/// @cond EO_CXX_EO_IMPL

inline void elm::map::source_set(Elm_Map_Source_Type type_, ::efl::eina::string_view source_name_) const
{
   eo_do(_concrete_eo_ptr(), ::elm_obj_map_source_set(type_, ::efl::eolian::to_c(source_name_)));
}

inline ::efl::eina::string_view elm::map::source_get(Elm_Map_Source_Type type_) const
{
   const char * _tmp_ret;
   eo_do(_concrete_eo_ptr(), _tmp_ret = ::elm_obj_map_source_get(type_));
   return ::efl::eolian::to_cxx<::efl::eina::string_view>(_tmp_ret, std::tuple<std::false_type>());
}

inline Elm_Map_Route * elm::map::route_add(Elm_Map_Route_Type type_, Elm_Map_Route_Method method_, double flon_, double flat_, double tlon_, double tlat_, Elm_Map_Route_Cb route_cb_, void * data_) const
{
   Elm_Map_Route * _tmp_ret;
   eo_do(_concrete_eo_ptr(), _tmp_ret = ::elm_obj_map_route_add(type_, method_, flon_, flat_, tlon_, tlat_, route_cb_, data_));
   return _tmp_ret;
}

inline ::evas::object elm::map::track_add(void * emap_) const
{
   Evas_Object * _tmp_ret;
   eo_do(_concrete_eo_ptr(), _tmp_ret = ::elm_obj_map_track_add(emap_));
   return ::efl::eolian::to_cxx<::evas::object>(_tmp_ret, std::tuple<std::false_type>());
}

inline void elm::map::region_to_canvas_convert(double lon_, double lat_, Evas_Coord* x_, Evas_Coord* y_) const
{
   eo_do(_concrete_eo_ptr(), ::elm_obj_map_region_to_canvas_convert(lon_, lat_, x_, y_));
}

inline Elm_Map_Overlay * elm::map::overlay_circle_add(double lon_, double lat_, double radius_) const
{
   Elm_Map_Overlay * _tmp_ret;
   eo_do(_concrete_eo_ptr(), _tmp_ret = ::elm_obj_map_overlay_circle_add(lon_, lat_, radius_));
   return _tmp_ret;
}

inline Elm_Map_Overlay * elm::map::overlay_class_add() const
{
   Elm_Map_Overlay * _tmp_ret;
   eo_do(_concrete_eo_ptr(), _tmp_ret = ::elm_obj_map_overlay_class_add());
   return _tmp_ret;
}

inline Elm_Map_Overlay * elm::map::overlay_bubble_add() const
{
   Elm_Map_Overlay * _tmp_ret;
   eo_do(_concrete_eo_ptr(), _tmp_ret = ::elm_obj_map_overlay_bubble_add());
   return _tmp_ret;
}

inline const char ** elm::map::sources_get(Elm_Map_Source_Type type_) const
{
   const char ** _tmp_ret;
   eo_do(_concrete_eo_ptr(), _tmp_ret = ::elm_obj_map_sources_get(type_));
   return _tmp_ret;
}

inline Elm_Map_Overlay * elm::map::overlay_polygon_add() const
{
   Elm_Map_Overlay * _tmp_ret;
   eo_do(_concrete_eo_ptr(), _tmp_ret = ::elm_obj_map_overlay_polygon_add());
   return _tmp_ret;
}

inline Elm_Map_Overlay * elm::map::overlay_line_add(double flon_, double flat_, double tlon_, double tlat_) const
{
   Elm_Map_Overlay * _tmp_ret;
   eo_do(_concrete_eo_ptr(), _tmp_ret = ::elm_obj_map_overlay_line_add(flon_, flat_, tlon_, tlat_));
   return _tmp_ret;
}

inline void elm::map::region_show(double lon_, double lat_) const
{
   eo_do(_concrete_eo_ptr(), ::elm_obj_map_region_show(lon_, lat_));
}

inline Elm_Map_Name * elm::map::name_add(::efl::eina::optional< ::efl::eina::string_view > address_, double lon_, double lat_, Elm_Map_Name_Cb name_cb_, void * data_) const
{
   Elm_Map_Name * _tmp_ret;
   eo_do(_concrete_eo_ptr(), _tmp_ret = ::elm_obj_map_name_add(::efl::eolian::to_c(address_), lon_, lat_, name_cb_, data_));
   return _tmp_ret;
}

inline void elm::map::name_search(::efl::eina::string_view address_, Elm_Map_Name_List_Cb name_cb_, void * data_) const
{
   eo_do(_concrete_eo_ptr(), ::elm_obj_map_name_search(::efl::eolian::to_c(address_), name_cb_, data_));
}

inline void elm::map::region_bring_in(double lon_, double lat_) const
{
   eo_do(_concrete_eo_ptr(), ::elm_obj_map_region_bring_in(lon_, lat_));
}

inline void elm::map::region_zoom_bring_in(int zoom_, double lon_, double lat_) const
{
   eo_do(_concrete_eo_ptr(), ::elm_obj_map_region_zoom_bring_in(zoom_, lon_, lat_));
}

inline void elm::map::track_remove(::evas::object route_) const
{
   eo_do(_concrete_eo_ptr(), ::elm_obj_map_track_remove(::efl::eolian::to_c(route_)));
}

inline Elm_Map_Overlay * elm::map::overlay_route_add(const Elm_Map_Route * route_) const
{
   Elm_Map_Overlay * _tmp_ret;
   eo_do(_concrete_eo_ptr(), _tmp_ret = ::elm_obj_map_overlay_route_add(route_));
   return _tmp_ret;
}

inline Elm_Map_Overlay * elm::map::overlay_scale_add(Evas_Coord x_, Evas_Coord y_) const
{
   Elm_Map_Overlay * _tmp_ret;
   eo_do(_concrete_eo_ptr(), _tmp_ret = ::elm_obj_map_overlay_scale_add(x_, y_));
   return _tmp_ret;
}

inline Elm_Map_Overlay * elm::map::overlay_add(double lon_, double lat_) const
{
   Elm_Map_Overlay * _tmp_ret;
   eo_do(_concrete_eo_ptr(), _tmp_ret = ::elm_obj_map_overlay_add(lon_, lat_));
   return _tmp_ret;
}

inline void elm::map::canvas_to_region_convert(Evas_Coord x_, Evas_Coord y_, double* lon_, double* lat_) const
{
   eo_do(_concrete_eo_ptr(), ::elm_obj_map_canvas_to_region_convert(x_, y_, lon_, lat_));
}

inline int elm::map::zoom_get() const
{
   int _tmp_ret;
   eo_do(_concrete_eo_ptr(), _tmp_ret = ::elm_obj_map_zoom_get());
   return _tmp_ret;
}

inline void elm::map::zoom_set(int zoom_) const
{
   eo_do(_concrete_eo_ptr(), ::elm_obj_map_zoom_set(zoom_));
}

inline bool elm::map::paused_get() const
{
   Eina_Bool _tmp_ret;
   eo_do(_concrete_eo_ptr(), _tmp_ret = ::elm_obj_map_paused_get());
   return ::efl::eolian::to_cxx<bool>(_tmp_ret, std::tuple<std::false_type>());
}

inline void elm::map::paused_set(bool paused_) const
{
   eo_do(_concrete_eo_ptr(), ::elm_obj_map_paused_set(::efl::eolian::to_c(paused_)));
}

inline bool elm::map::wheel_disabled_get() const
{
   Eina_Bool _tmp_ret;
   eo_do(_concrete_eo_ptr(), _tmp_ret = ::elm_obj_map_wheel_disabled_get());
   return ::efl::eolian::to_cxx<bool>(_tmp_ret, std::tuple<std::false_type>());
}

inline void elm::map::wheel_disabled_set(bool disabled_) const
{
   eo_do(_concrete_eo_ptr(), ::elm_obj_map_wheel_disabled_set(::efl::eolian::to_c(disabled_)));
}

inline int elm::map::zoom_min_get() const
{
   int _tmp_ret;
   eo_do(_concrete_eo_ptr(), _tmp_ret = ::elm_obj_map_zoom_min_get());
   return _tmp_ret;
}

inline void elm::map::zoom_min_set(int zoom_) const
{
   eo_do(_concrete_eo_ptr(), ::elm_obj_map_zoom_min_set(zoom_));
}

inline void elm::map::rotate_get(double* degree_, Evas_Coord* cx_, Evas_Coord* cy_) const
{
   eo_do(_concrete_eo_ptr(), ::elm_obj_map_rotate_get(degree_, cx_, cy_));
}

inline void elm::map::rotate_set(double degree_, Evas_Coord cx_, Evas_Coord cy_) const
{
   eo_do(_concrete_eo_ptr(), ::elm_obj_map_rotate_set(degree_, cx_, cy_));
}

inline ::efl::eina::string_view elm::map::user_agent_get() const
{
   const char * _tmp_ret;
   eo_do(_concrete_eo_ptr(), _tmp_ret = ::elm_obj_map_user_agent_get());
   return ::efl::eolian::to_cxx<::efl::eina::string_view>(_tmp_ret, std::tuple<std::false_type>());
}

