maps_address_s *a = g_new0(maps_address_s, 1);
if (!a) {
+ //LCOV_EXCL_START
MAPS_LOGE("OUT_OF_MEMORY(0x%08x)", MAPS_ERROR_OUT_OF_MEMORY);
return MAPS_ERROR_OUT_OF_MEMORY;
+ //LCOV_EXCL_STOP
}
*address = (maps_address_h) a;
return MAPS_ERROR_NONE;
} while (false);
+ //LCOV_EXCL_START
maps_address_destroy(*cloned);
*cloned = NULL;
return error;
+ //LCOV_EXCL_STOP
}
/*----------------------------------------------------------------------------*/
maps_area_s *bound = g_new0(maps_area_s, 1);
if (bound == NULL) {
+ //LCOV_EXCL_START
MAPS_LOGE("OUT_OF_MEMORY(0x%08x)", MAPS_ERROR_OUT_OF_MEMORY);
return MAPS_ERROR_OUT_OF_MEMORY;
+ //LCOV_EXCL_STOP
}
bound->type = MAPS_AREA_RECTANGLE;
maps_area_s *bound = g_new0(maps_area_s, 1);
if (bound == NULL) {
+ //LCOV_EXCL_START
MAPS_LOGE("OUT_OF_MEMORY(0x%08x)", MAPS_ERROR_OUT_OF_MEMORY);
return MAPS_ERROR_OUT_OF_MEMORY;
+ //LCOV_EXCL_STOP
}
bound->type = MAPS_AREA_CIRCLE;
if (!view)
return false;
maps_service_h maps = _maps_view_get_maps_service_ptr(view);
- bool supported = false;
- if (maps_service_provider_is_service_supported(maps, service, &supported) != MAPS_ERROR_NONE)
- return false;
- return supported;
+ return maps_condition_check_service_supported(maps, service);
}
bool maps_condition_check_view_data_supported(maps_view_h view, maps_service_data_e data)
if (!view)
return false;
maps_service_h maps = _maps_view_get_maps_service_ptr(view);
- bool supported = false;
- if (maps_service_provider_is_data_supported(maps, data, &supported) != MAPS_ERROR_NONE)
- return false;
- return supported;
+ return maps_condition_check_data_supported(maps, data);
}
maps_coordinates_s *coord = g_new0(maps_coordinates_s, 1);
if (coord == NULL) {
+ //LCOV_EXCL_START
MAPS_LOGE("OUT_OF_MEMORY(0x%08x)", MAPS_ERROR_OUT_OF_MEMORY);
return MAPS_ERROR_OUT_OF_MEMORY;
+ //LCOV_EXCL_STOP
}
coord->latitude = latitude;
coord->longitude = longitude;
break;
return MAPS_ERROR_NONE;
} while (false);
+ //LCOV_EXCL_START
maps_coordinates_destroy(*cloned);
*cloned = NULL;
return error;
+ //LCOV_EXCL_STOP
}
/*----------------------------------------------------------------------------*/
maps_coordinates_s *coordinates = (maps_coordinates_s *) data;
ret = maps_coordinates_destroy(coordinates);
if (ret) {
- MAPS_LOGI("Failed to maps_coordinates_destroy!!!");
+ MAPS_LOGI("Failed to maps_coordinates_destroy!!!"); //LCOV_EXCL_LINE
}
}
maps_item_list_s *l = g_slice_new0(maps_item_list_s);
if (!l) {
+ //LCOV_EXCL_START
MAPS_LOGE("OUT_OF_MEMORY(0x%08x)", MAPS_ERROR_OUT_OF_MEMORY);
return MAPS_ERROR_OUT_OF_MEMORY;
+ //LCOV_EXCL_STOP
}
l->l = NULL;
void *clone = NULL;
if (clone_func) {
if (clone_func(data, &clone) != MAPS_ERROR_NONE)
- continue;
+ continue; //LCOV_EXCL_LINE
} else {
clone = data;
}
return MAPS_ERROR_NONE;
} while (false);
+ //LCOV_EXCL_START
maps_item_list_destroy(*cloned);
*cloned = NULL;
return error;
+ //LCOV_EXCL_STOP
}
EXPORT_API int maps_item_list_get_length(maps_item_list_h list, int *length)
maps_string_hashtable_s *t = g_slice_new0(maps_string_hashtable_s);
if (!t) {
+ //LCOV_EXCL_START
MAPS_LOGE("OUT_OF_MEMORY(0x%08x)", MAPS_ERROR_OUT_OF_MEMORY);
return MAPS_ERROR_OUT_OF_MEMORY;
+ //LCOV_EXCL_STOP
}
t->t = g_hash_table_new_full(g_str_hash, g_str_equal, g_free, g_free);
char *key_clone = NULL;
if (maps_item_hashtable_clone_string(key,
(void **) &key_clone) != MAPS_ERROR_NONE)
- continue;
+ continue; //LCOV_EXCL_LINE
char *value_clone = NULL;
if (maps_item_hashtable_clone_string(value,
(void **) &value_clone) != MAPS_ERROR_NONE)
- continue;
+ continue; //LCOV_EXCL_LINE
if (!callback(index++, total, key_clone, value_clone,
user_data))
g_hash_table_iter_init(&iter, t->t);
while (g_hash_table_iter_next(&iter, &key, &value)) {
g_hash_table_insert(t_cloned->t,
+ //LCOV_EXCL_START
(gpointer) g_strdup((const gchar *) key),
(gpointer) g_strdup((const gchar *) value));
+ //LCOV_EXCL_STOP
}
return MAPS_ERROR_NONE;
} while (false);
+ //LCOV_EXCL_START
maps_string_hashtable_destroy(*cloned);
*cloned = NULL;
return error;
+ //LCOV_EXCL_STOP
}
EXPORT_API int maps_string_hashtable_contains(maps_string_hashtable_h table,
maps_int_hashtable_s *t = g_slice_new0(maps_int_hashtable_s);
if (!t) {
+ //LCOV_EXCL_START
MAPS_LOGE("OUT_OF_MEMORY(0x%08x)", MAPS_ERROR_OUT_OF_MEMORY);
return MAPS_ERROR_OUT_OF_MEMORY;
+ //LCOV_EXCL_STOP
}
t->t = g_hash_table_new_full(g_int_hash, g_int_equal, g_free, g_free);
return MAPS_ERROR_INVALID_PARAMETER;
maps_int_hashtable_s *t = (maps_int_hashtable_s *) table;
if (!t->t)
- return MAPS_ERROR_NOT_FOUND;
+ return MAPS_ERROR_NOT_FOUND; //LCOV_EXCL_LINE
const int *table_value = (const int *) g_hash_table_lookup(t->t, &key);
if (!table_value)
return MAPS_ERROR_NONE;
maps_int_hashtable_s *t = (maps_int_hashtable_s *) table;
if (!t->t)
- return MAPS_ERROR_NOT_FOUND;
+ return MAPS_ERROR_NOT_FOUND; //LCOV_EXCL_LINE
GHashTableIter iter;
gpointer key, value;
return MAPS_ERROR_NONE;
} while (false);
+ //LCOV_EXCL_START
maps_int_hashtable_destroy(*cloned);
*cloned = NULL;
return error;
+ //LCOV_EXCL_STOP
}
EXPORT_API int maps_int_hashtable_contains(maps_int_hashtable_h table,
*item = g_slice_new0(maps_hashtable_item_s);
if (*item == NULL)
- MAPS_LOGE("OUT_OF_MEMORY(0x%08x)", MAPS_ERROR_OUT_OF_MEMORY);
+ MAPS_LOGE("OUT_OF_MEMORY(0x%08x)", MAPS_ERROR_OUT_OF_MEMORY); //LCOV_EXCL_LINE
}
void _maps_hashtable_item_destroy(gpointer data)
maps_item_hashtable_s *t = g_slice_new0(maps_item_hashtable_s);
if (!t) {
+ //LCOV_EXCL_START
MAPS_LOGE("OUT_OF_MEMORY(0x%08x)", MAPS_ERROR_OUT_OF_MEMORY);
return MAPS_ERROR_OUT_OF_MEMORY;
+ //LCOV_EXCL_STOP
}
t->t = g_hash_table_new_full(g_str_hash, g_str_equal, g_free,
int *n_cloned = g_new0(int, 1);
if (n_cloned == NULL) {
+ //LCOV_EXCL_START
MAPS_LOGE("OUT_OF_MEMORY(0x%08x)", MAPS_ERROR_OUT_OF_MEMORY);
return MAPS_ERROR_OUT_OF_MEMORY;
+ //LCOV_EXCL_STOP
}
int *n_origin = (int *) origin;
double *n_cloned = g_new0(double, 1);
if (n_cloned == NULL) {
+ //LCOV_EXCL_START
MAPS_LOGE("OUT_OF_MEMORY(0x%08x)", MAPS_ERROR_OUT_OF_MEMORY);
return MAPS_ERROR_OUT_OF_MEMORY;
+ //LCOV_EXCL_STOP
}
double *n_origin = (double *) origin;
const int error = clone_func((void *) value, &item->value);
if (error != MAPS_ERROR_NONE) {
+ //LCOV_EXCL_START
_maps_hashtable_item_destroy(item);
return error;
+ //LCOV_EXCL_STOP
}
item->clone_func = clone_func;
item->free_func = free_func;
while (g_hash_table_iter_next(&iter, &key, &value)) {
maps_hashtable_item_s *item = (maps_hashtable_item_s *) value;
if (!item || !item->clone_func)
- continue;
+ continue; //LCOV_EXCL_LINE
char *key_clone = NULL;
if (maps_item_hashtable_clone_string(key,
return MAPS_ERROR_NONE;
} while (false);
+ //LCOV_EXCL_START
maps_item_hashtable_destroy(*cloned);
*cloned = NULL;
return error;
+ //LCOV_EXCL_STOP
}
EXPORT_API int maps_item_hashtable_contains(maps_item_hashtable_h table,
*place = (maps_place_h) g_slice_new0(maps_place_s);
if (*place == NULL) {
+ //LCOV_EXCL_START
MAPS_LOGE("OUT_OF_MEMORY(0x%08x)", MAPS_ERROR_OUT_OF_MEMORY);
return MAPS_ERROR_OUT_OF_MEMORY;
+ //LCOV_EXCL_STOP
}
return MAPS_ERROR_NONE;
return MAPS_ERROR_NONE;
} while (false);
+ //LCOV_EXCL_START
maps_place_destroy(*cloned);
*cloned = NULL;
return error;
+ //LCOV_EXCL_STOP
}
/*----------------------------------------------------------------------------*/
*place = (maps_place_attribute_h) g_slice_new0(maps_place_attribute_s);
if (*place == NULL) {
+ //LCOV_EXCL_START
MAPS_LOGE("OUT_OF_MEMORY(0x%08x)", MAPS_ERROR_OUT_OF_MEMORY);
return MAPS_ERROR_OUT_OF_MEMORY;
+ //LCOV_EXCL_STOP
}
return MAPS_ERROR_NONE;
return MAPS_ERROR_NONE;
} while (false);
+ //LCOV_EXCL_START
maps_place_attribute_destroy(*cloned);
*cloned = NULL;
return error;
+ //LCOV_EXCL_STOP
}
/*----------------------------------------------------------------------------*/
*place = g_slice_new0(maps_place_category_s);
if (*place == NULL) {
+ //LCOV_EXCL_START
MAPS_LOGE("OUT_OF_MEMORY(0x%08x)", MAPS_ERROR_OUT_OF_MEMORY);
return MAPS_ERROR_OUT_OF_MEMORY;
+ //LCOV_EXCL_STOP
}
return MAPS_ERROR_NONE;
return MAPS_ERROR_NONE;
} while (false);
+ //LCOV_EXCL_START
maps_place_category_destroy(*cloned);
*cloned = NULL;
return error;
+ //LCOV_EXCL_STOP
}
/*----------------------------------------------------------------------------*/
*place = (maps_place_contact_h) g_slice_new0(maps_place_contact_s);
if (*place == NULL) {
+ //LCOV_EXCL_START
MAPS_LOGE("OUT_OF_MEMORY(0x%08x)", MAPS_ERROR_OUT_OF_MEMORY);
return MAPS_ERROR_OUT_OF_MEMORY;
+ //LCOV_EXCL_STOP
}
return MAPS_ERROR_NONE;
return MAPS_ERROR_NONE;
} while (false);
+ //LCOV_EXCL_START
maps_place_contact_destroy(*cloned);
*cloned = NULL;
return error;
+ //LCOV_EXCL_STOP
}
/*----------------------------------------------------------------------------*/
*place = (maps_place_editorial_h) g_slice_new0(maps_place_editorial_s);
if (*place == NULL) {
+ //LCOV_EXCL_START
MAPS_LOGE("OUT_OF_MEMORY(0x%08x)", MAPS_ERROR_OUT_OF_MEMORY);
return MAPS_ERROR_OUT_OF_MEMORY;
+ //LCOV_EXCL_STOP
}
return MAPS_ERROR_NONE;
return MAPS_ERROR_NONE;
} while (false);
+ //LCOV_EXCL_START
maps_place_editorial_destroy(*cloned);
*cloned = NULL;
return error;
+ //LCOV_EXCL_STOP
}
/*----------------------------------------------------------------------------*/
*filter = (maps_place_filter_h) g_slice_new0(maps_place_filter_s);
if (*filter == NULL) {
+ //LCOV_EXCL_START
MAPS_LOGE("OUT_OF_MEMORY(0x%08x)", MAPS_ERROR_OUT_OF_MEMORY);
return MAPS_ERROR_OUT_OF_MEMORY;
+ //LCOV_EXCL_STOP
}
maps_place_filter_s *f = (maps_place_filter_s *) (*filter);
return MAPS_ERROR_NONE;
} while (false);
+ //LCOV_EXCL_START
maps_place_filter_destroy(*cloned);
*cloned = NULL;
return error;
+ //LCOV_EXCL_STOP
}
/*----------------------------------------------------------------------------*/
*place = (maps_place_image_h) g_slice_new0(maps_place_image_s);
if (*place == NULL) {
+ //LCOV_EXCL_START
MAPS_LOGE("OUT_OF_MEMORY(0x%08x)", MAPS_ERROR_OUT_OF_MEMORY);
return MAPS_ERROR_OUT_OF_MEMORY;
+ //LCOV_EXCL_STOP
}
return MAPS_ERROR_NONE;
return MAPS_ERROR_NONE;
} while (false);
+ //LCOV_EXCL_START
maps_place_image_destroy(*cloned);
*cloned = NULL;
return error;
+ //LCOV_EXCL_STOP
}
/*----------------------------------------------------------------------------*/
g_slice_new0(maps_place_link_object_s);
if (*place == NULL) {
+ //LCOV_EXCL_START
MAPS_LOGE("OUT_OF_MEMORY(0x%08x)", MAPS_ERROR_OUT_OF_MEMORY);
return MAPS_ERROR_OUT_OF_MEMORY;
+ //LCOV_EXCL_STOP
}
return MAPS_ERROR_NONE;
return MAPS_ERROR_NONE;
} while (false);
+ //LCOV_EXCL_START
maps_place_link_object_destroy(*cloned);
*cloned = NULL;
return error;
+ //LCOV_EXCL_STOP
}
/*----------------------------------------------------------------------------*/
*place = (maps_place_media_h) g_slice_new0(maps_place_media_s);
if (*place == NULL) {
+ //LCOV_EXCL_START
MAPS_LOGE("OUT_OF_MEMORY(0x%08x)", MAPS_ERROR_OUT_OF_MEMORY);
return MAPS_ERROR_OUT_OF_MEMORY;
+ //LCOV_EXCL_STOP
}
return MAPS_ERROR_NONE;
return MAPS_ERROR_NONE;
} while (false);
+ //LCOV_EXCL_START
maps_place_media_destroy(*cloned);
*cloned = NULL;
return error;
+ //LCOV_EXCL_STOP
}
/*----------------------------------------------------------------------------*/
*place = (maps_place_rating_h) g_slice_new0(maps_place_rating_s);
if (*place == NULL) {
+ //LCOV_EXCL_START
MAPS_LOGE("OUT_OF_MEMORY(0x%08x)", MAPS_ERROR_OUT_OF_MEMORY);
return MAPS_ERROR_OUT_OF_MEMORY;
+ //LCOV_EXCL_STOP
}
return MAPS_ERROR_NONE;
return MAPS_ERROR_NONE;
} while (false);
+ //LCOV_EXCL_START
maps_place_rating_destroy(*cloned);
*cloned = NULL;
return error;
+ //LCOV_EXCL_STOP
}
/*----------------------------------------------------------------------------*/
*place = (maps_place_review_h) g_slice_new0(maps_place_review_s);
if (*place == NULL) {
+ //LCOV_EXCL_START
MAPS_LOGE("OUT_OF_MEMORY(0x%08x)", MAPS_ERROR_OUT_OF_MEMORY);
return MAPS_ERROR_OUT_OF_MEMORY;
+ //LCOV_EXCL_STOP
}
return MAPS_ERROR_NONE;
return MAPS_ERROR_NONE;
} while (false);
+ //LCOV_EXCL_START
maps_place_review_destroy(*cloned);
*cloned = NULL;
return error;
+ //LCOV_EXCL_STOP
}
/*----------------------------------------------------------------------------*/
*place = (maps_place_url_h) g_slice_new0(maps_place_url_s);
if (*place == NULL) {
+ //LCOV_EXCL_START
MAPS_LOGE("OUT_OF_MEMORY(0x%08x)", MAPS_ERROR_OUT_OF_MEMORY);
return MAPS_ERROR_OUT_OF_MEMORY;
+ //LCOV_EXCL_STOP
}
return MAPS_ERROR_NONE;
return MAPS_ERROR_NONE;
} while (false);
+ //LCOV_EXCL_START
maps_place_url_destroy(*cloned);
*cloned = NULL;
return error;
+ //LCOV_EXCL_STOP
}
/*----------------------------------------------------------------------------*/
*info = g_slice_new0(maps_plugin_info_s);
if (*info == NULL) {
+ //LCOV_EXCL_START
MAPS_LOGE("OUT_OF_MEMORY(0x%08x)", MAPS_ERROR_OUT_OF_MEMORY);
return MAPS_ERROR_OUT_OF_MEMORY;
+ //LCOV_EXCL_STOP
}
return MAPS_ERROR_NONE;
return MAPS_ERROR_NONE;
} while (false);
+ //LCOV_EXCL_START
maps_plugin_info_destroy(*cloned);
*cloned = NULL;
return error;
+ //LCOV_EXCL_STOP
}
/*----------------------------------------------------------------------------*/
return MAPS_ERROR_NONE;
} while (0);
+ //LCOV_EXCL_START
maps_item_hashtable_destroy(preference);
return error;
+ //LCOV_EXCL_STOP
}
EXPORT_API int maps_preference_destroy(maps_preference_h preference)
*route = (maps_route_h) g_slice_new0(maps_route_s);
if (*route == NULL) {
+ //LCOV_EXCL_START
MAPS_LOGE("OUT_OF_MEMORY(0x%08x)", MAPS_ERROR_OUT_OF_MEMORY);
return MAPS_ERROR_OUT_OF_MEMORY;
+ //LCOV_EXCL_STOP
}
return MAPS_ERROR_NONE;
return MAPS_ERROR_NONE;
} while (false);
+ //LCOV_EXCL_START
maps_route_destroy(*cloned);
*cloned = NULL;
return error;
+ //LCOV_EXCL_STOP
}
/*----------------------------------------------------------------------------*/
*maneuver = (maps_route_maneuver_h) g_slice_new0(maps_route_maneuver_s);
if (*maneuver == NULL) {
+ //LCOV_EXCL_START
MAPS_LOGE("OUT_OF_MEMORY(0x%08x)", MAPS_ERROR_OUT_OF_MEMORY);
return MAPS_ERROR_OUT_OF_MEMORY;
+ //LCOV_EXCL_STOP
}
return MAPS_ERROR_NONE;
return MAPS_ERROR_NONE;
} while (false);
+ //LCOV_EXCL_START
maps_route_maneuver_destroy(*cloned);
*cloned = NULL;
return error;
+ //LCOV_EXCL_STOP
}
/*----------------------------------------------------------------------------*/
*segment = (maps_route_segment_h) g_slice_new0(maps_route_segment_s);
if (*segment == NULL) {
+ //LCOV_EXCL_START
MAPS_LOGE("OUT_OF_MEMORY(0x%08x)", MAPS_ERROR_OUT_OF_MEMORY);
return MAPS_ERROR_OUT_OF_MEMORY;
+ //LCOV_EXCL_STOP
}
return MAPS_ERROR_NONE;
return MAPS_ERROR_NONE;
} while (false);
+ //LCOV_EXCL_START
maps_route_segment_destroy(*cloned);
*cloned = NULL;
return error;
+ //LCOV_EXCL_STOP
}
/*----------------------------------------------------------------------------*/
return (plugin::plugin_s *) maps_service->plugin;
}
-static bool __maps_provider_supported(maps_service_h maps, maps_service_e service)
-{
- if (!maps)
- return false;
- bool supported = false;
- if (maps_service_provider_is_service_supported(maps, service, &supported)
- != MAPS_ERROR_NONE)
- return false;
- return supported;
-}
-
-
/*----------------------------------------------------------------------------*/
/* */
/* Maps Service & Preference */
if (!maps || !maps_provider)
return MAPS_ERROR_INVALID_PARAMETER;
if (!maps_condition_check_privilege()) {
+ //LCOV_EXCL_START
MAPS_LOGD("ERROR: privilege is not included");
return MAPS_ERROR_PERMISSION_DENIED;
+ //LCOV_EXCL_STOP
}
int error = MAPS_ERROR_NOT_SUPPORTED;
maps_service_s *maps_service = g_slice_new0(maps_service_s);
if (maps_service == NULL) {
+ //LCOV_EXCL_START
MAPS_LOGE("OUT_OF_MEMORY(0x%08x)", MAPS_ERROR_OUT_OF_MEMORY);
error = MAPS_ERROR_OUT_OF_MEMORY;
break;
+ //LCOV_EXCL_STOP
}
/* 3. Initialize the requested plugin */
int init_error = MAPS_ERROR_NONE; /* Storage for init error code */
maps_plugin_h plugin_h = plugin::binary_extractor().init(info, module, &init_error);
if (!plugin_h) {
+ //LCOV_EXCL_START
error = init_error;
MAPS_LOGE("ERROR! Plugin init failed");
break;
+ //LCOV_EXCL_STOP
}
maps_service->plugin = plugin_h;
return MAPS_ERROR_INVALID_PARAMETER;
/* Check if this API feature available */
- if (!__maps_provider_supported(maps, MAPS_SERVICE_GEOCODE))
+ if (!maps_condition_check_service_supported(maps, MAPS_SERVICE_GEOCODE))
return MAPS_ERROR_NOT_SUPPORTED;
/* Check if parameters are valid */
return MAPS_ERROR_INVALID_PARAMETER;
/* Check if this API feature available */
- if (!__maps_provider_supported(maps,
- MAPS_SERVICE_GEOCODE_INSIDE_AREA))
+ if (!maps_condition_check_service_supported(maps, MAPS_SERVICE_GEOCODE_INSIDE_AREA))
return MAPS_ERROR_NOT_SUPPORTED;
/* Check if parameters are valid */
return MAPS_ERROR_INVALID_PARAMETER;
/* Check if this API feature available */
- if (!__maps_provider_supported(maps,
- MAPS_SERVICE_GEOCODE_BY_STRUCTURED_ADDRESS))
+ if (!maps_condition_check_service_supported(maps, MAPS_SERVICE_GEOCODE_BY_STRUCTURED_ADDRESS))
return MAPS_ERROR_NOT_SUPPORTED;
/* Check if parameters are valid */
return MAPS_ERROR_INVALID_PARAMETER;
/* Check if this API feature available */
- if (!__maps_provider_supported(maps, MAPS_SERVICE_REVERSE_GEOCODE))
+ if (!maps_condition_check_service_supported(maps, MAPS_SERVICE_REVERSE_GEOCODE))
return MAPS_ERROR_NOT_SUPPORTED;
/* Check if parameters are valid */
return MAPS_ERROR_INVALID_PARAMETER;
/* Check if this API feature available */
- if (!__maps_provider_supported(maps, MAPS_SERVICE_SEARCH_PLACE))
+ if (!maps_condition_check_service_supported(maps, MAPS_SERVICE_SEARCH_PLACE))
return MAPS_ERROR_NOT_SUPPORTED;
/* Check if parameters are valid */
return MAPS_ERROR_INVALID_PARAMETER;
/* Check if this API feature available */
- if (!__maps_provider_supported(maps,
- MAPS_SERVICE_SEARCH_PLACE_BY_AREA))
+ if (!maps_condition_check_service_supported(maps, MAPS_SERVICE_SEARCH_PLACE_BY_AREA))
return MAPS_ERROR_NOT_SUPPORTED;
/* Check if parameters are valid */
return MAPS_ERROR_INVALID_PARAMETER;
/* Check if this API feature available */
- if (!__maps_provider_supported(maps,
- MAPS_SERVICE_SEARCH_PLACE_BY_ADDRESS))
+ if (!maps_condition_check_service_supported(maps, MAPS_SERVICE_SEARCH_PLACE_BY_ADDRESS))
return MAPS_ERROR_NOT_SUPPORTED;
/* Check if parameters are valid */
if (!maps)
return MAPS_ERROR_INVALID_PARAMETER;
- if (!__maps_provider_supported(maps, MAPS_SERVICE_SEARCH_PLACE_LIST))
+ if (!maps_condition_check_service_supported(maps, MAPS_SERVICE_SEARCH_PLACE_LIST))
return MAPS_ERROR_NOT_SUPPORTED;
if (!boundary || !filter || !callback || !request_id)
if (!maps)
return MAPS_ERROR_INVALID_PARAMETER;
- if (!__maps_provider_supported(maps, MAPS_SERVICE_SEARCH_GET_PLACE_DETAILS))
+ if (!maps_condition_check_service_supported(maps, MAPS_SERVICE_SEARCH_GET_PLACE_DETAILS))
return MAPS_ERROR_NOT_SUPPORTED;
if (!url || !callback || !request_id)
return MAPS_ERROR_INVALID_PARAMETER;
/* Check if this API feature available */
- if (!__maps_provider_supported(maps, MAPS_SERVICE_SEARCH_ROUTE))
+ if (!maps_condition_check_service_supported(maps, MAPS_SERVICE_SEARCH_ROUTE))
return MAPS_ERROR_NOT_SUPPORTED;
/* Check if parameters are valid */
return MAPS_ERROR_INVALID_PARAMETER;
/* Check if this API feature available */
- if (!__maps_provider_supported(maps,
+ if (!maps_condition_check_service_supported(maps,
MAPS_SERVICE_SEARCH_ROUTE_WAYPOINTS))
return MAPS_ERROR_NOT_SUPPORTED;
return MAPS_ERROR_INVALID_PARAMETER;
/* Check if this API feature available */
- if (!__maps_provider_supported(maps, MAPS_SERVICE_CANCEL_REQUEST))
+ if (!maps_condition_check_service_supported(maps, MAPS_SERVICE_CANCEL_REQUEST))
return MAPS_ERROR_NOT_SUPPORTED;
/* Check if parameters are valid */
if (!maps)
return MAPS_ERROR_INVALID_PARAMETER;
- if (!__maps_provider_supported(maps, MAPS_SERVICE_MULTI_REVERSE_GEOCODE))
+ if (!maps_condition_check_service_supported(maps, MAPS_SERVICE_MULTI_REVERSE_GEOCODE))
return MAPS_ERROR_NOT_SUPPORTED;
if (!coordinates_list || !callback || !request_id)
/* empty */
}
+//LCOV_EXCL_START
session::command_queue *__maps_view_select_q()
{
/*
return MAPS_ERROR_NOT_FOUND;
return maps_item_list_foreach(v->view_objects, NULL, _maps_view_object_overlay_cb, v->clipper);
}
+//LCOV_EXCL_STOP
int _maps_view_on_object_operation(maps_view_h view, maps_view_object_h object, maps_view_object_operation_e operation)
{
}
}
+//LCOV_EXCL_START
static void __on_canvas_tap(void *data, Evas *e, Evas_Object *obj, void *event_info)
{
MAPS_LOGI("__on_canvas_tap");
/* Detect & Process the gesture */
v->finger_stream->multi_move((Evas_Event_Multi_Move *)event_info);
}
+//LCOV_EXCL_STOP
static int __maps_plugin_render_map(const maps_view_h view,
const maps_coordinates_h coordinates, const double zoom_factor, const double rotation_angle)
coordinates, zoom_factor, rotation_angle);
}
+//LCOV_EXCL_START
void _maps_view_set_idle_listener(const maps_view_h view,
void (*callback)(void *user_data), void *user_data)
{
{
return ECORE_CALLBACK_RENEW;
}
+//LCOV_EXCL_STOP
void __maps_view_ready(const maps_view_h view)
{
/* ----------------------CREATE AND DESTROY-----------------------------------*/
+//LCOV_EXCL_START
static void __maps_view_parent_resize_cb(void *data, Evas *e, Evas_Object *obj, void *event_info)
{
maps_view_s *v = (maps_view_s*)data;
_maps_view_get_plugin_center(v, &v->center);
maps_view_set_screen_location(v, x, y, w, h);
}
+//LCOV_EXCL_STOP
static void __maps_view_create_panel(maps_view_h view, Evas_Object *obj)
{
maps_view_s *v = g_slice_new0(maps_view_s);
if (!v) {
+ //LCOV_EXCL_START
MAPS_LOGE("OUT_OF_MEMORY(0x%08x)", MAPS_ERROR_OUT_OF_MEMORY);
return MAPS_ERROR_OUT_OF_MEMORY;
+ //LCOV_EXCL_STOP
}
/* Initialize the list with visual objects */
/* Gesture Processing */
v->finger_stream = new view::finger_event_stream(v);
if (!v->finger_stream) {
+ //LCOV_EXCL_START
MAPS_LOGE("OUT_OF_MEMORY(0x%08x)", MAPS_ERROR_OUT_OF_MEMORY);
return MAPS_ERROR_OUT_OF_MEMORY;
+ //LCOV_EXCL_STOP
}
evas_object_event_callback_add(v->panel, EVAS_CALLBACK_MOUSE_DOWN, __on_canvas_tap, v);
evas_object_event_callback_add(v->panel, EVAS_CALLBACK_MOUSE_UP, __on_canvas_up, v);
return MAPS_ERROR_NONE;
}
-
+//LCOV_EXCL_START
int _maps_view_set_center_directly(const maps_view_h view,
const maps_coordinates_h coordinates)
{
return __get_plugin_interface(view)->maps_plugin_get_center(view, center);
}
+//LCOV_EXCL_STOP
/*----------------------MAP ZOOM, ROTATE, SET CENTER--------------------------*/
return __maps_view_set_center(view, coordinates, FALSE);
}
+//LCOV_EXCL_START
int _maps_view_move_center(maps_view_h view, const int delta_x, const int delta_y)
{
if (!view)
return error;
}
+//LCOV_EXCL_STOP
EXPORT_API int maps_view_set_scalebar_enabled(const maps_view_h view, bool enable)
{
/* Add inertia to the zoom process */
if (v->inertial_camera)
- v->inertial_camera->set_zoom_target(double(new_level));
+ v->inertial_camera->set_zoom_target(double(new_level)); //LCOV_EXCL_LINE
v->zoom_level = new_level;
v->zoom_factor = double(new_level); /* Update the integer zoom level too */
if (rotation_changed) {
/* Add inertia to the rotation process */
if (v->inertial_camera)
- v->inertial_camera->set_rotation_target(angle);
+ v->inertial_camera->set_rotation_target(angle); //LCOV_EXCL_LINE
/* Update Map View rotation angle */
v->rotation_angle = angle;
maps_view_event_data_h ed =
_maps_view_create_event_data(MAPS_VIEW_EVENT_ACTION);
if (ed) {
+ //LCOV_EXCL_START
_maps_view_event_data_set_action_type(ed, MAPS_VIEW_ACTION_ZOOM);
_maps_view_event_data_set_zoom_factor(ed, v->zoom_factor);
_maps_view_invoke_event_callback(v, ed);
maps_view_event_data_destroy(ed);
+ //LCOV_EXCL_STOP
}
}
/* Add inertia to the rotation process */
maps_view_s *v = (maps_view_s *)view;
if (v->inertial_camera)
- v->inertial_camera->set_rotation_target(angle);
+ v->inertial_camera->set_rotation_target(angle); //LCOV_EXCL_LINE
return _maps_view_set_zoom_rotate(view, false, .0, true, angle);
}
if (!v->inertial_gesture) {
v->inertial_gesture = new view::inertial_gesture(view);
if (!v->inertial_gesture) {
+ //LCOV_EXCL_START
MAPS_LOGE("OUT_OF_MEMORY(0x%08x)", MAPS_ERROR_OUT_OF_MEMORY);
return MAPS_ERROR_OUT_OF_MEMORY;
+ //LCOV_EXCL_STOP
}
}
if (!v->inertial_camera) {
v->inertial_camera = new view::inertial_camera(view);
if (!v->inertial_camera) {
+ //LCOV_EXCL_START
MAPS_LOGE("OUT_OF_MEMORY(0x%08x)", MAPS_ERROR_OUT_OF_MEMORY);
return MAPS_ERROR_OUT_OF_MEMORY;
+ //LCOV_EXCL_STOP
}
}
return MAPS_ERROR_NONE;
}
+//LCOV_EXCL_START
EXPORT_API int maps_view_get_inertia_enabled(maps_view_h view, bool *enabled)
{
if (!maps_condition_check_maps_feature())
*enabled = v->inertial_camera != NULL;
return MAPS_ERROR_NONE;
}
+//LCOV_EXCL_STOP
EXPORT_API int maps_view_set_language(maps_view_h view, const char *language)
{
return MAPS_ERROR_NONE;
}
+//LCOV_EXCL_START
int _maps_view_redraw(const maps_view_h view)
{
if (!view)
return MAPS_ERROR_NONE;
}
+//LCOV_EXCL_STOP
/* ---------------------USER CONTROL------------------------------------------*/
return MAPS_ERROR_NONE;
} while (false);
- return error;
+ return error; //LCOV_EXCL_LINE
}
EXPORT_API int maps_view_remove_object(maps_view_h view, maps_view_object_h object)
/* Redraw the view */
error = _maps_view_redraw(v);
if (error != MAPS_ERROR_NONE)
- return error;
+ return error; //LCOV_EXCL_LINE
return MAPS_ERROR_NONE;
} while (false);
/* Redraw the view */
error = _maps_view_redraw(v);
if (error != MAPS_ERROR_NONE)
- return error;
+ return error; //LCOV_EXCL_LINE
return MAPS_ERROR_NONE;
} while (false);
maps_view_event_data_h event_data = NULL;
const int error = _maps_view_event_data_create(&event_data);
if (error != MAPS_ERROR_NONE) {
+ //LCOV_EXCL_START
maps_view_event_data_destroy(event_data);
return NULL;
+ //LCOV_EXCL_STOP
}
if (!event_data)
return NULL;
void _maps_view_invoke_event_callback(maps_view_h view, maps_view_event_data_h event_data)
{
if (!view || !event_data)
- return;
+ return; //LCOV_EXCL_LINE
maps_view_s *v = (maps_view_s *)view;
view::poly_shape_hit_test *pd;
} maps_view_collect_poly_object_point_s;
-
+//LCOV_EXCL_START
static bool __maps_view_object_poly_collect_points_cb(int index, maps_coordinates_h point, void *user_data)
{
if (!point || !user_data)
/* 2. Extract test result */
return htd.object;
}
+//LCOV_EXCL_STOP
EXPORT_API int maps_view_get_maps_plugin_view_handle(maps_view_h view, void **maps_plugin_view_handle)
{
/* Applicable for gesture */
int x;
int y;
- maps_coordinates_h coordinates;
+ maps_coordinates_h coordinates;
/* Applicable for center move */
int delta_x;
maps_view_event_data_s *e = g_slice_new0(maps_view_event_data_s);
if (!e) {
+ //LCOV_EXCL_START
MAPS_LOGE("OUT_OF_MEMORY(0x%08x)", MAPS_ERROR_OUT_OF_MEMORY);
return MAPS_ERROR_OUT_OF_MEMORY;
+ //LCOV_EXCL_STOP
}
e->event_type = MAPS_VIEW_EVENT_GESTURE;
return MAPS_ERROR_NONE;
}
+//LCOV_EXCL_START
EXPORT_API int maps_view_event_data_clone(const maps_view_event_data_h origin, maps_view_event_data_h *cloned)
{
if (!maps_condition_check_maps_feature())
return MAPS_ERROR_INVALID_PARAMETER;
maps_view_event_data_s *e = (maps_view_event_data_s *) event;
if (e->center)
- maps_coordinates_destroy(e->center);
+ maps_coordinates_destroy(e->center); //LCOV_EXCL_LINE
return maps_coordinates_clone(center, &e->center);
}
*object = e->object;
return MAPS_ERROR_NONE;
}
+//LCOV_EXCL_STOP
do {
p = g_slice_new0(maps_view_polyline_data_s);
if (!p) {
+ //LCOV_EXCL_START
MAPS_LOGE("OUT_OF_MEMORY(0x%08x)",
MAPS_ERROR_OUT_OF_MEMORY);
return MAPS_ERROR_OUT_OF_MEMORY;
+ //LCOV_EXCL_STOP
}
error = maps_coordinates_list_create(&p->points);
return MAPS_ERROR_NONE;
} while (false);
+ //LCOV_EXCL_START
__maps_view_polyline_data_destroy(p);
return error;
+ //LCOV_EXCL_STOP
}
static int __maps_view_polyline_data_destroy(void *polyline)
do {
p = g_slice_new0(maps_view_polygon_data_s);
if (!p) {
+ //LCOV_EXCL_START
MAPS_LOGE("OUT_OF_MEMORY(0x%08x)",
MAPS_ERROR_OUT_OF_MEMORY);
return MAPS_ERROR_OUT_OF_MEMORY;
+ //LCOV_EXCL_STOP
}
error = maps_coordinates_list_create(&p->points);
return MAPS_ERROR_NONE;
} while (false);
+ //LCOV_EXCL_START
__maps_view_polygon_data_destroy(p);
return error;
+ //LCOV_EXCL_STOP
}
static int __maps_view_polygon_data_destroy(void *polygon)
do {
m = g_slice_new0(maps_view_marker_data_s);
if (!m) {
+ //LCOV_EXCL_START
MAPS_LOGE("OUT_OF_MEMORY(0x%08x)",
MAPS_ERROR_OUT_OF_MEMORY);
return MAPS_ERROR_OUT_OF_MEMORY;
+ //LCOV_EXCL_STOP
}
error = maps_coordinates_create(.0, .0, &m->coordinates);
return MAPS_ERROR_NONE;
} while (false);
+ //LCOV_EXCL_START
__maps_view_marker_data_destroy(m);
return error;
+ //LCOV_EXCL_STOP
}
static int __maps_view_marker_data_destroy(void *marker)
do {
m = g_slice_new0(maps_view_overlay_data_s);
if (!m) {
+ //LCOV_EXCL_START
MAPS_LOGE("OUT_OF_MEMORY(0x%08x)",
MAPS_ERROR_OUT_OF_MEMORY);
return MAPS_ERROR_OUT_OF_MEMORY;
+ //LCOV_EXCL_STOP
}
error = maps_coordinates_create(.0, .0, &m->coordinates);
return MAPS_ERROR_NONE;
} while (false);
+ //LCOV_EXCL_START
__maps_view_overlay_data_destroy(m);
return error;
+ //LCOV_EXCL_STOP
}
static int __maps_view_overlay_data_destroy(void *overlay)
do {
o = g_slice_new0(maps_view_object_s);
if (!o) {
+ //LCOV_EXCL_START
MAPS_LOGE("OUT_OF_MEMORY(0x%08x)",
MAPS_ERROR_OUT_OF_MEMORY);
return MAPS_ERROR_OUT_OF_MEMORY;
+ //LCOV_EXCL_STOP
}
o->type = type;
*object = (maps_view_object_h) o;
return MAPS_ERROR_NONE;
} while (false);
+ //LCOV_EXCL_START
maps_view_object_destroy(o);
return error;
+ //LCOV_EXCL_STOP
}
int _maps_view_object_set_view(maps_view_object_h object, maps_view_h view)
return pc.get_error();
/* Polyline create failure */
+ //LCOV_EXCL_START
maps_view_object_destroy(*polyline);
*polyline = NULL;
return pc.get_error();
+ //LCOV_EXCL_STOP
}
EXPORT_API int maps_view_object_create_polygon(maps_coordinates_list_h coordinates,
return pc.get_error();
/* Polygon create failure */
+ //LCOV_EXCL_START
maps_view_object_destroy(*polygon);
*polygon = NULL;
return pc.get_error();
+ //LCOV_EXCL_STOP
}
EXPORT_API int maps_view_object_create_overlay(maps_coordinates_h coordinates,
return pc.get_error();
/* Overlay create failure */
+ //LCOV_EXCL_START
maps_view_object_destroy(*overlay);
*overlay = NULL;
return pc.get_error();
+ //LCOV_EXCL_STOP
}
EXPORT_API int maps_view_object_destroy(maps_view_object_h object)
return MAPS_ERROR_NONE;
}
+//LCOV_EXCL_START
int _maps_view_object_overlay_get_bubble(maps_view_object_h overlay, Evas_Object **object)
{
if (!overlay || !object)
*object = m->bubble;
return MAPS_ERROR_NONE;
}
+//LCOV_EXCL_STOP
int _maps_view_object_overlay_set_bubble(maps_view_object_h overlay)
{
return ret;
}
+//LCOV_EXCL_START
bool _maps_view_object_overlay_cb(int index, int total, maps_view_object_h object, void *user_data)
{
if (!object || !user_data)
return true;
return __maps_view_object_overlay_update(object, (Evas_Object*)user_data);
}
+//LCOV_EXCL_STOP
int _maps_view_object_overlay_operation(maps_view_h view, maps_view_object_h object, maps_view_object_operation_e operation)
{
int i;
if (fp == NULL) {
- MAPS_LOGE("fopen fail");
+ MAPS_LOGE("fopen fail"); //LCOV_EXCL_LINE
return false;
}
bmpfile_header.filesz = sizeof(bmpfile_magic) + sizeof(bmpfile_header) + sizeof(bmp_dib_v3_header_t) + (width * height * 3);
if (error != MAPS_ERROR_NONE) break;
if (cs != MAPS_VIEW_COLORSPACE_RGBA8888 && cs != MAPS_VIEW_COLORSPACE_BGRA8888) {
+ //LCOV_EXCL_START
MAPS_LOGE("The color space is not supported yet. (%d)", cs);
error = MAPS_ERROR_INVALID_OPERATION;
+ //LCOV_EXCL_STOP
break;
}
return MAPS_ERROR_NONE;
}
+//LCOV_EXCL_START
tizen_profile_t _get_tizen_profile()
{
static tizen_profile_t profile = TIZEN_PROFILE_UNKNOWN;
return profile;
}
+//LCOV_EXCL_STOP
#define MAPS_BASE_DATE_MAX_LEN 32
#define MAPS_PLUGINS_PATH_PREFIX LIBDIR"/maps/plugins"
+//LCOV_EXCL_START
/*
* Internal Macros
*/
return !pstring || (*this == string(""));
}
};
+//LCOV_EXCL_STOP
typedef enum {
TIZEN_PROFILE_UNKNOWN = 0,
{
}
+//LCOV_EXCL_START
plugin::provider_info::provider_info(const string &p, const string &f)
: provider(p)
, file(f)
{
}
+//LCOV_EXCL_STOP
plugin::provider_info::provider_info(const provider_info &src)
{
/* Request the next plugin binary to get provider info */
const provider_info info = be.get_plugin_info(l[i]);
if (info.empty())
- continue;
+ continue; //LCOV_EXCL_LINE
/* Add provider info to the resulting list */
v.push_back(info);
g_pattern_spec_free(plugin_name_pattern);
g_dir_close(dir);
+ //LCOV_EXCL_START
} else if (error) {
MAPS_LOGE("%d: Can not open directory: %s\n", error->code, error->message);
+ //LCOV_EXCL_STOP
}
return l;
(const char*)uc->provider, user_consent_cb, (void*)uc);
MAPS_LOGD("maps_plugin_request_user_consent = %d", error);
if (error == MAPS_ERROR_USER_NOT_CONSENTED)
- error = MAPS_ERROR_NONE;
+ error = MAPS_ERROR_NONE; //LCOV_EXCL_LINE
}
}
/* 3. shutdown plugin */
if (error != MAPS_ERROR_NONE) {
+ //LCOV_EXCL_START
plugin::user_consent_checker().shutdown(plugin_handle);
if (uc) {
g_free(uc->provider);
g_free(uc);
}
+ //LCOV_EXCL_STOP
}
return error;
#include "maps_util.h"
+//LCOV_EXCL_START
namespace plugin
{
void user_consent_cb(bool consented, const char *provider, void *user_data);
int request_user_consent(const char *maps_provider, void* callback, void *user_data);
}
+//LCOV_EXCL_STOP
#endif /* __MAPS_SERVICE_PLUGIN_DISCOVERY_H__ */
\ No newline at end of file
/* Set of empty functions */
/* Plugin dedicated functions */
+//LCOV_EXCL_START
int maps_plugin_init_empty(maps_plugin_h *plugin)
{
return 0;
{
return &empty_interface;
}
+//LCOV_EXCL_STOP
string &file_name) const
{
if (file_name.empty())
- return provider_info::empty_instance;
+ return provider_info::empty_instance; //LCOV_EXCL_LINE
/* 1.Initialize plugin */
GMod *plugin = gmod_new(file_name, FALSE);
if (!plugin)
- return provider_info::empty_instance;
+ return provider_info::empty_instance; //LCOV_EXCL_LINE
provider_info info;
{
/* 1.Initialize plugin */
if (info.file.empty() || !init_error) {
+ //LCOV_EXCL_START
if (init_error)
*init_error = MAPS_ERROR_NOT_SUPPORTED;
return NULL;
+ //LCOV_EXCL_STOP
}
*init_error = MAPS_ERROR_NONE;
GMod *plugin = gmod_new(info.file, TRUE);
if (!plugin) {
+ //LCOV_EXCL_START
MAPS_LOGE("Open Module Failed: %s", info.file.c_str());
*init_error = MAPS_ERROR_SERVICE_NOT_AVAILABLE;
return NULL;
+ //LCOV_EXCL_STOP
}
/* 2.1 Create new plugin interface */
/* 2. Perform steps to completely initialize a plugin */
do {
if (!new_plugin) {
+ //LCOV_EXCL_START
MAPS_LOGE("OUT_OF_MEMORY(0x%08x)", MAPS_ERROR_OUT_OF_MEMORY);
*init_error = MAPS_ERROR_OUT_OF_MEMORY;
break;
+ //LCOV_EXCL_STOP
}
/* 2.1 Set plugin module handle */
/* 2.3 Check whether the plugin init function is valid */
if (!new_plugin->interface.maps_plugin_init) {
+ //LCOV_EXCL_START
MAPS_LOGE("ERROR! Plugin initialization function is invalid");
*init_error = MAPS_ERROR_SERVICE_NOT_AVAILABLE;
break;
+ //LCOV_EXCL_STOP
}
/* 2.4 Call a plugin to initialize itself, send to the plugin
if (!module || !new_plugin->interface.maps_plugin_init_module)
ret = new_plugin->interface.maps_plugin_init((maps_plugin_h *) (&new_plugin));
else
- ret = new_plugin->interface.maps_plugin_init_module((maps_plugin_h *) (&new_plugin), module);
+ ret = new_plugin->interface.maps_plugin_init_module((maps_plugin_h *) (&new_plugin), module); //LCOV_EXCL_LINE
if (ret != MAPS_ERROR_NONE) {
+ //LCOV_EXCL_START
MAPS_LOGE("ERROR! Plugin initialization function failed: %d", ret);
*init_error = ret;
break;
+ //LCOV_EXCL_STOP
}
if (!new_plugin->interface.maps_plugin_set_provider_key) {
+ //LCOV_EXCL_START
MAPS_LOGE("ERROR! Plugin set_provider_key function is NULL");
*init_error = MAPS_ERROR_SERVICE_NOT_AVAILABLE;
break;
+ //LCOV_EXCL_STOP
}
if (!new_plugin->interface.maps_plugin_get_provider_key) {
+ //LCOV_EXCL_START
MAPS_LOGE("ERROR! Plugin set_provider_key function is NULL");
*init_error = MAPS_ERROR_SERVICE_NOT_AVAILABLE;
break;
+ //LCOV_EXCL_STOP
}
if (!new_plugin->interface.maps_plugin_set_preference) {
+ //LCOV_EXCL_START
MAPS_LOGE("ERROR! Plugin set_preference function is NULL");
*init_error = MAPS_ERROR_SERVICE_NOT_AVAILABLE;
break;
}
if (!new_plugin->interface.maps_plugin_get_preference) {
+ //LCOV_EXCL_START
MAPS_LOGE("ERROR! Plugin get_preference function is NULL");
*init_error = MAPS_ERROR_SERVICE_NOT_AVAILABLE;
break;
+ //LCOV_EXCL_STOP
}
if (!new_plugin->interface.maps_plugin_is_data_supported) {
+ //LCOV_EXCL_START
MAPS_LOGE("ERROR! Plugin support_is_data_supported function is NULL");
*init_error = MAPS_ERROR_SERVICE_NOT_AVAILABLE;
break;
+ //LCOV_EXCL_STOP
}
if (!new_plugin->interface.maps_plugin_is_service_supported) {
+ //LCOV_EXCL_START
MAPS_LOGE("ERROR! Plugin support_is_service_supported function is NULL");
*init_error = MAPS_ERROR_SERVICE_NOT_AVAILABLE;
break;
+ //LCOV_EXCL_STOP
}
/* 2.7 Create a queue with asynchronous requests to plugin */
g_hash_table_new_full(g_int_hash, g_int_equal, g_free,
session::command_handler::destroy);
if (!new_plugin->pending_request_maps) {
+ //LCOV_EXCL_START
MAPS_LOGE("OUT_OF_MEMORY(0x%08x)", MAPS_ERROR_OUT_OF_MEMORY);
*init_error = MAPS_ERROR_OUT_OF_MEMORY;
break;
+ //LCOV_EXCL_STOP
}
g_mutex_init(&new_plugin->pending_request_mutex);
return new_plugin;
} while (FALSE);
+ //LCOV_EXCL_START
MAPS_LOGE("Shut down the plugin becuause of error");
/* 3. shutdown plugin in case of problem */
shutdown(new_plugin);
return NULL;
+ //LCOV_EXCL_STOP
}
void plugin::binary_extractor::shutdown(maps_plugin_h plugin_h)
/* 2. Destroy the request queue */
if (plugin->request_queue)
- g_async_queue_unref(plugin->request_queue);
+ g_async_queue_unref(plugin->request_queue); //LCOV_EXCL_LINE
/* 3. Destroy the map of pending requests */
if (plugin->pending_request_maps) {
gboolean is_resident) const
{
if (!g_module_supported()) {
+ //LCOV_EXCL_START
MAPS_LOGE("ERROR! g_module_supported is false\n\n");
return NULL;
+ //LCOV_EXCL_STOP
}
if (module_file.empty())
gmod->name = g_strdup(module_file.c_str());
if (!gmod->name) {
+ //LCOV_EXCL_START
g_free(gmod);
return NULL;
+ //LCOV_EXCL_STOP
}
gmod->path = g_strnfill(100, 0);
g_sprintf(gmod->path, "%s/%s", MAPS_PLUGINS_PATH_PREFIX, gmod->name);
if (!gmod->path) {
+ //LCOV_EXCL_START
g_free(gmod->name);
g_free(gmod);
return NULL;
+ //LCOV_EXCL_STOP
}
gmod->module = g_module_open(gmod->path, G_MODULE_BIND_LAZY);
if (!gmod->module) {
+ //LCOV_EXCL_START
MAPS_LOGE("module path not found: %s", gmod->path);
const gchar *last_error = g_module_error();
g_free(gmod->path);
g_free(gmod);
return NULL;
+ //LCOV_EXCL_STOP
}
MAPS_LOGD("open module");
/*if (is_resident)
gpointer func_ptr = NULL;
if (!g_module_symbol(gmod->module, func_name, &func_ptr)) {
+ //LCOV_EXCL_START
MAPS_LOGE("function symbol not found");
MAPS_LOGE("%s", g_module_error());
func_ptr = NULL;
+ //LCOV_EXCL_STOP
}
return func_ptr;
}
MAPS_LOGD("*********************************************");
MAPS_LOGD("PLUGIN INFO");
if (!plugin) {
+ //LCOV_EXCL_START
MAPS_LOGD("PLUGIN is NULL");
MAPS_LOGD("*********************************************");
return;
+ //LCOV_EXCL_STOP
}
const GMod *mod = (const GMod *) plugin->module;
if (!mod) {
- MAPS_LOGD("PLUGIN module is NULL");
+ MAPS_LOGD("PLUGIN module is NULL"); //LCOV_EXCL_LINE
} else {
MAPS_LOGD("module address:\t\t\t%p", mod->module);
MAPS_LOGD("module name:\t\t\t%s", mod->name);
if (!plugin->request_queue) {
MAPS_LOGD("PLUGIN request queue is NULL");
} else {
- MAPS_LOGD("plugin request queue:\t\t\t%p", plugin->request_queue);
+ MAPS_LOGD("plugin request queue:\t\t\t%p", plugin->request_queue); //LCOV_EXCL_LINE
}
const interface_s *itf = &plugin->interface;
GMod *plugin = gmod_new(info.file, TRUE);
if (!plugin) {
+ //LCOV_EXCL_START
MAPS_LOGE("Open Module Failed: %s", info.file.c_str());
*init_error = MAPS_ERROR_SERVICE_NOT_AVAILABLE;
return NULL;
+ //LCOV_EXCL_STOP
}
/* 2.1 Create new plugin interface */
/* 2. Perform steps to completely initialize a plugin */
do {
if (!new_plugin) {
+ //LCOV_EXCL_START
MAPS_LOGE("OUT_OF_MEMORY(0x%08x)", MAPS_ERROR_OUT_OF_MEMORY);
*init_error = MAPS_ERROR_OUT_OF_MEMORY;
break;
+ //LCOV_EXCL_STOP
}
/* 2.1 Set plugin module handle */
/* RAII Class implementing the mutex helper on the base of GLib mutex */
/* which automatically locks mutex during its creation and unlocks while
* exiting the scope */
+//LCOV_EXCL_START
class scope_mutex {
GMutex *mutex;
public:
maps_plugin_h init(const provider_info &info, const char *module, int *init_error);
void shutdown(maps_plugin_h plugin_h);
};
+//LCOV_EXCL_STOP
};
#endif /* __MAPS_SERVICE_PLUGIN_MODULE_H__ */
extern plugin::plugin_s *__extract_plugin(maps_service_h maps);
volatile int session::command::command_request_id = 1;
-session::command session::command::empty_instance;
+session::command session::command::empty_instance; //LCOV_EXCL_LINE
session::command::command(maps_service_h ms)
: m(ms), my_req_id(0), error(MAPS_ERROR_NONE), is_merged(false)
{
}
+//LCOV_EXCL_START
session::command::command(const command &src)
{
*this = src;
{
return MAPS_ERROR_NONE;
}
+//LCOV_EXCL_STOP
void session::command::destroy()
{
plugin::interface_s *session::command::interface() const
{
if (!m)
- return plugin::get_empty_interface_ptr();
+ return plugin::get_empty_interface_ptr(); //LCOV_EXCL_LINE
plugin::plugin_s *p = __extract_plugin(m);
if (!p)
- return plugin::get_empty_interface_ptr();
+ return plugin::get_empty_interface_ptr(); //LCOV_EXCL_LINE
return &p->interface;
}
+//LCOV_EXCL_START
maps_plugin_h session::command::handle() const
{
return (maps_plugin_h) plugin();
{
is_merged = true;
}
+//LCOV_EXCL_STOP
/*----------------------------------------------------------------------------*/
session::command_handler::command_handler(plugin::plugin_s *p, void *ud,
handler->plg_req_id);
if (!contains(user_req_id)) { /* Attempt to update not existing id */
+ //LCOV_EXCL_START
MAPS_LOGD("\t not updated session::pending_request: %d, %d",
user_req_id, handler->plg_req_id);
delete handler; /* This handler must be deleted */
+ //LCOV_EXCL_STOP
return;
}
return g_hash_table_contains(plg->pending_request_maps, &user_req_id);
}
+//LCOV_EXCL_START
int *session::pending_request::int_dup(const int n)
{
int *clone = g_new0(int, 1);
*clone = n;
return clone;
-}
\ No newline at end of file
+}
+//LCOV_EXCL_STOP
/*----------------------------------------------------------------------------*/
+//LCOV_EXCL_START
class command
{
private:
int *int_dup(const int n);
};
}
+//LCOV_EXCL_STOP
#endif /* __MAPS_SERVICE_SESSION_COMMAND_H__ */
/*----------------------------------------------------------------------------*/
+//LCOV_EXCL_START
int session::command_queue_sync::push(command *c)
{
return (c and c->plugin())? c->run() : MAPS_ERROR_INVALID_PARAMETER;
{
/* empty */
}
+//LCOV_EXCL_STOP
void session::command_queue_sync::clear(plugin::plugin_s *p)
{
#define __MAPS_SERVICE_SESSION_COMMAND_QUEUE_H__
#include "module.h"
+//LCOV_EXCL_START
namespace session
{
#endif /* _MAPS_SERVICE_SUPPORTS_ASYNC_QUEUE_ */
};
+//LCOV_EXCL_STOP
#endif /* __MAPS_SERVICE_SESSION_COMMAND_QUEUE_H__ */
MAPS_LOGD("session::command_geocode::run: %d", my_req_id);
} else {
- error = MAPS_ERROR_OUT_OF_MEMORY;
+ error = MAPS_ERROR_OUT_OF_MEMORY; //LCOV_EXCL_LINE
}
} else {
/* Plugin Function is NULL: use default empty function */
return ret;
}
+//LCOV_EXCL_START
session::command_geocode_handler::command_geocode_handler(plugin::plugin_s *p,
maps_service_geocode_cb cb,
void *ud, int urid)
, callback(cb)
{
}
+//LCOV_EXCL_STOP
bool session::command_geocode_handler::foreach_geocode_cb(maps_error_e error,
int request_id,
command_geocode_handler *handler = (command_geocode_handler *) user_data;
if (request_id != handler->plg_req_id) {
+ //LCOV_EXCL_START
MAPS_LOGE("\nERROR! Incorrect request id [%d] come from the plugin; expected [%d]\n",
request_id, handler->plg_req_id);
+ //LCOV_EXCL_STOP
}
/* Make a user's copy of result data */
if (maps_area_is_valid(b)) {
bounds = b;
} else {
+ //LCOV_EXCL_START
error = MAPS_ERROR_INVALID_PARAMETER;
*request_id = -1;
+ //LCOV_EXCL_STOP
}
}
MAPS_LOGD("session::command_geocode_inside_bounds::run: %d", my_req_id);
} else {
- error = MAPS_ERROR_OUT_OF_MEMORY;
+ error = MAPS_ERROR_OUT_OF_MEMORY; //LCOV_EXCL_LINE
}
} else {
/* Plugin Function is NULL: use default empty function */
if (maps_address_is_valid(a)) {
address = a;
} else {
+ //LCOV_EXCL_START
error = MAPS_ERROR_INVALID_PARAMETER;
*request_id = -1;
MAPS_LOGD("Invalid parameter");
+ //LCOV_EXCL_STOP
}
}
pr.update(my_req_id, handler);
} else {
- error = MAPS_ERROR_OUT_OF_MEMORY;
+ error = MAPS_ERROR_OUT_OF_MEMORY; //LCOV_EXCL_LINE
}
} else {
/* Plugin Function is NULL: use default empty function */
MAPS_LOGD("session::command_reverse_geocode::run: %d", my_req_id);
} else {
- error = MAPS_ERROR_OUT_OF_MEMORY;
+ error = MAPS_ERROR_OUT_OF_MEMORY; //LCOV_EXCL_LINE
}
} else {
/* Plugin Function is NULL: use default empty function */
return ret;
}
+//LCOV_EXCL_START
session::command_reverse_geocode_handler::command_reverse_geocode_handler(
plugin::plugin_s *p,
maps_service_reverse_geocode_cb cb,
, callback(cb)
{
}
+//LCOV_EXCL_STOP
void session::command_reverse_geocode_handler::foreach_reverse_geocode_cb(
maps_error_e error,
(command_reverse_geocode_handler *) user_data;
if (request_id != handler->plg_req_id) {
+ //LCOV_EXCL_START
MAPS_LOGE("\n\nERROR! Incorrect request id [%d] come from the plugin; expected [%d]\n\n",
request_id, handler->plg_req_id);
+ //LCOV_EXCL_STOP
}
/* Make a user's copy of result data */
MAPS_LOGD("session::command_multi_reverse_geocode::run: %d", my_req_id);
} else {
- error = MAPS_ERROR_OUT_OF_MEMORY;
+ error = MAPS_ERROR_OUT_OF_MEMORY; //LCOV_EXCL_LINE
}
} else {
/* Plugin Function is NULL: use default empty function */
return ret;
}
+//LCOV_EXCL_START
session::command_multi_reverse_geocode_handler::command_multi_reverse_geocode_handler(
plugin::plugin_s *p, maps_service_multi_reverse_geocode_cb cb, void *ud, int urid)
: command_handler(p, ud, urid)
, callback(cb)
{
}
+//LCOV_EXCL_STOP
bool session::command_multi_reverse_geocode_handler::foreach_multi_reverse_geocode_cb(
maps_error_e error, int request_id, int total, maps_coordinates_list_h address_list, void *user_data)
(command_multi_reverse_geocode_handler *) user_data;
if (request_id != handler->plg_req_id) {
+ //LCOV_EXCL_START
MAPS_LOGE("\n\nERROR! Incorrect request id [%d] come from the plugin; expected [%d]\n\n",
request_id, handler->plg_req_id);
+ //LCOV_EXCL_STOP
}
/* Make a user's copy of result data */
if (maps_coordinates_is_valid(pos)) {
position = pos;
} else {
+ //LCOV_EXCL_START
error = MAPS_ERROR_INVALID_PARAMETER;
*request_id = -1;
MAPS_LOGD("Invalid parameter");
+ //LCOV_EXCL_STOP
}
}
MAPS_LOGD("session::command_search_place::run: %d", my_req_id);
} else {
- error = MAPS_ERROR_OUT_OF_MEMORY;
+ error = MAPS_ERROR_OUT_OF_MEMORY; //LCOV_EXCL_LINE
}
} else {
/* Plugin Function is NULL: use default empty function */
return ret;
}
+//LCOV_EXCL_START
session::command_search_place_handler::command_search_place_handler(
plugin::plugin_s* p,
maps_service_search_place_cb cb,
, callback(cb)
{
}
+//LCOV_EXCL_STOP
bool session::command_search_place_handler::foreach_place_cb(maps_error_e error,
int request_id,
(command_search_place_handler *) user_data;
if (request_id != handler->plg_req_id) {
+ //LCOV_EXCL_START
MAPS_LOGE("\nERROR! Incorrect request id [%d] come from the plugin; expected [%d]\n",
request_id, handler->plg_req_id);
+ //LCOV_EXCL_STOP
}
/* Make a user's copy of result data */
if (maps_area_is_valid(b)) {
boundary = b;
} else {
+ //LCOV_EXCL_START
error = MAPS_ERROR_INVALID_PARAMETER;
*request_id = -1;
+ //LCOV_EXCL_STOP
}
}
MAPS_LOGD("session::command_search_by_area_place::run: %d", my_req_id);
} else {
- error = MAPS_ERROR_OUT_OF_MEMORY;
+ error = MAPS_ERROR_OUT_OF_MEMORY; //LCOV_EXCL_LINE
}
} else {
/* Plugin Function is NULL: use default empty function */
if (maps_area_is_valid(b)) {
boundary = b;
} else {
+ //LCOV_EXCL_START
error = MAPS_ERROR_INVALID_PARAMETER;
*request_id = -1;
MAPS_LOGD("Invalid parameter");
+ //LCOV_EXCL_STOP
}
}
MAPS_LOGD("session::command_search_by_address_place::run: %d", my_req_id);
} else {
- error = MAPS_ERROR_OUT_OF_MEMORY;
+ error = MAPS_ERROR_OUT_OF_MEMORY; //LCOV_EXCL_LINE
}
} else {
/* Plugin Function is NULL: use default empty function */
if (maps_area_is_valid(b)) {
boundary = b;
} else {
+ //LCOV_EXCL_START
error = MAPS_ERROR_INVALID_PARAMETER;
*request_id = -1;
MAPS_LOGD("Invalid parameter");
+ //LCOV_EXCL_STOP
}
}
MAPS_LOGD("session::command_search_place_list::run: %d", my_req_id);
} else {
- error = MAPS_ERROR_OUT_OF_MEMORY;
+ error = MAPS_ERROR_OUT_OF_MEMORY; //LCOV_EXCL_LINE
}
} else {
/* Plugin Function is NULL: use default empty function */
return ret;
}
+//LCOV_EXCL_START
session::command_search_place_list_handler::command_search_place_list_handler(
plugin::plugin_s* p,
maps_service_search_place_list_cb cb,
, callback(cb)
{
}
+//LCOV_EXCL_STOP
void session::command_search_place_list_handler::foreach_place_list_cb(maps_error_e error,
int request_id,
(command_search_place_list_handler *) user_data;
if (request_id != handler->plg_req_id) {
+ //LCOV_EXCL_START
MAPS_LOGE("\n\nERROR! Incorrect request id [%d] come from the plugin; expected [%d]\n\n",
request_id, handler->plg_req_id);
+ //LCOV_EXCL_STOP
}
/* Check which data features are supported */
MAPS_LOGD("session::command_get_place_details::run: %d",
my_req_id);
} else {
- error = MAPS_ERROR_OUT_OF_MEMORY;
+ error = MAPS_ERROR_OUT_OF_MEMORY; //LCOV_EXCL_LINE
}
} else {
/* Plugin Function is NULL: use default empty function */
return ret;
}
+//LCOV_EXCL_START
session::command_get_place_details_handler::command_get_place_details_handler(
plugin::plugin_s* p,
maps_service_get_place_details_cb cb,
, callback(cb)
{
}
+//LCOV_EXCL_STOP
void session::command_get_place_details_handler::foreach_place_details_cb(maps_error_e error,
int request_id, maps_place_h place, void *user_data)
(command_get_place_details_handler *) user_data;
if (request_id != handler->plg_req_id) {
+ //LCOV_EXCL_START
MAPS_LOGE("\n\nERROR! Incorrect request id [%d] come from the plugin; expected [%d]\n\n",
request_id, handler->plg_req_id);
+ //LCOV_EXCL_STOP
}
/* Make a user's copy of result data */
if (maps_coordinates_is_valid(orig)) {
origin = orig;
} else {
- error = MAPS_ERROR_INVALID_PARAMETER;
+ error = MAPS_ERROR_INVALID_PARAMETER; //LCOV_EXCL_LINE
}
if (maps_coordinates_is_valid(dest)) {
destination = dest;
} else {
- error = MAPS_ERROR_INVALID_PARAMETER;
+ error = MAPS_ERROR_INVALID_PARAMETER; //LCOV_EXCL_LINE
}
if (error) {
+ //LCOV_EXCL_START
*request_id = -1;
MAPS_LOGD("Invalid parameter");
+ //LCOV_EXCL_STOP
}
}
MAPS_LOGD("session::command_search_route::run: %d", my_req_id);
} else {
- error = MAPS_ERROR_OUT_OF_MEMORY;
+ error = MAPS_ERROR_OUT_OF_MEMORY; //LCOV_EXCL_LINE
}
} else {
/* Plugin Function is NULL: use default empty function */
MAPS_LOGD("session::command_search_place::run: %d", my_req_id);
} else {
- error = MAPS_ERROR_OUT_OF_MEMORY;
+ error = MAPS_ERROR_OUT_OF_MEMORY; //LCOV_EXCL_LINE
}
} else {
/* Plugin Function is NULL: use default empty function */
return ret;
}
+//LCOV_EXCL_START
session::command_search_route_handler::command_search_route_handler(
plugin::plugin_s *p,
maps_service_search_route_cb cb,
, callback(cb)
{
}
+//LCOV_EXCL_STOP
bool session::command_search_route_handler::foreach_route_cb(maps_error_e error,
int request_id,
(command_search_route_handler *) user_data;
if (request_id != handler->plg_req_id) {
+ //LCOV_EXCL_START
MAPS_LOGE("\n\nERROR! Incorrect request id [%d] come from the plugin; expected [%d]\n\n",
request_id, handler->plg_req_id);
+ //LCOV_EXCL_STOP
}
/* Make a user's copy of result data */
* Mapping API commands
*/
/*----------------------------------------------------------------------------*/
+//LCOV_EXCL_START
session::command_view_set_center::command_view_set_center(maps_service_h ms,
maps_view_h view,
cmd->set_merged();
}
}
+//LCOV_EXCL_STOP
namespace session
{
+//LCOV_EXCL_START
/*----------------------------------------------------------------------------*/
/*typedef int (*maps_plugin_geocode_f)(maps_service_h maps,
* const char *address, maps_service_geocode_cb callback,
virtual int get_priority() const;
virtual void merge(const command *c);
};
+//LCOV_EXCL_STOP
}
#include "command_queue.h"
#include "command.h"
+//LCOV_EXCL_START
session::thread::thread()
{
}
command_queue *cq = session::command_queue::interface();
cq->clear(p);
}
+//LCOV_EXCL_STOP
int view::gesture_detector::__CLICK_AREA = 50;
+//LCOV_EXCL_START
view::gesture_detector::gesture_detector(maps_view_h v)
: _view(v)
, _gp(this)
lat, lon,
0x1B, 0, 0, 0);
}
+//LCOV_EXCL_STOP
#include "gesture_detector_statemachine.h"
#include <glib.h>
-
+//LCOV_EXCL_START
view::gesture_detector_statemachine::gesture_detector_statemachine(maps_view_h v)
: gesture_detector(v)
, _current_state(STATE_NONE)
s.c_str(), state, e.c_str(), event,
0x1B, 0, 0, 0);
}
+//LCOV_EXCL_STOP
#include "runtime_data.h"
#include "gesture_detector.h"
-
+//LCOV_EXCL_START
namespace view
{
enum view_event_e {
string get_event_str(view_event_e event);
};
};
+//LCOV_EXCL_STOP
#endif /* __MAPS_VIEW_GESTURE_DETECTOR_STATEMACHINE_H__ */
/* ---------------------------------------------------------------------------*/
-
+//LCOV_EXCL_START
view::zoom_calculator::zoom_calculator(const touch_point &start_tp_f1,
const touch_point &cur_tp_f1,
const touch_point &start_tp_f2,
gesture_detector::get_trajectory_effective_length(tp, start);
return (trajectory >= gesture_detector::__CLICK_AREA);
}
+//LCOV_EXCL_STOP
#define _MOVE_CENTER_COMMAND_DEFINED_
+//LCOV_EXCL_START
namespace view
{
void set_gesture_detector(class gesture_detector *d);
};
};
+//LCOV_EXCL_STOP
#endif /* __MAPS_VIEW_GESTURE_PROCESSOR_H__ */
int _maps_coordinates_copy(maps_coordinates_h orig, maps_coordinates_h dest);
+//LCOV_EXCL_START
view::inertial_camera::inertial_camera(maps_view_h view)
: _view(view)
, target_zoom_factor(.0)
return transiting;
}
+//LCOV_EXCL_STOP
#include "maps_view.h"
+//LCOV_EXCL_START
namespace view
{
class inertial_camera {
void set_cur_state();
};
};
+//LCOV_EXCL_STOP
#endif /* __MAPS_VIEW_INERTIAL_CAMERA_H__ */
extern void _maps_view_halt_inertial_camera(maps_view_h view);
+//LCOV_EXCL_START
view::inertial_gesture::inertial_gesture(maps_view_h view)
: gesture_detector(view)
, _d(NULL)
MAPS_LOGD("reset inertial start (%d,%d)", _inertial_start[finger_no]._x, _inertial_start[finger_no]._y);
}
}
-
+//LCOV_EXCL_STOP
#include "gesture_detector.h"
+//LCOV_EXCL_START
namespace view
{
class inertial_gesture : public gesture_detector {
void update_inertial_start_point(int finger_no);
};
};
+//LCOV_EXCL_STOP
#endif /* __MAPS_VIEW_INERTIAL_GESTURE_H__ */
}
if ((type < MAPS_VIEW_MARKER_PIN) || (type > MAPS_VIEW_MARKER_STICKER)) {
+ //LCOV_EXCL_START
__error = MAPS_ERROR_INVALID_PARAMETER;
return NULL;
+ //LCOV_EXCL_STOP
}
__error = MAPS_ERROR_NONE;
return marker;
} while (false);
+ //LCOV_EXCL_START
/* FAILURE: Releasing objects */
maps_view_object_destroy(marker);
return NULL;
+ //LCOV_EXCL_STOP
}
#include "maps_error.h"
#include "maps_view_object.h"
+//LCOV_EXCL_START
namespace view
{
class marker_constructor {
}
};
};
+//LCOV_EXCL_STOP
#endif /* __MAPS_VIEW_MARKER_CONSTRUCTOR_H__ */
return overlay;
} while (false);
+ //LCOV_EXCL_START
/* FAILURE: Releasing objects */
maps_view_object_destroy(overlay);
return NULL;
+ //LCOV_EXCL_STOP
}
#include "maps_error.h"
#include "maps_view_object.h"
+//LCOV_EXCL_START
namespace view
{
class overlay_constructor {
}
};
};
+//LCOV_EXCL_STOP
#endif /* __MAPS_VIEW_overlay_constructor_H__ */
#include <math.h>
+//LCOV_EXCL_START
void view::poly_shape_hit_test::add_point(const float x, const float y)
{
__x.push_back(x);
}
return (c != 0);
}
+//LCOV_EXCL_STOP
#include <maps_util.h>
+//LCOV_EXCL_START
namespace view
{
class poly_shape_hit_test {
bool pnpoly(const float x, const float y) const;
};
};
+//LCOV_EXCL_STOP
#endif /* __MAPS_VIEW_POLY_SHAPE_HIT_TEST_H__ */
const unsigned char a)
{
if (!coordinates) {
+ //LCOV_EXCL_START
__error = MAPS_ERROR_INVALID_PARAMETER;
return NULL;
+ //LCOV_EXCL_STOP
}
__error = MAPS_ERROR_NONE;
return polygon;
} while (false);
+ //LCOV_EXCL_START
/* FAILURE: Releasing objects */
maps_view_object_destroy(polygon);
return NULL;
+ //LCOV_EXCL_STOP
}
#include "maps_error.h"
#include "maps_view_object.h"
+//LCOV_EXCL_START
namespace view
{
class polygon_constructor {
}
};
};
+//LCOV_EXCL_STOP
#endif /* __MAPS_VIEW_POLYGON_CONSTRUCTOR_H__ */
const int width)
{
if (!coordinates || (width <= 0)) {
+ //LCOV_EXCL_START
__error = MAPS_ERROR_INVALID_PARAMETER;
return NULL;
+ //LCOV_EXCL_STOP
}
__error = MAPS_ERROR_NONE;
return polyline;
} while (false);
+ //LCOV_EXCL_START
/* FAILURE: Releasing objects */
maps_view_object_destroy(polyline);
return NULL;
+ //LCOV_EXCL_STOP
}
#include "maps_error.h"
#include "maps_view_object.h"
+//LCOV_EXCL_START
namespace view
{
class polyline_constructor {
}
};
};
+//LCOV_EXCL_STOP
#endif /* __MAPS_VIEW_POLYLINE_CONSTRUCTOR_H__ */
#include "maps_view_plugin.h"
#include <glib.h>
+//LCOV_EXCL_START
view::touch_point::touch_point()
: _x(0)
, _y(0)
cnt++;
return cnt;
}
+//LCOV_EXCL_STOP
projects / platform / core / api / maps-service.git / commitdiff