inline void elm::map::user_agent_set(::efl::eina::string_view user_agent_) const
{
   eo_do(_concrete_eo_ptr(), ::elm_obj_map_user_agent_set(::efl::eolian::to_c(user_agent_)));
}

inline int elm::map::zoom_max_get() const
{
   int _tmp_ret;
   eo_do(_concrete_eo_ptr(), _tmp_ret = ::elm_obj_map_zoom_max_get());
   return _tmp_ret;
}

inline void elm::map::zoom_max_set(int zoom_) const
{
   eo_do(_concrete_eo_ptr(), ::elm_obj_map_zoom_max_set(zoom_));
}

inline Elm_Map_Zoom_Mode elm::map::zoom_mode_get() const
{
   Elm_Map_Zoom_Mode _tmp_ret;
   eo_do(_concrete_eo_ptr(), _tmp_ret = ::elm_obj_map_zoom_mode_get());
   return _tmp_ret;
}

inline void elm::map::zoom_mode_set(Elm_Map_Zoom_Mode mode_) const
{
   eo_do(_concrete_eo_ptr(), ::elm_obj_map_zoom_mode_set(mode_));
}

inline void elm::map::region_get(double* lon_, double* lat_) const
{
   eo_do(_concrete_eo_ptr(), ::elm_obj_map_region_get(lon_, lat_));
}

inline ::efl::eina::range_list< Elm_Map_Overlay * > elm::map::overlays_get() const
{
   Eina_List * _tmp_ret;
   eo_do(_concrete_eo_ptr(), _tmp_ret = ::elm_obj_map_overlays_get());
   return ::efl::eolian::to_cxx<::efl::eina::range_list< Elm_Map_Overlay * >>(_tmp_ret, std::tuple<std::false_type, std::false_type>());
}

inline void elm::map::tile_load_status_get(int* try_num_, int* finish_num_) const
{
   eo_do(_concrete_eo_ptr(), ::elm_obj_map_tile_load_status_get(try_num_, finish_num_));
}

inline void eo_cxx::elm::map::source_set(Elm_Map_Source_Type type_, ::efl::eina::string_view source_name_) const
{
   eo_do(_concrete_eo_ptr(), ::elm_obj_map_source_set(type_, ::efl::eolian::to_c(source_name_)));
}

inline ::efl::eina::string_view eo_cxx::elm::map::source_get(Elm_Map_Source_Type type_) const
{
   const char * _tmp_ret;
   eo_do(_concrete_eo_ptr(), _tmp_ret = ::elm_obj_map_source_get(type_));
   return ::efl::eolian::to_cxx<::efl::eina::string_view>(_tmp_ret, std::tuple<std::false_type>());
}

inline Elm_Map_Route * eo_cxx::elm::map::route_add(Elm_Map_Route_Type type_, Elm_Map_Route_Method method_, double flon_, double flat_, double tlon_, double tlat_, Elm_Map_Route_Cb route_cb_, void * data_) const
{
   Elm_Map_Route * _tmp_ret;
   eo_do(_concrete_eo_ptr(), _tmp_ret = ::elm_obj_map_route_add(type_, method_, flon_, flat_, tlon_, tlat_, route_cb_, data_));
   return _tmp_ret;
}

inline ::evas::object eo_cxx::elm::map::track_add(void * emap_) const
{
   Evas_Object * _tmp_ret;
   eo_do(_concrete_eo_ptr(), _tmp_ret = ::elm_obj_map_track_add(emap_));
   return ::efl::eolian::to_cxx<::evas::object>(_tmp_ret, std::tuple<std::false_type>());
}

inline void eo_cxx::elm::map::region_to_canvas_convert(double lon_, double lat_, Evas_Coord* x_, Evas_Coord* y_) const
{
   eo_do(_concrete_eo_ptr(), ::elm_obj_map_region_to_canvas_convert(lon_, lat_, x_, y_));
}

inline Elm_Map_Overlay * eo_cxx::elm::map::overlay_circle_add(double lon_, double lat_, double radius_) const
{
   Elm_Map_Overlay * _tmp_ret;
   eo_do(_concrete_eo_ptr(), _tmp_ret = ::elm_obj_map_overlay_circle_add(lon_, lat_, radius_));
   return _tmp_ret;
}

inline Elm_Map_Overlay * eo_cxx::elm::map::overlay_class_add() const
{
   Elm_Map_Overlay * _tmp_ret;
   eo_do(_concrete_eo_ptr(), _tmp_ret = ::elm_obj_map_overlay_class_add());
   return _tmp_ret;
}

inline Elm_Map_Overlay * eo_cxx::elm::map::overlay_bubble_add() const
{
   Elm_Map_Overlay * _tmp_ret;
   eo_do(_concrete_eo_ptr(), _tmp_ret = ::elm_obj_map_overlay_bubble_add());
   return _tmp_ret;
}

inline const char ** eo_cxx::elm::map::sources_get(Elm_Map_Source_Type type_) const
{
   const char ** _tmp_ret;
   eo_do(_concrete_eo_ptr(), _tmp_ret = ::elm_obj_map_sources_get(type_));
   return _tmp_ret;
}

inline Elm_Map_Overlay * eo_cxx::elm::map::overlay_polygon_add() const
{
   Elm_Map_Overlay * _tmp_ret;
   eo_do(_concrete_eo_ptr(), _tmp_ret = ::elm_obj_map_overlay_polygon_add());
   return _tmp_ret;
}

inline Elm_Map_Overlay * eo_cxx::elm::map::overlay_line_add(double flon_, double flat_, double tlon_, double tlat_) const
{
   Elm_Map_Overlay * _tmp_ret;
   eo_do(_concrete_eo_ptr(), _tmp_ret = ::elm_obj_map_overlay_line_add(flon_, flat_, tlon_, tlat_));
   return _tmp_ret;
}

inline void eo_cxx::elm::map::region_show(double lon_, double lat_) const
{
   eo_do(_concrete_eo_ptr(), ::elm_obj_map_region_show(lon_, lat_));
}

inline Elm_Map_Name * eo_cxx::elm::map::name_add(::efl::eina::optional< ::efl::eina::string_view > address_, double lon_, double lat_, Elm_Map_Name_Cb name_cb_, void * data_) const
{
   Elm_Map_Name * _tmp_ret;
   eo_do(_concrete_eo_ptr(), _tmp_ret = ::elm_obj_map_name_add(::efl::eolian::to_c(address_), lon_, lat_, name_cb_, data_));
   return _tmp_ret;
}

inline void eo_cxx::elm::map::name_search(::efl::eina::string_view address_, Elm_Map_Name_List_Cb name_cb_, void * data_) const
{
   eo_do(_concrete_eo_ptr(), ::elm_obj_map_name_search(::efl::eolian::to_c(address_), name_cb_, data_));
}

inline void eo_cxx::elm::map::region_bring_in(double lon_, double lat_) const
{
   eo_do(_concrete_eo_ptr(), ::elm_obj_map_region_bring_in(lon_, lat_));
}

inline void eo_cxx::elm::map::region_zoom_bring_in(int zoom_, double lon_, double lat_) const
{
   eo_do(_concrete_eo_ptr(), ::elm_obj_map_region_zoom_bring_in(zoom_, lon_, lat_));
}

inline void eo_cxx::elm::map::track_remove(::evas::object route_) const
{
   eo_do(_concrete_eo_ptr(), ::elm_obj_map_track_remove(::efl::eolian::to_c(route_)));
}

inline Elm_Map_Overlay * eo_cxx::elm::map::overlay_route_add(const Elm_Map_Route * route_) const
{
   Elm_Map_Overlay * _tmp_ret;
   eo_do(_concrete_eo_ptr(), _tmp_ret = ::elm_obj_map_overlay_route_add(route_));
   return _tmp_ret;
}

inline Elm_Map_Overlay * eo_cxx::elm::map::overlay_scale_add(Evas_Coord x_, Evas_Coord y_) const
{
   Elm_Map_Overlay * _tmp_ret;
   eo_do(_concrete_eo_ptr(), _tmp_ret = ::elm_obj_map_overlay_scale_add(x_, y_));
   return _tmp_ret;
}

inline Elm_Map_Overlay * eo_cxx::elm::map::overlay_add(double lon_, double lat_) const
{
   Elm_Map_Overlay * _tmp_ret;
   eo_do(_concrete_eo_ptr(), _tmp_ret = ::elm_obj_map_overlay_add(lon_, lat_));
   return _tmp_ret;
}

inline void eo_cxx::elm::map::canvas_to_region_convert(Evas_Coord x_, Evas_Coord y_, double* lon_, double* lat_) const
{
   eo_do(_concrete_eo_ptr(), ::elm_obj_map_canvas_to_region_convert(x_, y_, lon_, lat_));
}

inline int eo_cxx::elm::map::zoom_get() const
{
   int _tmp_ret;
   eo_do(_concrete_eo_ptr(), _tmp_ret = ::elm_obj_map_zoom_get());
   return _tmp_ret;
}

inline void eo_cxx::elm::map::zoom_set(int zoom_) const
{
   eo_do(_concrete_eo_ptr(), ::elm_obj_map_zoom_set(zoom_));
}

inline bool eo_cxx::elm::map::paused_get() const
{
   Eina_Bool _tmp_ret;
   eo_do(_concrete_eo_ptr(), _tmp_ret = ::elm_obj_map_paused_get());
   return ::efl::eolian::to_cxx<bool>(_tmp_ret, std::tuple<std::false_type>());
}

inline void eo_cxx::elm::map::paused_set(bool paused_) const
{
   eo_do(_concrete_eo_ptr(), ::elm_obj_map_paused_set(::efl::eolian::to_c(paused_)));
}

inline bool eo_cxx::elm::map::wheel_disabled_get() const
{
   Eina_Bool _tmp_ret;
   eo_do(_concrete_eo_ptr(), _tmp_ret = ::elm_obj_map_wheel_disabled_get());
   return ::efl::eolian::to_cxx<bool>(_tmp_ret, std::tuple<std::false_type>());
}

inline void eo_cxx::elm::map::wheel_disabled_set(bool disabled_) const
{
   eo_do(_concrete_eo_ptr(), ::elm_obj_map_wheel_disabled_set(::efl::eolian::to_c(disabled_)));
}

inline int eo_cxx::elm::map::zoom_min_get() const
{
   int _tmp_ret;
   eo_do(_concrete_eo_ptr(), _tmp_ret = ::elm_obj_map_zoom_min_get());
   return _tmp_ret;
}

inline void eo_cxx::elm::map::zoom_min_set(int zoom_) const
{
   eo_do(_concrete_eo_ptr(), ::elm_obj_map_zoom_min_set(zoom_));
}

inline void eo_cxx::elm::map::rotate_get(double* degree_, Evas_Coord* cx_, Evas_Coord* cy_) const
{
   eo_do(_concrete_eo_ptr(), ::elm_obj_map_rotate_get(degree_, cx_, cy_));
}

inline void eo_cxx::elm::map::rotate_set(double degree_, Evas_Coord cx_, Evas_Coord cy_) const
{
   eo_do(_concrete_eo_ptr(), ::elm_obj_map_rotate_set(degree_, cx_, cy_));
}

inline ::efl::eina::string_view eo_cxx::elm::map::user_agent_get() const
{
   const char * _tmp_ret;
   eo_do(_concrete_eo_ptr(), _tmp_ret = ::elm_obj_map_user_agent_get());
   return ::efl::eolian::to_cxx<::efl::eina::string_view>(_tmp_ret, std::tuple<std::false_type>());
}

inline void eo_cxx::elm::map::user_agent_set(::efl::eina::string_view user_agent_) const
{
   eo_do(_concrete_eo_ptr(), ::elm_obj_map_user_agent_set(::efl::eolian::to_c(user_agent_)));
}

inline int eo_cxx::elm::map::zoom_max_get() const
{
   int _tmp_ret;
   eo_do(_concrete_eo_ptr(), _tmp_ret = ::elm_obj_map_zoom_max_get());
   return _tmp_ret;
}

inline void eo_cxx::elm::map::zoom_max_set(int zoom_) const
{
   eo_do(_concrete_eo_ptr(), ::elm_obj_map_zoom_max_set(zoom_));
}

inline Elm_Map_Zoom_Mode eo_cxx::elm::map::zoom_mode_get() const
{
   Elm_Map_Zoom_Mode _tmp_ret;
   eo_do(_concrete_eo_ptr(), _tmp_ret = ::elm_obj_map_zoom_mode_get());
   return _tmp_ret;
}

inline void eo_cxx::elm::map::zoom_mode_set(Elm_Map_Zoom_Mode mode_) const
{
   eo_do(_concrete_eo_ptr(), ::elm_obj_map_zoom_mode_set(mode_));
}

inline void eo_cxx::elm::map::region_get(double* lon_, double* lat_) const
{
   eo_do(_concrete_eo_ptr(), ::elm_obj_map_region_get(lon_, lat_));
}

inline ::efl::eina::range_list< Elm_Map_Overlay * > eo_cxx::elm::map::overlays_get() const
{
   Eina_List * _tmp_ret;
   eo_do(_concrete_eo_ptr(), _tmp_ret = ::elm_obj_map_overlays_get());
   return ::efl::eolian::to_cxx<::efl::eina::range_list< Elm_Map_Overlay * >>(_tmp_ret, std::tuple<std::false_type, std::false_type>());
}

inline void eo_cxx::elm::map::tile_load_status_get(int* try_num_, int* finish_num_) const
{
   eo_do(_concrete_eo_ptr(), ::elm_obj_map_tile_load_status_get(try_num_, finish_num_));
}

inline ::eo_cxx::elm::map::operator ::elm::map() const
{
   return *static_cast<::elm::map const*>(static_cast<void const*>(this));
}

inline ::eo_cxx::elm::map::operator ::elm::map&()
{
   return *static_cast<::elm::map*>(static_cast<void*>(this));
}

inline ::eo_cxx::elm::map::operator ::elm::map const&() const
{
   return *static_cast<::elm::map const*>(static_cast<void const*>(this));
}

template <typename T>
void elm_map_source_set_wrapper(Eo* objid EINA_UNUSED, ::efl::eo::detail::Inherit_Private_Data* self, Elm_Map_Source_Type type_, const char * source_name_)
{
   try
      {
         static_cast<T*>(self->this_)->source_set(type_, ::efl::eolian::to_cxx<::efl::eina::string_view>(source_name_, std::tuple<std::false_type>()));
      }
   catch (...)
      {
         eina_error_set( ::efl::eina::unknown_error() );
      }
}

template <typename T>
::efl::eina::string_view elm_map_source_get_wrapper(Eo* objid EINA_UNUSED, ::efl::eo::detail::Inherit_Private_Data* self, Elm_Map_Source_Type type_)
{
   try
      {
         return static_cast<T*>(self->this_)->source_get(type_);
      }
   catch (...)
      {
         eina_error_set( ::efl::eina::unknown_error() );
         const char * _tmp_ret{};
         return ::efl::eolian::to_cxx<::efl::eina::string_view>(_tmp_ret, std::tuple<std::false_type>());
      }
}

template <typename T>
Elm_Map_Route * elm_map_route_add_wrapper(Eo* objid EINA_UNUSED, ::efl::eo::detail::Inherit_Private_Data* self, Elm_Map_Route_Type type_, Elm_Map_Route_Method method_, double flon_, double flat_, double tlon_, double tlat_, Elm_Map_Route_Cb route_cb_, void * data_)
{
   try
      {
         return static_cast<T*>(self->this_)->route_add(type_, method_, flon_, flat_, tlon_, tlat_, route_cb_, data_);
      }
   catch (...)
      {
         eina_error_set( ::efl::eina::unknown_error() );
         Elm_Map_Route * _tmp_ret{};
         return _tmp_ret;
      }
}

template <typename T>
::evas::object elm_map_track_add_wrapper(Eo* objid EINA_UNUSED, ::efl::eo::detail::Inherit_Private_Data* self, void * emap_)
{
   try
      {
         return static_cast<T*>(self->this_)->track_add(emap_);
      }
   catch (...)
      {
         eina_error_set( ::efl::eina::unknown_error() );
         Evas_Object * _tmp_ret{};
         return ::efl::eolian::to_cxx<::evas::object>(_tmp_ret, std::tuple<std::false_type>());
      }
}

template <typename T>
void elm_map_region_to_canvas_convert_wrapper(Eo* objid EINA_UNUSED, ::efl::eo::detail::Inherit_Private_Data* self, double lon_, double lat_, Evas_Coord* x_, Evas_Coord* y_)
{
   try
      {
         static_cast<T*>(self->this_)->region_to_canvas_convert(lon_, lat_, x_, y_);
      }
   catch (...)
      {
         eina_error_set( ::efl::eina::unknown_error() );
      }
}

template <typename T>
Elm_Map_Overlay * elm_map_overlay_circle_add_wrapper(Eo* objid EINA_UNUSED, ::efl::eo::detail::Inherit_Private_Data* self, double lon_, double lat_, double radius_)
{
   try
      {
         return static_cast<T*>(self->this_)->overlay_circle_add(lon_, lat_, radius_);
      }
   catch (...)
      {
         eina_error_set( ::efl::eina::unknown_error() );
         Elm_Map_Overlay * _tmp_ret{};
         return _tmp_ret;
      }
}

template <typename T>
Elm_Map_Overlay * elm_map_overlay_class_add_wrapper(Eo* objid EINA_UNUSED, ::efl::eo::detail::Inherit_Private_Data* self)
{
   try
      {
         return static_cast<T*>(self->this_)->overlay_class_add();
      }
   catch (...)
      {
         eina_error_set( ::efl::eina::unknown_error() );
         Elm_Map_Overlay * _tmp_ret{};
         return _tmp_ret;
      }
}

template <typename T>
Elm_Map_Overlay * elm_map_overlay_bubble_add_wrapper(Eo* objid EINA_UNUSED, ::efl::eo::detail::Inherit_Private_Data* self)
{
   try
      {
         return static_cast<T*>(self->this_)->overlay_bubble_add();
      }
   catch (...)
      {
         eina_error_set( ::efl::eina::unknown_error() );
         Elm_Map_Overlay * _tmp_ret{};
         return _tmp_ret;
      }
}

template <typename T>
const char ** elm_map_sources_get_wrapper(Eo* objid EINA_UNUSED, ::efl::eo::detail::Inherit_Private_Data* self, Elm_Map_Source_Type type_)
{
   try
      {
         return static_cast<T*>(self->this_)->sources_get(type_);
      }
   catch (...)
      {
         eina_error_set( ::efl::eina::unknown_error() );
         const char ** _tmp_ret{};
         return _tmp_ret;
      }
}

template <typename T>
Elm_Map_Overlay * elm_map_overlay_polygon_add_wrapper(Eo* objid EINA_UNUSED, ::efl::eo::detail::Inherit_Private_Data* self)
{
   try
      {
         return static_cast<T*>(self->this_)->overlay_polygon_add();
      }
   catch (...)
      {
         eina_error_set( ::efl::eina::unknown_error() );
         Elm_Map_Overlay * _tmp_ret{};
         return _tmp_ret;
      }
}

template <typename T>
Elm_Map_Overlay * elm_map_overlay_line_add_wrapper(Eo* objid EINA_UNUSED, ::efl::eo::detail::Inherit_Private_Data* self, double flon_, double flat_, double tlon_, double tlat_)
{
   try
      {
         return static_cast<T*>(self->this_)->overlay_line_add(flon_, flat_, tlon_, tlat_);
      }
   catch (...)
      {
         eina_error_set( ::efl::eina::unknown_error() );
         Elm_Map_Overlay * _tmp_ret{};
         return _tmp_ret;
      }
}

template <typename T>
void elm_map_region_show_wrapper(Eo* objid EINA_UNUSED, ::efl::eo::detail::Inherit_Private_Data* self, double lon_, double lat_)
{
   try
      {
         static_cast<T*>(self->this_)->region_show(lon_, lat_);
      }
   catch (...)
      {
         eina_error_set( ::efl::eina::unknown_error() );
      }
}

template <typename T>
Elm_Map_Name * elm_map_name_add_wrapper(Eo* objid EINA_UNUSED, ::efl::eo::detail::Inherit_Private_Data* self, const char * address_, double lon_, double lat_, Elm_Map_Name_Cb name_cb_, void * data_)
{
   try
      {
         return static_cast<T*>(self->this_)->name_add(::efl::eolian::to_cxx<::efl::eina::optional< ::efl::eina::string_view >>(address_, std::tuple<std::false_type>()), lon_, lat_, name_cb_, data_);
      }
   catch (...)
      {
         eina_error_set( ::efl::eina::unknown_error() );
         Elm_Map_Name * _tmp_ret{};
         return _tmp_ret;
      }
}

template <typename T>
void elm_map_name_search_wrapper(Eo* objid EINA_UNUSED, ::efl::eo::detail::Inherit_Private_Data* self, const char * address_, Elm_Map_Name_List_Cb name_cb_, void * data_)
{
   try
      {
         static_cast<T*>(self->this_)->name_search(::efl::eolian::to_cxx<::efl::eina::string_view>(address_, std::tuple<std::false_type>()), name_cb_, data_);
      }
   catch (...)
      {
         eina_error_set( ::efl::eina::unknown_error() );
      }
}

template <typename T>
void elm_map_region_bring_in_wrapper(Eo* objid EINA_UNUSED, ::efl::eo::detail::Inherit_Private_Data* self, double lon_, double lat_)
{
   try
      {
         static_cast<T*>(self->this_)->region_bring_in(lon_, lat_);
      }
   catch (...)
      {
         eina_error_set( ::efl::eina::unknown_error() );
      }
}

template <typename T>
void elm_map_region_zoom_bring_in_wrapper(Eo* objid EINA_UNUSED, ::efl::eo::detail::Inherit_Private_Data* self, int zoom_, double lon_, double lat_)
{
   try
      {
         static_cast<T*>(self->this_)->region_zoom_bring_in(zoom_, lon_, lat_);
      }
   catch (...)
      {
         eina_error_set( ::efl::eina::unknown_error() );
      }
}

template <typename T>
void elm_map_track_remove_wrapper(Eo* objid EINA_UNUSED, ::efl::eo::detail::Inherit_Private_Data* self, Evas_Object * route_)
{
   try
      {
         static_cast<T*>(self->this_)->track_remove(::efl::eolian::to_cxx<::evas::object>(route_, std::tuple<std::false_type>()));
      }
   catch (...)
      {
         eina_error_set( ::efl::eina::unknown_error() );
      }
}

template <typename T>
Elm_Map_Overlay * elm_map_overlay_route_add_wrapper(Eo* objid EINA_UNUSED, ::efl::eo::detail::Inherit_Private_Data* self, const Elm_Map_Route * route_)
{
   try
      {
         return static_cast<T*>(self->this_)->overlay_route_add(route_);
      }
   catch (...)
      {
         eina_error_set( ::efl::eina::unknown_error() );
         Elm_Map_Overlay * _tmp_ret{};
         return _tmp_ret;
      }
}

template <typename T>
Elm_Map_Overlay * elm_map_overlay_scale_add_wrapper(Eo* objid EINA_UNUSED, ::efl::eo::detail::Inherit_Private_Data* self, Evas_Coord x_, Evas_Coord y_)
{
   try
      {
         return static_cast<T*>(self->this_)->overlay_scale_add(x_, y_);
      }
   catch (...)
      {
         eina_error_set( ::efl::eina::unknown_error() );
         Elm_Map_Overlay * _tmp_ret{};
         return _tmp_ret;
      }
}

template <typename T>
Elm_Map_Overlay * elm_map_overlay_add_wrapper(Eo* objid EINA_UNUSED, ::efl::eo::detail::Inherit_Private_Data* self, double lon_, double lat_)
{
   try
      {
         return static_cast<T*>(self->this_)->overlay_add(lon_, lat_);
      }
   catch (...)
      {
         eina_error_set( ::efl::eina::unknown_error() );
         Elm_Map_Overlay * _tmp_ret{};
         return _tmp_ret;
      }
}

template <typename T>
void elm_map_canvas_to_region_convert_wrapper(Eo* objid EINA_UNUSED, ::efl::eo::detail::Inherit_Private_Data* self, Evas_Coord x_, Evas_Coord y_, double* lon_, double* lat_)
{
   try
      {
         static_cast<T*>(self->this_)->canvas_to_region_convert(x_, y_, lon_, lat_);
      }
   catch (...)
      {
         eina_error_set( ::efl::eina::unknown_error() );
      }
}

template <typename T>
int elm_map_zoom_get_wrapper(Eo* objid EINA_UNUSED, ::efl::eo::detail::Inherit_Private_Data* self)
{
   try
      {
         return static_cast<T*>(self->this_)->zoom_get();
      }
   catch (...)
      {
         eina_error_set( ::efl::eina::unknown_error() );
         int _tmp_ret{};
         return _tmp_ret;
      }
}

template <typename T>
void elm_map_zoom_set_wrapper(Eo* objid EINA_UNUSED, ::efl::eo::detail::Inherit_Private_Data* self, int zoom_)
{
   try
      {
         static_cast<T*>(self->this_)->zoom_set(zoom_);
      }
   catch (...)
      {
         eina_error_set( ::efl::eina::unknown_error() );
      }
}

template <typename T>
bool elm_map_paused_get_wrapper(Eo* objid EINA_UNUSED, ::efl::eo::detail::Inherit_Private_Data* self)
{
   try
      {
         return static_cast<T*>(self->this_)->paused_get();
      }
   catch (...)
      {
         eina_error_set( ::efl::eina::unknown_error() );
         Eina_Bool _tmp_ret{};
         return ::efl::eolian::to_cxx<bool>(_tmp_ret, std::tuple<std::false_type>());
      }
}

template <typename T>
void elm_map_paused_set_wrapper(Eo* objid EINA_UNUSED, ::efl::eo::detail::Inherit_Private_Data* self, Eina_Bool paused_)
{
   try
      {
         static_cast<T*>(self->this_)->paused_set(::efl::eolian::to_cxx<bool>(paused_, std::tuple<std::false_type>()));
      }
   catch (...)
      {
         eina_error_set( ::efl::eina::unknown_error() );
      }
}

template <typename T>
bool elm_map_wheel_disabled_get_wrapper(Eo* objid EINA_UNUSED, ::efl::eo::detail::Inherit_Private_Data* self)
{
   try
      {
         return static_cast<T*>(self->this_)->wheel_disabled_get();
      }
   catch (...)
      {
         eina_error_set( ::efl::eina::unknown_error() );
         Eina_Bool _tmp_ret{};
         return ::efl::eolian::to_cxx<bool>(_tmp_ret, std::tuple<std::false_type>());
      }
}

template <typename T>
void elm_map_wheel_disabled_set_wrapper(Eo* objid EINA_UNUSED, ::efl::eo::detail::Inherit_Private_Data* self, Eina_Bool disabled_)
{
   try
      {
         static_cast<T*>(self->this_)->wheel_disabled_set(::efl::eolian::to_cxx<bool>(disabled_, std::tuple<std::false_type>()));
      }
   catch (...)
      {
         eina_error_set( ::efl::eina::unknown_error() );
      }
}

template <typename T>
int elm_map_zoom_min_get_wrapper(Eo* objid EINA_UNUSED, ::efl::eo::detail::Inherit_Private_Data* self)
{
   try
      {
         return static_cast<T*>(self->this_)->zoom_min_get();
      }
   catch (...)
      {
         eina_error_set( ::efl::eina::unknown_error() );
         int _tmp_ret{};
         return _tmp_ret;
      }
}

template <typename T>
void elm_map_zoom_min_set_wrapper(Eo* objid EINA_UNUSED, ::efl::eo::detail::Inherit_Private_Data* self, int zoom_)
{
   try
      {
         static_cast<T*>(self->this_)->zoom_min_set(zoom_);
      }
   catch (...)
      {
         eina_error_set( ::efl::eina::unknown_error() );
      }
}

template <typename T>
void elm_map_rotate_get_wrapper(Eo* objid EINA_UNUSED, ::efl::eo::detail::Inherit_Private_Data* self, double* degree_, Evas_Coord* cx_, Evas_Coord* cy_)
{
   try
      {
         static_cast<T*>(self->this_)->rotate_get(degree_, cx_, cy_);
      }
   catch (...)
      {
         eina_error_set( ::efl::eina::unknown_error() );
      }
}

template <typename T>
void elm_map_rotate_set_wrapper(Eo* objid EINA_UNUSED, ::efl::eo::detail::Inherit_Private_Data* self, double degree_, Evas_Coord cx_, Evas_Coord cy_)
{
   try
      {
         static_cast<T*>(self->this_)->rotate_set(degree_, cx_, cy_);
      }
   catch (...)
      {
         eina_error_set( ::efl::eina::unknown_error() );
      }
}

template <typename T>
::efl::eina::string_view elm_map_user_agent_get_wrapper(Eo* objid EINA_UNUSED, ::efl::eo::detail::Inherit_Private_Data* self)
{
   try
      {
         return static_cast<T*>(self->this_)->user_agent_get();
      }
   catch (...)
      {
         eina_error_set( ::efl::eina::unknown_error() );
         const char * _tmp_ret{};
         return ::efl::eolian::to_cxx<::efl::eina::string_view>(_tmp_ret, std::tuple<std::false_type>());
      }
}

template <typename T>
void elm_map_user_agent_set_wrapper(Eo* objid EINA_UNUSED, ::efl::eo::detail::Inherit_Private_Data* self, const char * user_agent_)
{
   try
      {
         static_cast<T*>(self->this_)->user_agent_set(::efl::eolian::to_cxx<::efl::eina::string_view>(user_agent_, std::tuple<std::false_type>()));
      }
   catch (...)
      {
         eina_error_set( ::efl::eina::unknown_error() );
      }
}

template <typename T>
int elm_map_zoom_max_get_wrapper(Eo* objid EINA_UNUSED, ::efl::eo::detail::Inherit_Private_Data* self)
{
   try
      {
         return static_cast<T*>(self->this_)->zoom_max_get();
      }
   catch (...)
      {
         eina_error_set( ::efl::eina::unknown_error() );
         int _tmp_ret{};
         return _tmp_ret;
      }
}

template <typename T>
void elm_map_zoom_max_set_wrapper(Eo* objid EINA_UNUSED, ::efl::eo::detail::Inherit_Private_Data* self, int zoom_)
{
   try
      {
         static_cast<T*>(self->this_)->zoom_max_set(zoom_);
      }
   catch (...)
      {
         eina_error_set( ::efl::eina::unknown_error() );
      }
}

template <typename T>
Elm_Map_Zoom_Mode elm_map_zoom_mode_get_wrapper(Eo* objid EINA_UNUSED, ::efl::eo::detail::Inherit_Private_Data* self)
{
   try
      {
         return static_cast<T*>(self->this_)->zoom_mode_get();
      }
   catch (...)
      {
         eina_error_set( ::efl::eina::unknown_error() );
         Elm_Map_Zoom_Mode _tmp_ret{};
         return _tmp_ret;
      }
}

template <typename T>
void elm_map_zoom_mode_set_wrapper(Eo* objid EINA_UNUSED, ::efl::eo::detail::Inherit_Private_Data* self, Elm_Map_Zoom_Mode mode_)
{
   try
      {
         static_cast<T*>(self->this_)->zoom_mode_set(mode_);
      }
   catch (...)
      {
         eina_error_set( ::efl::eina::unknown_error() );
      }
}

template <typename T>
void elm_map_region_get_wrapper(Eo* objid EINA_UNUSED, ::efl::eo::detail::Inherit_Private_Data* self, double* lon_, double* lat_)
{
   try
      {
         static_cast<T*>(self->this_)->region_get(lon_, lat_);
      }
   catch (...)
      {
         eina_error_set( ::efl::eina::unknown_error() );
      }
}

template <typename T>
::efl::eina::range_list< Elm_Map_Overlay * > elm_map_overlays_get_wrapper(Eo* objid EINA_UNUSED, ::efl::eo::detail::Inherit_Private_Data* self)
{
   try
      {
         return static_cast<T*>(self->this_)->overlays_get();
      }
   catch (...)
      {
         eina_error_set( ::efl::eina::unknown_error() );
         Eina_List * _tmp_ret{};
         return ::efl::eolian::to_cxx<::efl::eina::range_list< Elm_Map_Overlay * >>(_tmp_ret, std::tuple<std::false_type, std::false_type>());
      }
}

template <typename T>
void elm_map_tile_load_status_get_wrapper(Eo* objid EINA_UNUSED, ::efl::eo::detail::Inherit_Private_Data* self, int* try_num_, int* finish_num_)
{
   try
      {
         static_cast<T*>(self->this_)->tile_load_status_get(try_num_, finish_num_);
      }
   catch (...)
      {
         eina_error_set( ::efl::eina::unknown_error() );
      }
}

namespace efl { namespace eo { namespace detail {

template<>
struct operations< ::elm::map >
{
   template <typename T>
   struct type
         : virtual operations< ::elm::widget >::template type<T>
         , virtual operations< ::elm_interface_scrollable >::template type<T>
         , virtual operations< ::elm_interface_atspi_widget_action >::template type<T>
         , virtual operations< ::evas::clickable_interface >::template type<T>
   {
      virtual void source_set(Elm_Map_Source_Type type_, ::efl::eina::string_view source_name_)
      {

         eo_do_super(dynamic_cast<T*>(this)->_eo_ptr(),
               dynamic_cast<T*>(this)->_eo_class(),
               ::elm_obj_map_source_set(type_, ::efl::eolian::to_c(source_name_)));
      }

      virtual ::efl::eina::string_view source_get(Elm_Map_Source_Type type_)
      {
         const char * _tmp_ret = {};

         eo_do_super(dynamic_cast<T*>(this)->_eo_ptr(),
               dynamic_cast<T*>(this)->_eo_class(),
               _tmp_ret = ::elm_obj_map_source_get(type_));
            return ::efl::eolian::to_cxx<::efl::eina::string_view>(_tmp_ret, std::tuple<std::false_type>());
      }

      virtual Elm_Map_Route * route_add(Elm_Map_Route_Type type_, Elm_Map_Route_Method method_, double flon_, double flat_, double tlon_, double tlat_, Elm_Map_Route_Cb route_cb_, void * data_)
      {
         Elm_Map_Route * _tmp_ret = {};

         eo_do_super(dynamic_cast<T*>(this)->_eo_ptr(),
               dynamic_cast<T*>(this)->_eo_class(),
               _tmp_ret = ::elm_obj_map_route_add(type_, method_, flon_, flat_, tlon_, tlat_, route_cb_, data_));
            return _tmp_ret;
      }

      virtual ::evas::object track_add(void * emap_)
      {
         Evas_Object * _tmp_ret = {};

         eo_do_super(dynamic_cast<T*>(this)->_eo_ptr(),
               dynamic_cast<T*>(this)->_eo_class(),
               _tmp_ret = ::elm_obj_map_track_add(emap_));
            return ::efl::eolian::to_cxx<::evas::object>(_tmp_ret, std::tuple<std::false_type>());
      }

      virtual void region_to_canvas_convert(double lon_, double lat_, Evas_Coord* x_, Evas_Coord* y_)
      {

         eo_do_super(dynamic_cast<T*>(this)->_eo_ptr(),
               dynamic_cast<T*>(this)->_eo_class(),
               ::elm_obj_map_region_to_canvas_convert(lon_, lat_, x_, y_));
      }

      virtual Elm_Map_Overlay * overlay_circle_add(double lon_, double lat_, double radius_)
      {
         Elm_Map_Overlay * _tmp_ret = {};

         eo_do_super(dynamic_cast<T*>(this)->_eo_ptr(),
               dynamic_cast<T*>(this)->_eo_class(),
               _tmp_ret = ::elm_obj_map_overlay_circle_add(lon_, lat_, radius_));
            return _tmp_ret;
      }

      virtual Elm_Map_Overlay * overlay_class_add()
      {
         Elm_Map_Overlay * _tmp_ret = {};

         eo_do_super(dynamic_cast<T*>(this)->_eo_ptr(),
               dynamic_cast<T*>(this)->_eo_class(),
               _tmp_ret = ::elm_obj_map_overlay_class_add());
            return _tmp_ret;
      }

      virtual Elm_Map_Overlay * overlay_bubble_add()
      {
         Elm_Map_Overlay * _tmp_ret = {};

         eo_do_super(dynamic_cast<T*>(this)->_eo_ptr(),
               dynamic_cast<T*>(this)->_eo_class(),
               _tmp_ret = ::elm_obj_map_overlay_bubble_add());
            return _tmp_ret;
      }

      virtual const char ** sources_get(Elm_Map_Source_Type type_)
      {
         const char ** _tmp_ret = {};

         eo_do_super(dynamic_cast<T*>(this)->_eo_ptr(),
               dynamic_cast<T*>(this)->_eo_class(),
               _tmp_ret = ::elm_obj_map_sources_get(type_));
            return _tmp_ret;
      }

      virtual Elm_Map_Overlay * overlay_polygon_add()
      {
         Elm_Map_Overlay * _tmp_ret = {};

         eo_do_super(dynamic_cast<T*>(this)->_eo_ptr(),
               dynamic_cast<T*>(this)->_eo_class(),
               _tmp_ret = ::elm_obj_map_overlay_polygon_add());
            return _tmp_ret;
      }

      virtual Elm_Map_Overlay * overlay_line_add(double flon_, double flat_, double tlon_, double tlat_)
      {
         Elm_Map_Overlay * _tmp_ret = {};

         eo_do_super(dynamic_cast<T*>(this)->_eo_ptr(),
               dynamic_cast<T*>(this)->_eo_class(),
               _tmp_ret = ::elm_obj_map_overlay_line_add(flon_, flat_, tlon_, tlat_));
            return _tmp_ret;
      }

      virtual void region_show(double lon_, double lat_)
      {

         eo_do_super(dynamic_cast<T*>(this)->_eo_ptr(),
               dynamic_cast<T*>(this)->_eo_class(),
               ::elm_obj_map_region_show(lon_, lat_));
      }

      virtual Elm_Map_Name * name_add(::efl::eina::optional< ::efl::eina::string_view > address_, double lon_, double lat_, Elm_Map_Name_Cb name_cb_, void * data_)
      {
         Elm_Map_Name * _tmp_ret = {};

         eo_do_super(dynamic_cast<T*>(this)->_eo_ptr(),
               dynamic_cast<T*>(this)->_eo_class(),
               _tmp_ret = ::elm_obj_map_name_add(::efl::eolian::to_c(address_), lon_, lat_, name_cb_, data_));
            return _tmp_ret;
      }

      virtual void name_search(::efl::eina::string_view address_, Elm_Map_Name_List_Cb name_cb_, void * data_)
      {

         eo_do_super(dynamic_cast<T*>(this)->_eo_ptr(),
               dynamic_cast<T*>(this)->_eo_class(),
               ::elm_obj_map_name_search(::efl::eolian::to_c(address_), name_cb_, data_));
      }

      virtual void region_bring_in(double lon_, double lat_)
      {

         eo_do_super(dynamic_cast<T*>(this)->_eo_ptr(),
               dynamic_cast<T*>(this)->_eo_class(),
               ::elm_obj_map_region_bring_in(lon_, lat_));
      }

      virtual void region_zoom_bring_in(int zoom_, double lon_, double lat_)
      {

         eo_do_super(dynamic_cast<T*>(this)->_eo_ptr(),
               dynamic_cast<T*>(this)->_eo_class(),
               ::elm_obj_map_region_zoom_bring_in(zoom_, lon_, lat_));
      }

      virtual void track_remove(::evas::object route_)
      {

         eo_do_super(dynamic_cast<T*>(this)->_eo_ptr(),
               dynamic_cast<T*>(this)->_eo_class(),
               ::elm_obj_map_track_remove(::efl::eolian::to_c(route_)));
      }

      virtual Elm_Map_Overlay * overlay_route_add(const Elm_Map_Route * route_)
      {
         Elm_Map_Overlay * _tmp_ret = {};

         eo_do_super(dynamic_cast<T*>(this)->_eo_ptr(),
               dynamic_cast<T*>(this)->_eo_class(),
               _tmp_ret = ::elm_obj_map_overlay_route_add(route_));
            return _tmp_ret;
      }

      virtual Elm_Map_Overlay * overlay_scale_add(Evas_Coord x_, Evas_Coord y_)
      {
         Elm_Map_Overlay * _tmp_ret = {};

         eo_do_super(dynamic_cast<T*>(this)->_eo_ptr(),
               dynamic_cast<T*>(this)->_eo_class(),
               _tmp_ret = ::elm_obj_map_overlay_scale_add(x_, y_));
            return _tmp_ret;
      }

      virtual Elm_Map_Overlay * overlay_add(double lon_, double lat_)
      {
         Elm_Map_Overlay * _tmp_ret = {};

         eo_do_super(dynamic_cast<T*>(this)->_eo_ptr(),
               dynamic_cast<T*>(this)->_eo_class(),
               _tmp_ret = ::elm_obj_map_overlay_add(lon_, lat_));
            return _tmp_ret;
      }

      virtual void canvas_to_region_convert(Evas_Coord x_, Evas_Coord y_, double* lon_, double* lat_)
      {

         eo_do_super(dynamic_cast<T*>(this)->_eo_ptr(),
               dynamic_cast<T*>(this)->_eo_class(),
               ::elm_obj_map_canvas_to_region_convert(x_, y_, lon_, lat_));
      }

      virtual int zoom_get()
      {
         int _tmp_ret = {};

         eo_do_super(dynamic_cast<T*>(this)->_eo_ptr(),
               dynamic_cast<T*>(this)->_eo_class(),
               _tmp_ret = ::elm_obj_map_zoom_get());
            return _tmp_ret;
      }

      virtual void zoom_set(int zoom_)
      {

         eo_do_super(dynamic_cast<T*>(this)->_eo_ptr(),
               dynamic_cast<T*>(this)->_eo_class(),
               ::elm_obj_map_zoom_set(zoom_));
      }

      virtual bool paused_get()
      {
         Eina_Bool _tmp_ret = {};

         eo_do_super(dynamic_cast<T*>(this)->_eo_ptr(),
               dynamic_cast<T*>(this)->_eo_class(),
               _tmp_ret = ::elm_obj_map_paused_get());
            return ::efl::eolian::to_cxx<bool>(_tmp_ret, std::tuple<std::false_type>());
      }

      virtual void paused_set(bool paused_)
      {

         eo_do_super(dynamic_cast<T*>(this)->_eo_ptr(),
               dynamic_cast<T*>(this)->_eo_class(),
               ::elm_obj_map_paused_set(::efl::eolian::to_c(paused_)));
      }

      virtual bool wheel_disabled_get()
      {
         Eina_Bool _tmp_ret = {};

         eo_do_super(dynamic_cast<T*>(this)->_eo_ptr(),
               dynamic_cast<T*>(this)->_eo_class(),
               _tmp_ret = ::elm_obj_map_wheel_disabled_get());
            return ::efl::eolian::to_cxx<bool>(_tmp_ret, std::tuple<std::false_type>());
      }

      virtual void wheel_disabled_set(bool disabled_)
      {

         eo_do_super(dynamic_cast<T*>(this)->_eo_ptr(),
               dynamic_cast<T*>(this)->_eo_class(),
               ::elm_obj_map_wheel_disabled_set(::efl::eolian::to_c(disabled_)));
      }

      virtual int zoom_min_get()
      {
         int _tmp_ret = {};

         eo_do_super(dynamic_cast<T*>(this)->_eo_ptr(),
               dynamic_cast<T*>(this)->_eo_class(),
               _tmp_ret = ::elm_obj_map_zoom_min_get());
            return _tmp_ret;
      }

      virtual void zoom_min_set(int zoom_)
      {

         eo_do_super(dynamic_cast<T*>(this)->_eo_ptr(),
               dynamic_cast<T*>(this)->_eo_class(),
               ::elm_obj_map_zoom_min_set(zoom_));
      }

      virtual void rotate_get(double* degree_, Evas_Coord* cx_, Evas_Coord* cy_)
      {

         eo_do_super(dynamic_cast<T*>(this)->_eo_ptr(),
               dynamic_cast<T*>(this)->_eo_class(),
               ::elm_obj_map_rotate_get(degree_, cx_, cy_));
      }

      virtual void rotate_set(double degree_, Evas_Coord cx_, Evas_Coord cy_)
      {

         eo_do_super(dynamic_cast<T*>(this)->_eo_ptr(),
               dynamic_cast<T*>(this)->_eo_class(),
               ::elm_obj_map_rotate_set(degree_, cx_, cy_));
      }

      virtual ::efl::eina::string_view user_agent_get()
      {
         const char * _tmp_ret = {};

         eo_do_super(dynamic_cast<T*>(this)->_eo_ptr(),
               dynamic_cast<T*>(this)->_eo_class(),
               _tmp_ret = ::elm_obj_map_user_agent_get());
            return ::efl::eolian::to_cxx<::efl::eina::string_view>(_tmp_ret, std::tuple<std::false_type>());
      }

      virtual void user_agent_set(::efl::eina::string_view user_agent_)
      {

         eo_do_super(dynamic_cast<T*>(this)->_eo_ptr(),
               dynamic_cast<T*>(this)->_eo_class(),
               ::elm_obj_map_user_agent_set(::efl::eolian::to_c(user_agent_)));
      }

      virtual int zoom_max_get()
      {
         int _tmp_ret = {};

         eo_do_super(dynamic_cast<T*>(this)->_eo_ptr(),
               dynamic_cast<T*>(this)->_eo_class(),
               _tmp_ret = ::elm_obj_map_zoom_max_get());
            return _tmp_ret;
      }

      virtual void zoom_max_set(int zoom_)
      {

         eo_do_super(dynamic_cast<T*>(this)->_eo_ptr(),
               dynamic_cast<T*>(this)->_eo_class(),
               ::elm_obj_map_zoom_max_set(zoom_));
      }

      virtual Elm_Map_Zoom_Mode zoom_mode_get()
      {
         Elm_Map_Zoom_Mode _tmp_ret = {};

         eo_do_super(dynamic_cast<T*>(this)->_eo_ptr(),
               dynamic_cast<T*>(this)->_eo_class(),
               _tmp_ret = ::elm_obj_map_zoom_mode_get());
            return _tmp_ret;
      }

      virtual void zoom_mode_set(Elm_Map_Zoom_Mode mode_)
      {

         eo_do_super(dynamic_cast<T*>(this)->_eo_ptr(),
               dynamic_cast<T*>(this)->_eo_class(),
               ::elm_obj_map_zoom_mode_set(mode_));
      }

      virtual void region_get(double* lon_, double* lat_)
      {

         eo_do_super(dynamic_cast<T*>(this)->_eo_ptr(),
               dynamic_cast<T*>(this)->_eo_class(),
               ::elm_obj_map_region_get(lon_, lat_));
      }

      virtual ::efl::eina::range_list< Elm_Map_Overlay * > overlays_get()
      {
         Eina_List * _tmp_ret = {};

         eo_do_super(dynamic_cast<T*>(this)->_eo_ptr(),
               dynamic_cast<T*>(this)->_eo_class(),
               _tmp_ret = ::elm_obj_map_overlays_get());
            return ::efl::eolian::to_cxx<::efl::eina::range_list< Elm_Map_Overlay * >>(_tmp_ret, std::tuple<std::false_type, std::false_type>());
      }

      virtual void tile_load_status_get(int* try_num_, int* finish_num_)
      {

         eo_do_super(dynamic_cast<T*>(this)->_eo_ptr(),
               dynamic_cast<T*>(this)->_eo_class(),
               ::elm_obj_map_tile_load_status_get(try_num_, finish_num_));
      }

   };
};


template<>
struct operation_description_class_size< ::elm::map >
{
   static constexpr int value = 
#if defined(MAP_PROTECTED) && defined(MAP_BETA)
      40
#elif defined(MAP_PROTECTED)
      40
#elif defined(MAP_BETA)
      40
#else
      40
#endif
      + operation_description_class_size<::elm::widget >::value      + operation_description_class_size<::elm_interface_scrollable >::value      + operation_description_class_size<::elm_interface_atspi_widget_action >::value      + operation_description_class_size<::evas::clickable_interface >::value;
};

template <typename T>
int initialize_operation_description(::efl::eo::detail::tag<::elm::map>
                                 , Eo_Op_Description* ops)
{
   int i = 0;
   (void)i;
   (void)ops;
   ops[i].func = reinterpret_cast<void*>(& ::elm_map_source_set_wrapper<T>);
   ops[i].api_func = reinterpret_cast<void*>(& ::elm_obj_map_source_set);
   ops[i].op_type = EO_OP_TYPE_REGULAR;
   ++i;

   ops[i].func = reinterpret_cast<void*>(& ::elm_map_source_get_wrapper<T>);
   ops[i].api_func = reinterpret_cast<void*>(& ::elm_obj_map_source_get);
   ops[i].op_type = EO_OP_TYPE_REGULAR;
   ++i;

   ops[i].func = reinterpret_cast<void*>(& ::elm_map_route_add_wrapper<T>);
   ops[i].api_func = reinterpret_cast<void*>(& ::elm_obj_map_route_add);
   ops[i].op_type = EO_OP_TYPE_REGULAR;
   ++i;

   ops[i].func = reinterpret_cast<void*>(& ::elm_map_track_add_wrapper<T>);
   ops[i].api_func = reinterpret_cast<void*>(& ::elm_obj_map_track_add);
   ops[i].op_type = EO_OP_TYPE_REGULAR;
   ++i;

   ops[i].func = reinterpret_cast<void*>(& ::elm_map_region_to_canvas_convert_wrapper<T>);
   ops[i].api_func = reinterpret_cast<void*>(& ::elm_obj_map_region_to_canvas_convert);
   ops[i].op_type = EO_OP_TYPE_REGULAR;
   ++i;

   ops[i].func = reinterpret_cast<void*>(& ::elm_map_overlay_circle_add_wrapper<T>);
   ops[i].api_func = reinterpret_cast<void*>(& ::elm_obj_map_overlay_circle_add);
   ops[i].op_type = EO_OP_TYPE_REGULAR;
   ++i;

   ops[i].func = reinterpret_cast<void*>(& ::elm_map_overlay_class_add_wrapper<T>);
   ops[i].api_func = reinterpret_cast<void*>(& ::elm_obj_map_overlay_class_add);
   ops[i].op_type = EO_OP_TYPE_REGULAR;
   ++i;

   ops[i].func = reinterpret_cast<void*>(& ::elm_map_overlay_bubble_add_wrapper<T>);
   ops[i].api_func = reinterpret_cast<void*>(& ::elm_obj_map_overlay_bubble_add);
   ops[i].op_type = EO_OP_TYPE_REGULAR;
   ++i;

   ops[i].func = reinterpret_cast<void*>(& ::elm_map_sources_get_wrapper<T>);
   ops[i].api_func = reinterpret_cast<void*>(& ::elm_obj_map_sources_get);
   ops[i].op_type = EO_OP_TYPE_REGULAR;
   ++i;

   ops[i].func = reinterpret_cast<void*>(& ::elm_map_overlay_polygon_add_wrapper<T>);
   ops[i].api_func = reinterpret_cast<void*>(& ::elm_obj_map_overlay_polygon_add);
   ops[i].op_type = EO_OP_TYPE_REGULAR;
   ++i;

   ops[i].func = reinterpret_cast<void*>(& ::elm_map_overlay_line_add_wrapper<T>);
   ops[i].api_func = reinterpret_cast<void*>(& ::elm_obj_map_overlay_line_add);
   ops[i].op_type = EO_OP_TYPE_REGULAR;
   ++i;

   ops[i].func = reinterpret_cast<void*>(& ::elm_map_region_show_wrapper<T>);
   ops[i].api_func = reinterpret_cast<void*>(& ::elm_obj_map_region_show);
   ops[i].op_type = EO_OP_TYPE_REGULAR;
   ++i;

   ops[i].func = reinterpret_cast<void*>(& ::elm_map_name_add_wrapper<T>);
   ops[i].api_func = reinterpret_cast<void*>(& ::elm_obj_map_name_add);
   ops[i].op_type = EO_OP_TYPE_REGULAR;
   ++i;

   ops[i].func = reinterpret_cast<void*>(& ::elm_map_name_search_wrapper<T>);
   ops[i].api_func = reinterpret_cast<void*>(& ::elm_obj_map_name_search);
   ops[i].op_type = EO_OP_TYPE_REGULAR;
   ++i;

   ops[i].func = reinterpret_cast<void*>(& ::elm_map_region_bring_in_wrapper<T>);
   ops[i].api_func = reinterpret_cast<void*>(& ::elm_obj_map_region_bring_in);
   ops[i].op_type = EO_OP_TYPE_REGULAR;
   ++i;

   ops[i].func = reinterpret_cast<void*>(& ::elm_map_region_zoom_bring_in_wrapper<T>);
   ops[i].api_func = reinterpret_cast<void*>(& ::elm_obj_map_region_zoom_bring_in);
   ops[i].op_type = EO_OP_TYPE_REGULAR;
   ++i;

   ops[i].func = reinterpret_cast<void*>(& ::elm_map_track_remove_wrapper<T>);
   ops[i].api_func = reinterpret_cast<void*>(& ::elm_obj_map_track_remove);
   ops[i].op_type = EO_OP_TYPE_REGULAR;
   ++i;

   ops[i].func = reinterpret_cast<void*>(& ::elm_map_overlay_route_add_wrapper<T>);
   ops[i].api_func = reinterpret_cast<void*>(& ::elm_obj_map_overlay_route_add);
   ops[i].op_type = EO_OP_TYPE_REGULAR;
   ++i;

   ops[i].func = reinterpret_cast<void*>(& ::elm_map_overlay_scale_add_wrapper<T>);
   ops[i].api_func = reinterpret_cast<void*>(& ::elm_obj_map_overlay_scale_add);
   ops[i].op_type = EO_OP_TYPE_REGULAR;
   ++i;

   ops[i].func = reinterpret_cast<void*>(& ::elm_map_overlay_add_wrapper<T>);
   ops[i].api_func = reinterpret_cast<void*>(& ::elm_obj_map_overlay_add);
   ops[i].op_type = EO_OP_TYPE_REGULAR;
   ++i;

   ops[i].func = reinterpret_cast<void*>(& ::elm_map_canvas_to_region_convert_wrapper<T>);
   ops[i].api_func = reinterpret_cast<void*>(& ::elm_obj_map_canvas_to_region_convert);
   ops[i].op_type = EO_OP_TYPE_REGULAR;
   ++i;

   ops[i].func = reinterpret_cast<void*>(& ::elm_map_zoom_get_wrapper<T>);
   ops[i].api_func = reinterpret_cast<void*>(& ::elm_obj_map_zoom_get);
   ops[i].op_type = EO_OP_TYPE_REGULAR;
   ++i;

   ops[i].func = reinterpret_cast<void*>(& ::elm_map_zoom_set_wrapper<T>);
   ops[i].api_func = reinterpret_cast<void*>(& ::elm_obj_map_zoom_set);
   ops[i].op_type = EO_OP_TYPE_REGULAR;
   ++i;

   ops[i].func = reinterpret_cast<void*>(& ::elm_map_paused_get_wrapper<T>);
   ops[i].api_func = reinterpret_cast<void*>(& ::elm_obj_map_paused_get);
   ops[i].op_type = EO_OP_TYPE_REGULAR;
   ++i;

   ops[i].func = reinterpret_cast<void*>(& ::elm_map_paused_set_wrapper<T>);
   ops[i].api_func = reinterpret_cast<void*>(& ::elm_obj_map_paused_set);
   ops[i].op_type = EO_OP_TYPE_REGULAR;
   ++i;

   ops[i].func = reinterpret_cast<void*>(& ::elm_map_wheel_disabled_get_wrapper<T>);
   ops[i].api_func = reinterpret_cast<void*>(& ::elm_obj_map_wheel_disabled_get);
   ops[i].op_type = EO_OP_TYPE_REGULAR;
   ++i;

   ops[i].func = reinterpret_cast<void*>(& ::elm_map_wheel_disabled_set_wrapper<T>);
   ops[i].api_func = reinterpret_cast<void*>(& ::elm_obj_map_wheel_disabled_set);
   ops[i].op_type = EO_OP_TYPE_REGULAR;
   ++i;

   ops[i].func = reinterpret_cast<void*>(& ::elm_map_zoom_min_get_wrapper<T>);
   ops[i].api_func = reinterpret_cast<void*>(& ::elm_obj_map_zoom_min_get);
   ops[i].op_type = EO_OP_TYPE_REGULAR;
   ++i;

   ops[i].func = reinterpret_cast<void*>(& ::elm_map_zoom_min_set_wrapper<T>);
   ops[i].api_func = reinterpret_cast<void*>(& ::elm_obj_map_zoom_min_set);
   ops[i].op_type = EO_OP_TYPE_REGULAR;
   ++i;

   ops[i].func = reinterpret_cast<void*>(& ::elm_map_rotate_get_wrapper<T>);
   ops[i].api_func = reinterpret_cast<void*>(& ::elm_obj_map_rotate_get);
   ops[i].op_type = EO_OP_TYPE_REGULAR;
   ++i;

   ops[i].func = reinterpret_cast<void*>(& ::elm_map_rotate_set_wrapper<T>);
   ops[i].api_func = reinterpret_cast<void*>(& ::elm_obj_map_rotate_set);
   ops[i].op_type = EO_OP_TYPE_REGULAR;
   ++i;

   ops[i].func = reinterpret_cast<void*>(& ::elm_map_user_agent_get_wrapper<T>);
   ops[i].api_func = reinterpret_cast<void*>(& ::elm_obj_map_user_agent_get);
   ops[i].op_type = EO_OP_TYPE_REGULAR;
   ++i;

   ops[i].func = reinterpret_cast<void*>(& ::elm_map_user_agent_set_wrapper<T>);
   ops[i].api_func = reinterpret_cast<void*>(& ::elm_obj_map_user_agent_set);
   ops[i].op_type = EO_OP_TYPE_REGULAR;
   ++i;

   ops[i].func = reinterpret_cast<void*>(& ::elm_map_zoom_max_get_wrapper<T>);
   ops[i].api_func = reinterpret_cast<void*>(& ::elm_obj_map_zoom_max_get);
   ops[i].op_type = EO_OP_TYPE_REGULAR;
   ++i;

   ops[i].func = reinterpret_cast<void*>(& ::elm_map_zoom_max_set_wrapper<T>);
   ops[i].api_func = reinterpret_cast<void*>(& ::elm_obj_map_zoom_max_set);
   ops[i].op_type = EO_OP_TYPE_REGULAR;
   ++i;

   ops[i].func = reinterpret_cast<void*>(& ::elm_map_zoom_mode_get_wrapper<T>);
   ops[i].api_func = reinterpret_cast<void*>(& ::elm_obj_map_zoom_mode_get);
   ops[i].op_type = EO_OP_TYPE_REGULAR;
   ++i;

   ops[i].func = reinterpret_cast<void*>(& ::elm_map_zoom_mode_set_wrapper<T>);
   ops[i].api_func = reinterpret_cast<void*>(& ::elm_obj_map_zoom_mode_set);
   ops[i].op_type = EO_OP_TYPE_REGULAR;
   ++i;

   ops[i].func = reinterpret_cast<void*>(& ::elm_map_region_get_wrapper<T>);
   ops[i].api_func = reinterpret_cast<void*>(& ::elm_obj_map_region_get);
   ops[i].op_type = EO_OP_TYPE_REGULAR;
   ++i;

   ops[i].func = reinterpret_cast<void*>(& ::elm_map_overlays_get_wrapper<T>);
   ops[i].api_func = reinterpret_cast<void*>(& ::elm_obj_map_overlays_get);
   ops[i].op_type = EO_OP_TYPE_REGULAR;
   ++i;

   ops[i].func = reinterpret_cast<void*>(& ::elm_map_tile_load_status_get_wrapper<T>);
   ops[i].api_func = reinterpret_cast<void*>(& ::elm_obj_map_tile_load_status_get);
   ops[i].op_type = EO_OP_TYPE_REGULAR;
   ++i;

   initialize_operation_description<T>(::efl::eo::detail::tag<::elm::widget>(), &ops[operation_description_class_size< ::elm::map >::value]);
   initialize_operation_description<T>(::efl::eo::detail::tag<::elm_interface_scrollable>(), &ops[operation_description_class_size< ::elm::map >::value + operation_description_class_size<::elm::widget>::value]);
   initialize_operation_description<T>(::efl::eo::detail::tag<::elm_interface_atspi_widget_action>(), &ops[operation_description_class_size< ::elm::map >::value + operation_description_class_size<::elm::widget>::value + operation_description_class_size<::elm_interface_scrollable>::value]);
   initialize_operation_description<T>(::efl::eo::detail::tag<::evas::clickable_interface>(), &ops[operation_description_class_size< ::elm::map >::value + operation_description_class_size<::elm::widget>::value + operation_description_class_size<::elm_interface_scrollable>::value + operation_description_class_size<::elm_interface_atspi_widget_action>::value]);
   return 0;
}
inline Eo_Class const* get_eo_class(tag<::elm::map>)
{
   return (ELM_MAP_CLASS);
}

} } }

/// @endcond

