From fd8dc7ea3ba5583eda14808b13020f104b02729d Mon Sep 17 00:00:00 2001 From: Date: Thu, 17 Mar 2016 10:41:06 +0100 Subject: Alignment with the latest version of positioning --- src/navigation/README | 2 +- .../node-cpp-lbs-modules/PositioningWrapper.cpp | 84 ++ .../node-cpp-lbs-modules/PositioningWrapper.hpp | 62 + .../node-cpp-lbs-modules/binding.gyp | 17 + .../dbus-proxies/NavigationCoreProxy.hpp | 4 +- .../dbus-proxies/POIServiceProxy.hpp | 4 +- .../dbus-proxies/PositioningProxy.cpp | 65 + .../dbus-proxies/PositioningProxy.hpp | 65 + .../dbus-proxies/genivi-dbus-model.h | 1569 ++++++++++++++++++++ 9 files changed, 1865 insertions(+), 7 deletions(-) create mode 100644 test/navigation/w3c/socket-based-poc/node-cpp-lbs-modules/PositioningWrapper.cpp create mode 100644 test/navigation/w3c/socket-based-poc/node-cpp-lbs-modules/PositioningWrapper.hpp create mode 100644 test/navigation/w3c/socket-based-poc/node-cpp-lbs-modules/dbus-proxies/PositioningProxy.cpp create mode 100644 test/navigation/w3c/socket-based-poc/node-cpp-lbs-modules/dbus-proxies/PositioningProxy.hpp create mode 100644 test/navigation/w3c/socket-based-poc/node-cpp-lbs-modules/dbus-proxies/genivi-dbus-model.h diff --git a/src/navigation/README b/src/navigation/README index 14daf7e..4e3bf69 100644 --- a/src/navigation/README +++ b/src/navigation/README @@ -28,7 +28,7 @@ Ubuntu 14.04 LTS =============================== Current versions of additional code =============================== - (git): 5b6b120d836259afb57b3ad6bf2f6ba8107c4a3e + (git): 48451e36a8c21afb00575227d27e10417c27878c (git): 162a3e43d14531a7053872903674351a3142eea2 =============================== diff --git a/test/navigation/w3c/socket-based-poc/node-cpp-lbs-modules/PositioningWrapper.cpp b/test/navigation/w3c/socket-based-poc/node-cpp-lbs-modules/PositioningWrapper.cpp new file mode 100644 index 0000000..a4c163e --- /dev/null +++ b/test/navigation/w3c/socket-based-poc/node-cpp-lbs-modules/PositioningWrapper.cpp @@ -0,0 +1,84 @@ +/** +* @licence app begin@ +* SPDX-License-Identifier: MPL-2.0 +* +* \copyright Copyright (C) 2016, PCA Peugeot Citroen +* +* \file main.cpp +* +* \brief This file is part of the Navigation Web API proof of concept. +* +* \author Philippe Colliot +* +* \version 0.1 +* +* This Source Code Form is subject to the terms of the +* Mozilla Public License (MPL), v. 2.0. +* If a copy of the MPL was not distributed with this file, +* You can obtain one at http://mozilla.org/MPL/2.0/. +* +* For further information see http://www.genivi.org/. +* +* List of changes: +* , , +* +* @licence end@ +*/ +#include + +#include "PositioningWrapper.hpp" + +using namespace v8; +using namespace std; + + +Persistent PositioningWrapper::constructor; + + +void PositioningWrapper::Init(Handle target) { + HandleScope scope; + + Local tpl = FunctionTemplate::New(New); + Local name = String::NewSymbol("PositioningWrapper"); + + constructor = Persistent::New(tpl); + // ObjectWrap uses the first internal field to store the wrapped pointer. + constructor->InstanceTemplate()->SetInternalFieldCount(1); + constructor->SetClassName(name); + + // Add all prototype methods, getters and setters here. + + // This has to be last, otherwise the properties won't show up on the + // object in JavaScript. + target->Set(name, constructor->GetFunction()); +} + +PositioningWrapper::PositioningWrapper() { +} + +PositioningWrapper::~PositioningWrapper() { +} + +Handle PositioningWrapper::New(const Arguments& args) { + HandleScope scope; + + if (!args.IsConstructCall()) { + return ThrowException(Exception::TypeError( + String::New("Use the new operator to create instances of this object.")) + ); + } + PositioningProxy* proxy = new PositioningProxy(); + + // Creates a new instance object of this type and wraps it. + PositioningWrapper* obj = new PositioningWrapper(); + obj->mp_proxy = proxy; + obj->Wrap(args.This()); + + return args.This(); +} + +void RegisterModule(Handle target) { + PositioningWrapper::Init(target); +} + +NODE_MODULE(PositioningWrapper, RegisterModule); diff --git a/test/navigation/w3c/socket-based-poc/node-cpp-lbs-modules/PositioningWrapper.hpp b/test/navigation/w3c/socket-based-poc/node-cpp-lbs-modules/PositioningWrapper.hpp new file mode 100644 index 0000000..fb87a86 --- /dev/null +++ b/test/navigation/w3c/socket-based-poc/node-cpp-lbs-modules/PositioningWrapper.hpp @@ -0,0 +1,62 @@ +/** +* @licence app begin@ +* SPDX-License-Identifier: MPL-2.0 +* +* \copyright Copyright (C) 2016, PCA Peugeot Citroen +* +* \file main.cpp +* +* \brief This file is part of the Navigation Web API proof of concept. +* +* \author Philippe Colliot +* +* \version 0.1 +* +* This Source Code Form is subject to the terms of the +* Mozilla Public License (MPL), v. 2.0. +* If a copy of the MPL was not distributed with this file, +* You can obtain one at http://mozilla.org/MPL/2.0/. +* +* For further information see http://www.genivi.org/. +* +* List of changes: +* , , +* +* @licence end@ +*/ +#ifndef POSITIONINGWRAPPER_HPP +#define POSITIONINGWRAPPER_HPP + +#define USE_DBUS 0 + +#include +#include + +#include "./dbus-proxies/PositioningProxy.hpp" + +#include +#include +#include + +// Do not include this line. It's generally frowned upon to use namespaces +// in header files as it may cause issues with other code that includes your +// header file. +// using namespace v8; + +class PositioningWrapper : public node::ObjectWrap { +public: + static v8::Persistent constructor; + static void Init(v8::Handle target); + +protected: + PositioningWrapper(); + ~PositioningWrapper(); + + static v8::Handle New(const v8::Arguments& args); + +private: + + PositioningProxy* mp_proxy; +}; + +#endif diff --git a/test/navigation/w3c/socket-based-poc/node-cpp-lbs-modules/binding.gyp b/test/navigation/w3c/socket-based-poc/node-cpp-lbs-modules/binding.gyp index 28b9194..24d8eb5 100644 --- a/test/navigation/w3c/socket-based-poc/node-cpp-lbs-modules/binding.gyp +++ b/test/navigation/w3c/socket-based-poc/node-cpp-lbs-modules/binding.gyp @@ -33,6 +33,23 @@ 'include_dirs': ['./','./dbus-proxies','/usr/include/dbus-c++-1/','/usr/include/glib-2.0/','/usr/lib/i386-linux-gnu/glib-2.0/include/'], 'cflags_cc': ['-Wall', '-std=gnu++11', '-fexceptions'], 'libraries': ['-ldbus-c++-1 -ldbus-1 -ldbus-c++-glib-1', '-L/usr/lib/i386-linux-gnu/'] + }, + { + 'target_name': 'PositioningProxy', + 'product_prefix': 'lib', + 'type': 'shared_library', + 'sources': [ './dbus-proxies/PositioningProxy.cpp' ], + 'include_dirs': ['./','/usr/include/dbus-c++-1/','/usr/include/glib-2.0/','/usr/lib/i386-linux-gnu/glib-2.0/include/'], + 'cflags_cc': ['-Wall', '-std=gnu++11', '-fexceptions','-fPIC'], + 'libraries': ['-ldbus-c++-1 -ldbus-1 -ldbus-c++-glib-1', '-L/usr/lib/i386-linux-gnu/'] + }, + { + 'target_name': 'PositioningWrapper', + 'dependencies': [ 'PositioningProxy' ], + 'sources': [ './PositioningWrapper.cpp' ], + 'include_dirs': ['./','./dbus-proxies','/usr/include/dbus-c++-1/','/usr/include/glib-2.0/','/usr/lib/i386-linux-gnu/glib-2.0/include/'], + 'cflags_cc': ['-Wall', '-std=gnu++11', '-fexceptions'], + 'libraries': ['-ldbus-c++-1 -ldbus-1 -ldbus-c++-glib-1', '-L/usr/lib/i386-linux-gnu/'] } ] } diff --git a/test/navigation/w3c/socket-based-poc/node-cpp-lbs-modules/dbus-proxies/NavigationCoreProxy.hpp b/test/navigation/w3c/socket-based-poc/node-cpp-lbs-modules/dbus-proxies/NavigationCoreProxy.hpp index 1f7a028..321c29a 100644 --- a/test/navigation/w3c/socket-based-poc/node-cpp-lbs-modules/dbus-proxies/NavigationCoreProxy.hpp +++ b/test/navigation/w3c/socket-based-poc/node-cpp-lbs-modules/dbus-proxies/NavigationCoreProxy.hpp @@ -27,9 +27,7 @@ #ifndef NAVIGATIONCOREPROXY_HPP #define NAVIGATIONCOREPROXY_HPP -#include -#include "genivi-navigationcore-constants.h" -#include "genivi-navigationcore-configuration_proxy.h" +#include "genivi-dbus-model.h" #include #include diff --git a/test/navigation/w3c/socket-based-poc/node-cpp-lbs-modules/dbus-proxies/POIServiceProxy.hpp b/test/navigation/w3c/socket-based-poc/node-cpp-lbs-modules/dbus-proxies/POIServiceProxy.hpp index d42b3a7..8331811 100644 --- a/test/navigation/w3c/socket-based-poc/node-cpp-lbs-modules/dbus-proxies/POIServiceProxy.hpp +++ b/test/navigation/w3c/socket-based-poc/node-cpp-lbs-modules/dbus-proxies/POIServiceProxy.hpp @@ -27,9 +27,7 @@ #ifndef POISERVICEPROXY_HPP #define POISERVICEPROXY_HPP -#include -#include "genivi-poiservice-constants.h" -#include "genivi-poiservice-poisearch_proxy.h" +#include "genivi-dbus-model.h" #include #include diff --git a/test/navigation/w3c/socket-based-poc/node-cpp-lbs-modules/dbus-proxies/PositioningProxy.cpp b/test/navigation/w3c/socket-based-poc/node-cpp-lbs-modules/dbus-proxies/PositioningProxy.cpp new file mode 100644 index 0000000..93af921 --- /dev/null +++ b/test/navigation/w3c/socket-based-poc/node-cpp-lbs-modules/dbus-proxies/PositioningProxy.cpp @@ -0,0 +1,65 @@ +/** +* @licence app begin@ +* SPDX-License-Identifier: MPL-2.0 +* +* \copyright Copyright (C) 2016, PCA Peugeot Citroen +* +* \file main.cpp +* +* \brief This file is part of the Navigation Web API proof of concept. +* +* \author Philippe Colliot +* +* \version 0.1 +* +* This Source Code Form is subject to the terms of the +* Mozilla Public License (MPL), v. 2.0. +* If a copy of the MPL was not distributed with this file, +* You can obtain one at http://mozilla.org/MPL/2.0/. +* +* For further information see http://www.genivi.org/. +* +* List of changes: +* , , +* +* @licence end@ +*/ +#include + +#include "PositioningProxy.hpp" + +using namespace v8; +using namespace std; + +static DBus::Glib::BusDispatcher *dispatcher; +static DBus::Connection *connection; + +PositioningEnhancedPositionProxy::PositioningEnhancedPositionProxy(DBus::Connection &connection) + : DBus::ObjectProxy(connection, + "/org/genivi/positioning", + "org.genivi.positioning.EnhancedPosition") +{ + +} + +void PositioningEnhancedPositionProxy::PositionUpdate(const uint64_t& changedValues) +{ + +} + +PositioningProxy::PositioningProxy() +{ + dispatcher = new DBus::Glib::BusDispatcher(); + DBus::default_dispatcher = dispatcher; + dispatcher->attach(NULL); + connection = new DBus::Connection(DBus::Connection::SessionBus()); + connection->setup(dispatcher); + mp_enhancedPositionProxy = new PositioningEnhancedPositionProxy(*connection); +} + +PositioningProxy::~PositioningProxy() +{ + delete mp_enhancedPositionProxy; + delete connection; + delete dispatcher; +} diff --git a/test/navigation/w3c/socket-based-poc/node-cpp-lbs-modules/dbus-proxies/PositioningProxy.hpp b/test/navigation/w3c/socket-based-poc/node-cpp-lbs-modules/dbus-proxies/PositioningProxy.hpp new file mode 100644 index 0000000..c745739 --- /dev/null +++ b/test/navigation/w3c/socket-based-poc/node-cpp-lbs-modules/dbus-proxies/PositioningProxy.hpp @@ -0,0 +1,65 @@ +/** +* @licence app begin@ +* SPDX-License-Identifier: MPL-2.0 +* +* \copyright Copyright (C) 2016, PCA Peugeot Citroen +* +* \file main.cpp +* +* \brief This file is part of the Navigation Web API proof of concept. +* +* \author Philippe Colliot +* +* \version 0.1 +* +* This Source Code Form is subject to the terms of the +* Mozilla Public License (MPL), v. 2.0. +* If a copy of the MPL was not distributed with this file, +* You can obtain one at http://mozilla.org/MPL/2.0/. +* +* For further information see http://www.genivi.org/. +* +* List of changes: +* , , +* +* @licence end@ +*/ +#ifndef POSITIONINGPROXY_HPP +#define POSITIONINGPROXY_HPP + +#include "genivi-dbus-model.h" + +#include +#include + +#include +#include +#include + +// Do not include this line. It's generally frowned upon to use namespaces +// in header files as it may cause issues with other code that includes your +// header file. +// using namespace v8; + +class PositioningEnhancedPositionProxy + : public org::genivi::positioning::EnhancedPosition_proxy, + public DBus::ObjectProxy +{ +public: + + PositioningEnhancedPositionProxy(DBus::Connection &connection); + void PositionUpdate(const uint64_t& changedValues); + +private: +}; + +class PositioningProxy +{ +public: + PositioningProxy(); + ~PositioningProxy(); + + PositioningEnhancedPositionProxy* mp_enhancedPositionProxy; +}; + +#endif diff --git a/test/navigation/w3c/socket-based-poc/node-cpp-lbs-modules/dbus-proxies/genivi-dbus-model.h b/test/navigation/w3c/socket-based-poc/node-cpp-lbs-modules/dbus-proxies/genivi-dbus-model.h new file mode 100644 index 0000000..6e1dd3e --- /dev/null +++ b/test/navigation/w3c/socket-based-poc/node-cpp-lbs-modules/dbus-proxies/genivi-dbus-model.h @@ -0,0 +1,1569 @@ +/** +* @licence app begin@ +* SPDX-License-Identifier: MPL-2.0 +* +* \copyright Copyright (C) 2013-2014, PCA Peugeot Citroen +* +* \file poi-common-dbus-data-model.h +* +* \brief This file is part of the poi proof of concept. +* +* \author Philippe Colliot +* +* \version 1.1 +* +* This Source Code Form is subject to the terms of the +* Mozilla Public License (MPL), v. 2.0. +* If a copy of the MPL was not distributed with this file, +* You can obtain one at http://mozilla.org/MPL/2.0/. +* +* For further information see http://www.genivi.org/. +* +* List of changes: +* 10-02-2014, Philippe Colliot, refinement and migration to the new repository +* , , +* +* @licence end@ +*/ +#ifndef __GENIVIDBUSMODEL_H__ +#define __GENIVIDBUSMODEL_H__ + +#include +#include +#include +#include +#include +#include +#include + + +#include +#include +#include "genivi-navigationcore-constants.h" +#include "genivi-navigationcore-configuration_proxy.h" +#include "genivi-poiservice-constants.h" +#include "genivi-poiservice-poisearch_proxy.h" +#include "positioning-constants.h" +#include "enhanced-position-proxy.h" + +typedef uint32_t poiId_t; +typedef uint32_t categoryId_t; +typedef uint32_t resourceId_t; +typedef uint32_t attributeId_t; +typedef uint32_t handleId_t; +typedef uint8_t camId_t; + +/* How to + The below classes are gateways between internal data and DBus data + Internal access is provided by set and get + DBus access is provided by setDBus and getDBus + Code rules: + if data name is MYNAME: +class DBus_MYNAME // DBus data type ex:(qqqs) +{ +public: + struct MYNAME_t //no class used into this public structure + { +... + }; + + typedef ... DBus_MYNAME_t; + + DBus_MYNAME(){ +... + } + + ~DBus_MYNAME(){} + + void set(MYNAME_t value){ +... + } + + MYNAME_t get(){ +... + return(m_MYNAME); + } + + void setDBus(DBus_MYNAME_t value){ +... + } + + DBus_MYNAME_t getDBus(){ + DBus_MYNAME_t return_value; +... + return(return_value); + } + +private: + MYNAME_t m_MYNAME; +}; + +*/ + +class DBus_dataFormatConverter +{ +public: + typedef ::DBus::Struct< uint8_t, ::DBus::Variant > DBusCommonAPIVariant; + + DBus_dataFormatConverter() + { + } + ~ DBus_dataFormatConverter() + { + } + DBusCommonAPIVariant createVariantString(std::string str) + { + DBusCommonAPIVariant var; + DBus::MessageIter iter = var._2.writer(); + iter.append_string(str.c_str()); + return var; + } + + DBusCommonAPIVariant createVariantUint16(uint16_t value) + { + DBusCommonAPIVariant var; + DBus::MessageIter iter = var._2.writer(); + iter.append_uint16(value); + return var; + } + + DBusCommonAPIVariant createVariantArrayUint16(std::vector< uint16_t > value) + { + DBusCommonAPIVariant var; + DBus::MessageIter iter=var._2.writer(); + iter << value; + return var; + } + + DBusCommonAPIVariant createVariantUint32(uint32_t value) + { + DBusCommonAPIVariant var; + DBus::MessageIter iter = var._2.writer(); + iter.append_uint32(value); + return var; + } + + DBusCommonAPIVariant createVariantArrayUint32(std::vector< uint32_t > value) + { + DBusCommonAPIVariant var; + DBus::MessageIter iter=var._2.writer(); + iter << value; + return var; + } + +}; + +class DBus_version : DBus_dataFormatConverter // (qqqs) +{ +public: + struct version_t + { + ushort major; + ushort minor; + ushort micro; + std::string date; + }; + + typedef ::DBus::Struct< uint16_t, uint16_t, uint16_t, std::string > DBus_version_t; + + DBus_version(){ + m_version.major = 0; + m_version.minor = 0; + m_version.micro = 0; + m_version.date = ""; + } + + ~DBus_version(){} + + void set(version_t value){ + m_version.major = value.major; + m_version.minor = value.minor; + m_version.micro = value.micro; + m_version.date = value.date; + } + + version_t get(){ + return(m_version); + } + + void setDBus(DBus_version_t value){ + m_version.major = value._1; + m_version.minor = value._2; + m_version.micro = value._3; + m_version.date = value._4; + } + + DBus_version_t getDBus(){ + DBus_version_t return_value; + return_value._1 = m_version.major; + return_value._2 = m_version.minor; + return_value._3 = m_version.micro; + return_value._4 = m_version.date; + return(return_value); + } + +private: + version_t m_version; +}; + +class DBus_categoryDetails : DBus_dataFormatConverter // (uau(yv)sbs(yv)) -->in this implementation, the two variant data are string +{ +public: + struct categoryDetails_t + { + categoryId_t id; //Category unique id + std::vector parents_id; //list of parent categories unique id + std::string icons; //visual icons set + std::string name; + bool top_level; //false if predefined, true if created by plugin + std::string description; //short category description (optional) + std::string media; //media associated (html web site, audio, video, ...) (optional) + }; + + typedef ::DBus::Struct< uint32_t, std::vector< uint32_t >, DBusCommonAPIVariant, std::string, bool, std::string, DBusCommonAPIVariant > DBus_categoryDetails_t; + + DBus_categoryDetails() + { + m_categoryDetails.id = 0; + m_categoryDetails.parents_id.clear(); + m_categoryDetails.parents_id.push_back(0); //one element by default + m_categoryDetails.icons = ""; + m_categoryDetails.name = ""; + m_categoryDetails.top_level = true; + m_categoryDetails.description = ""; + m_categoryDetails.media = ""; + } + + ~DBus_categoryDetails(){} + + void set(categoryDetails_t value) + { + size_t index; + m_categoryDetails.id = value.id; + m_categoryDetails.parents_id.clear(); + for (index=0;indexin this implementation, the variant data is a string +{ +public: + struct categoryOperator_t + { + int32_t type; //attribute operator type enum(INVALID,MORE_THAN,LESS_THAN,EQUAL, ....) + std::string name; //attribute operator name + std::string value; //attribute operator value + }; + + typedef ::DBus::Struct< int32_t, std::string, DBusCommonAPIVariant > DBus_categoryOperator_t; + + DBus_categoryOperator(){ + m_categoryOperator.type = 0; + m_categoryOperator.name = ""; + m_categoryOperator.value = ""; + } + + ~DBus_categoryOperator(){ + } + + void set(categoryOperator_t value){ + m_categoryOperator.type = value.type; + m_categoryOperator.name = value.name; + m_categoryOperator.value = value.value; + } + + categoryOperator_t get(){ + return(m_categoryOperator); + } + + void setDBus(DBus_categoryOperator_t value){ + m_categoryOperator.type = value._1; + m_categoryOperator.name = value._2; + m_categoryOperator.value = value._3._2.reader().get_string(); + } + + DBus_categoryOperator_t getDBus(){ + DBus_categoryOperator_t return_value; + return_value._1 = m_categoryOperator.type; + return_value._2 = m_categoryOperator.name; + return_value._3 = createVariantString(m_categoryOperator.value); + return(return_value); + } + +private: + categoryOperator_t m_categoryOperator; +}; + +class DBus_categoryAttribute : DBus_dataFormatConverter // (usia(is(yv))) +{ +public: + struct categoryAttribute_t + { + attributeId_t id; //attribute unique id + std::string name; //attribute unique name + int32_t type; //enum(INVALID,STRING,INTEGER,COORDINATES ...) + std::vector oper; + }; + + typedef ::DBus::Struct< uint32_t, std::string, int32_t, std::vector< ::DBus::Struct< int32_t, std::string, DBusCommonAPIVariant > > > DBus_categoryAttribute_t; + + DBus_categoryAttribute(){ + DBus_categoryOperator op; + m_categoryAttribute.id = 0; + m_categoryAttribute.name = ""; + m_categoryAttribute.type = 0; + m_categoryAttribute.oper.clear(); + m_categoryAttribute.oper.push_back(op.get()); //one element by default + } + + ~DBus_categoryAttribute(){ + } + + void set(categoryAttribute_t value){ + size_t index; + m_categoryAttribute.id = value.id; + m_categoryAttribute.name = value.name; + m_categoryAttribute.type = value.type; + m_categoryAttribute.oper.clear(); + for (index=0;index DBus_categorySortOption_t; + + DBus_categorySortOption(){ + m_categorySortOption.id = 0; + m_categorySortOption.name = ""; + } + + ~DBus_categorySortOption(){ + } + + void set(categorySortOption_t value){ + m_categorySortOption.id = value.id; + m_categorySortOption.name = value.name; + } + + categorySortOption_t get(){ + return(m_categorySortOption); + } + + void setDBus(DBus_categorySortOption_t value){ + m_categorySortOption.id = value._1; + m_categorySortOption.name = value._2; + } + + DBus_categorySortOption_t getDBus(){ + DBus_categorySortOption_t return_value; + return_value._1 = m_categorySortOption.id; + return_value._2 = m_categorySortOption.name; + return(return_value); + } + +private: + categorySortOption_t m_categorySortOption; +}; + +class DBus_category : DBus_dataFormatConverter // ( (uau(yv)sbs(yv)) a(usia(is(yv))) a(us) ) +{ +public: + struct category_t + { + DBus_categoryDetails::categoryDetails_t details; + std::vector attributes; + std::vector sortOptions; + }; + + typedef ::DBus::Struct< ::DBus::Struct< uint32_t, std::vector< uint32_t >, DBusCommonAPIVariant, std::string, bool, std::string, DBusCommonAPIVariant >, std::vector< ::DBus::Struct< uint32_t, std::string, int32_t, std::vector< ::DBus::Struct< int32_t, std::string, DBusCommonAPIVariant > > > >, std::vector< ::DBus::Struct< uint32_t, std::string > > > DBus_category_t; + + DBus_category() + { + DBus_categoryDetails details; + DBus_categoryAttribute attrib; + DBus_categorySortOption sortOption; + + m_category.details = details.get(); + m_category.attributes.clear(); + m_category.attributes.push_back(attrib.get()); //one element by default + m_category.sortOptions.clear(); + m_category.sortOptions.push_back(sortOption.get()); //one element by default + } + + ~ DBus_category(){} + + void set(category_t value) + { + size_t index; + m_category.details = value.details; + m_category.attributes.clear(); + for (index=0;index DBus_categoryIdLevel_t; + + + DBus_categoryIdLevel(){ + m_categoryIdLevel.id = 0; + m_categoryIdLevel.top_level = true; + } + + ~DBus_categoryIdLevel(){} + + void set(categoryIdLevel_t value){ + m_categoryIdLevel.id = value.id; + m_categoryIdLevel.top_level = value.top_level; + } + + categoryIdLevel_t get(){ + return(m_categoryIdLevel); + } + + void setDBus(DBus_categoryIdLevel_t value){ + m_categoryIdLevel.id = value._1; + m_categoryIdLevel.top_level = value._2; + } + + DBus_categoryIdLevel_t getDBus(){ + DBus_categoryIdLevel_t return_value; + return_value._1 = m_categoryIdLevel.id; + return_value._2 = m_categoryIdLevel.top_level; + return(return_value); + } + +private: + categoryIdLevel_t m_categoryIdLevel; +}; + +class DBus_categoryReason : DBus_dataFormatConverter // (uq) +{ +public: + struct categoryReason_t + { + categoryId_t id; + ushort reason; //enum(ADDED,REMOVED,ATTR_ADDED,ATTR_MODIFIED,ATTR_REMOVED, ... ) + }; + + typedef ::DBus::Struct< uint32_t, uint16_t > DBus_categoryReason_t; + + + DBus_categoryReason(){ + m_categoryReason.id = 0; + m_categoryReason.reason = true; + } + + ~DBus_categoryReason(){} + + void set(categoryReason_t value){ + m_categoryReason.id = value.id; + m_categoryReason.reason = value.reason; + } + + categoryReason_t get(){ + return(m_categoryReason); + } + + void setDBus(DBus_categoryReason_t value){ + m_categoryReason.id = value._1; + m_categoryReason.reason = value._2; + } + + DBus_categoryReason_t getDBus(){ + DBus_categoryReason_t return_value; + return_value._1 = m_categoryReason.id; + return_value._2 = m_categoryReason.reason; + return(return_value); + } + +private: + categoryReason_t m_categoryReason; +}; + +class DBus_categoryIdName : DBus_categoryIdLevel // (usb) +{ +public: + + struct categoryIdName_t + { + DBus_categoryIdLevel::categoryIdLevel_t id; + std::string name; + }; + + typedef ::DBus::Struct< uint32_t, std::string, bool > DBus_categoryIdName_t; + + + DBus_categoryIdName(){ + m_categoryIdName = ""; + } + + ~DBus_categoryIdName(){} + + void set(categoryIdName_t value){ + DBus_categoryIdLevel::set(value.id); + m_categoryIdName = value.name; + } + + categoryIdName_t get(){ + categoryIdName_t return_value; + return_value.id = DBus_categoryIdLevel::get(); + return_value.name = m_categoryIdName; + return(return_value); + } + + void setDBus(DBus_categoryIdName_t value){ + DBus_categoryIdLevel::DBus_categoryIdLevel_t id; + id._1 = value._1; + id._2 = value._3; + DBus_categoryIdLevel::setDBus(id); + m_categoryIdName = value._2; + } + + DBus_categoryIdName_t getDBus(){ + DBus_categoryIdName_t return_value; + DBus_categoryIdLevel::DBus_categoryIdLevel_t id; + id = DBus_categoryIdLevel::getDBus(); + return_value._1 = id._1; + return_value._2 = m_categoryIdName; + return_value._3 = id._2; + return(return_value); + } + +private: + std::string m_categoryIdName; +}; + +class DBus_categoryRadius : DBus_dataFormatConverter // (uu) +{ +public: + struct categoryRadius_t + { + categoryId_t id; + uint radius; + }; + + typedef ::DBus::Struct< uint32_t, uint32_t > DBus_categoryRadius_t; + + DBus_categoryRadius(){ + m_categoryRadius.id = 0; + m_categoryRadius.radius = 0; + } + + ~DBus_categoryRadius(){} + + void set(categoryRadius_t value){ + m_categoryRadius.id = value.id; + m_categoryRadius.radius = value.radius; + } + + categoryRadius_t get(){ + return(m_categoryRadius); + } + + void setDBus(DBus_categoryRadius_t value){ + m_categoryRadius.id = value._1; + m_categoryRadius.radius = value._2; + } + + DBus_categoryRadius_t getDBus(){ + DBus_categoryRadius_t return_value; + return_value._1 = m_categoryRadius.id; + return_value._2 = m_categoryRadius.radius; + return(return_value); + } + +private: + categoryRadius_t m_categoryRadius; +}; + +class DBus_poiAttribute : DBus_dataFormatConverter // (ui(yv)) -->in this implementation, the variant data is a string +{ +public: + struct poiAttribute_t + { + attributeId_t id; + int32_t type; + std::string value; + }; + + typedef ::DBus::Struct< uint32_t, int32_t, DBusCommonAPIVariant > DBus_poiAttribute_t; + + + DBus_poiAttribute(){ + m_attribute.id = 0; + m_attribute.type = 0; + m_attribute.value = ""; + } + + ~DBus_poiAttribute(){} + + void set(poiAttribute_t value){ + m_attribute.id = value.id; + m_attribute.type = value.type; + m_attribute.value = value.value; + } + + poiAttribute_t get(){ + return(m_attribute); + } + + void setDBus(DBus_poiAttribute_t value){ + m_attribute.id = value._1; + m_attribute.type = value._2; + m_attribute.value = value._3._2.reader().get_string(); + } + + DBus_poiAttribute_t getDBus(){ + DBus_poiAttribute_t return_value; + return_value._1 = m_attribute.id; + return_value._2 = m_attribute.type; + return_value._3 = createVariantString(m_attribute.value); + return(return_value); + } + +private: + poiAttribute_t m_attribute; +}; + +class DBus_attributeDetails : DBus_poiAttribute //(uui(yv)ib) -->in this implementation, the variant data is string +{ +public: + struct attributeDetails_t + { + DBus_poiAttribute::poiAttribute_t attribute; + categoryId_t categoryId; //Category unique id + int32_t oper; //enum(INVALID,MORE_THAN,LESS_THAN,EQUAL, ....) + bool mandatory; //true if the attribute is mandatory for the search and false for optional + }; + + typedef ::DBus::Struct< uint32_t, uint32_t, int32_t, ::DBus::Struct< uint8_t, ::DBus::Variant >, int32_t, bool > DBus_attributeDetails_t; + + + DBus_attributeDetails(){ + m_attributeDetails.categoryId = 0; + m_attributeDetails.oper = 0; + m_attributeDetails.mandatory = true; + } + + ~DBus_attributeDetails(){} + + void set(attributeDetails_t value){ + DBus_poiAttribute::set(value.attribute); + m_attributeDetails.categoryId = value.categoryId; + m_attributeDetails.oper = value.oper; + m_attributeDetails.mandatory = value.mandatory; + } + + attributeDetails_t get(){ + attributeDetails_t return_value; + return_value.attribute = DBus_poiAttribute::get(); + return_value.categoryId = m_attributeDetails.categoryId; + return_value.oper = m_attributeDetails.oper; + return_value.mandatory = m_attributeDetails.mandatory; + return(return_value); + } + + void setDBus(DBus_attributeDetails_t value){ + DBus_poiAttribute::DBus_poiAttribute_t attribute; + attribute._1 = value._1; + attribute._2 = value._3; + attribute._3 = value._4; + DBus_poiAttribute::setDBus(attribute); + m_attributeDetails.categoryId = value._2; + m_attributeDetails.oper = value._5; + m_attributeDetails.mandatory = value._6; + } + + DBus_attributeDetails_t getDBus(){ + DBus_attributeDetails_t return_value; + DBus_poiAttribute::DBus_poiAttribute_t attribute; + attribute = DBus_poiAttribute::getDBus(); + return_value._1 = attribute._1; + return_value._2 = m_attributeDetails.categoryId; + return_value._3 = attribute._2; + return_value._4 = attribute._3; + return_value._5 = m_attributeDetails.oper; + return_value._6 = m_attributeDetails.mandatory; + return(return_value); + } + +private: + attributeDetails_t m_attributeDetails; +}; + +class DBus_geoCoordinate3D : DBus_dataFormatConverter //(ddd) +{ +public: + struct geoCoordinate3D_t + { + double latitude; + double longitude; + double altitude; + }; + typedef ::DBus::Struct< double, double, double > DBus_geoCoordinate3D_t; + + DBus_geoCoordinate3D(){ + m_geoCoordinate3D.latitude = 48.85792; //by default center of Paris + m_geoCoordinate3D.longitude = 2.3383145; + m_geoCoordinate3D.altitude = 0; + } + + ~DBus_geoCoordinate3D(){} + + void set(geoCoordinate3D_t value){ + m_geoCoordinate3D.latitude = value.latitude; + m_geoCoordinate3D.longitude = value.longitude; + m_geoCoordinate3D.altitude = value.altitude; + } + + geoCoordinate3D_t get(){ + return(m_geoCoordinate3D); + } + + void setDBus(DBus_geoCoordinate3D_t value){ + m_geoCoordinate3D.latitude = value._1; + m_geoCoordinate3D.longitude = value._2; + m_geoCoordinate3D.altitude = value._3; + } + + DBus_geoCoordinate3D_t getDBus(){ + DBus_geoCoordinate3D_t return_value; + return_value._1 = m_geoCoordinate3D.latitude; + return_value._2 = m_geoCoordinate3D.longitude; + return_value._3 = m_geoCoordinate3D.altitude; + return(return_value); + } + +private: + geoCoordinate3D_t m_geoCoordinate3D; +}; + +class DBus_poiDetails : DBus_dataFormatConverter //(us(ddd)) +{ +public: + struct poiDetails_t + { + poiId_t id; + std::string name; + DBus_geoCoordinate3D::geoCoordinate3D_t location; + }; + typedef ::DBus::Struct< uint32_t, std::string, ::DBus::Struct< double, double, double > > DBus_poiDetails_t; + + DBus_poiDetails(){ + DBus_geoCoordinate3D loc; + + m_poiDetails.id = 0; + m_poiDetails.name = ""; + m_poiDetails.location = loc.get(); + } + + ~DBus_poiDetails(){} + + void set(poiDetails_t value){ + m_poiDetails.id = value.id; + m_poiDetails.name = value.name; + m_poiDetails.location = value.location; + } + + poiDetails_t get(){ + return(m_poiDetails); + } + + void setDBus(DBus_poiDetails_t value){ + DBus_geoCoordinate3D loc; + + m_poiDetails.id = value._1; + m_poiDetails.name = value._2; + loc.setDBus(value._3); + m_poiDetails.location = loc.get(); + } + + DBus_poiDetails_t getDBus(){ + DBus_geoCoordinate3D loc; + DBus_poiDetails_t return_value; + return_value._1 = m_poiDetails.id; + return_value._2 = m_poiDetails.name; + loc.set(m_poiDetails.location); + return_value._3 = loc.getDBus(); + return(return_value); + } + +private: + poiDetails_t m_poiDetails; +}; + +class DBus_searchResult : DBus_dataFormatConverter //(uuia(ui(yv))) -->in this implementation, the variant data depends on the value of 'type' +{ +public: + struct searchResult_t + { + poiId_t id; + uint distance; + int32_t route_status; + std::vector attributes; + }; + + typedef ::DBus::Struct< uint32_t, uint32_t, int32_t, std::vector< ::DBus::Struct< uint32_t, int32_t, DBusCommonAPIVariant > > > DBus_searchResult_t; + + DBus_searchResult(){ + DBus_poiAttribute attrib; + m_searchResult.id = 0; + m_searchResult.distance = 0; + m_searchResult.route_status = 0; + m_searchResult.attributes.clear(); + m_searchResult.attributes.push_back(attrib.get()); + } + + ~DBus_searchResult(){ + } + + void set(searchResult_t value){ + size_t index; + m_searchResult.id = value.id; + m_searchResult.distance = value.distance; + m_searchResult.route_status = value.route_status; + m_searchResult.attributes.clear(); + for (index=0;indexin this implementation, the variant data depends on the value of 'type' +{ +public: + struct searchResultDetails_t + { + DBus_poiDetails::poiDetails_t details; + std::vector categories; + std::vector attributes; + }; + + typedef ::DBus::Struct< ::DBus::Struct< uint32_t, std::string, ::DBus::Struct< double, double, double > >, std::vector< uint32_t >, std::vector< ::DBus::Struct< uint32_t, int32_t, DBusCommonAPIVariant > > > DBus_searchResultDetails_t; + + + DBus_searchResultDetails(){ + DBus_poiDetails details; + DBus_poiAttribute attrib; + m_searchResultDetails.details = details.get(); + m_searchResultDetails.categories.clear(); + m_searchResultDetails.categories.push_back(0); //one element by default + m_searchResultDetails.attributes.clear(); + m_searchResultDetails.attributes.push_back(attrib.get()); //one element by default + } + + ~DBus_searchResultDetails(){} + + void set(searchResultDetails_t value){ + size_t index; + m_searchResultDetails.details = value.details; + m_searchResultDetails.categories.clear(); + for (index=0;indexin this implementation, the variant data depends on the value of 'type' +{ +public: + struct poiCAMDetails_t //no class used into this public structure + { + poiId_t source_id; + std::string name; + categoryId_t category; + DBus_geoCoordinate3D::geoCoordinate3D_t location; + ushort distance; + std::vector attributes; + }; + + typedef ::DBus::Struct< uint32_t, std::string, uint32_t, ::DBus::Struct< double, double, double >, uint16_t, std::vector< ::DBus::Struct< uint32_t, int32_t, DBusCommonAPIVariant > > > DBus_poiCAMDetails_t; + + DBus_poiCAMDetails(){ + DBus_poiAttribute attrib; + DBus_geoCoordinate3D loc; + + m_poiCAMDetails.source_id = 0; + m_poiCAMDetails.name = ""; + m_poiCAMDetails.category = 0; + m_poiCAMDetails.location = loc.get(); + m_poiCAMDetails.distance = 0; + m_poiCAMDetails.attributes.clear(); + m_poiCAMDetails.attributes.push_back(attrib.get()); + } + + ~DBus_poiCAMDetails(){} + + void set(poiCAMDetails_t value){ + size_t index; + + m_poiCAMDetails.source_id = value.source_id; + m_poiCAMDetails.name = value.name; + m_poiCAMDetails.category = value.category; + m_poiCAMDetails.location = value.location; + m_poiCAMDetails.distance = value.distance; + m_poiCAMDetails.attributes.clear(); + for (index=0;indexin this implementation, the variant data is string +{ +public: + struct CAMcategoryDetails_t + { + std::vector parents_id; + std::string icons; + std::string name; + std::string short_desc; + std::string media; + }; + + typedef ::DBus::Struct< std::vector< uint32_t >, DBusCommonAPIVariant, std::string, std::string, DBusCommonAPIVariant > DBus_CAMcategoryDetails_t; + + DBus_CAMcategoryDetails(){ + m_CAMcategoryDetails.parents_id.clear(); + m_CAMcategoryDetails.parents_id.push_back(0); //one element by default + m_CAMcategoryDetails.icons = ""; + m_CAMcategoryDetails.name = ""; + m_CAMcategoryDetails.short_desc = ""; + m_CAMcategoryDetails.media = ""; + } + + ~DBus_CAMcategoryDetails(){} + + void set(CAMcategoryDetails_t value){ + size_t index; + m_CAMcategoryDetails.parents_id.clear(); + for (index=0;indexin this implementation, the variant data is string +{ +public: + struct CAMcategory_t //no class used into this public structure + { + DBus_CAMcategoryDetails::CAMcategoryDetails_t details; + std::vector attributes; + std::vector sortOptions; + }; + + typedef ::DBus::Struct< ::DBus::Struct< std::vector< uint32_t >, DBusCommonAPIVariant, std::string, std::string, DBusCommonAPIVariant >, std::vector< ::DBus::Struct< uint32_t, std::string, int32_t, std::vector< ::DBus::Struct< int32_t, std::string, DBusCommonAPIVariant > > > >, std::vector< ::DBus::Struct< uint32_t, std::string > > > DBus_CAMcategory_t; + + DBus_CAMcategory(){ + DBus_CAMcategoryDetails details; + DBus_categoryAttribute attrib; + DBus_categorySortOption sortOption; + + m_CAMcategory.details = details.get(); + m_CAMcategory.attributes.clear(); + m_CAMcategory.attributes.push_back(attrib.get()); //one element by default + m_CAMcategory.sortOptions.clear(); + m_CAMcategory.sortOptions.push_back(sortOption.get()); //one element by default + } + + ~DBus_CAMcategory(){} + + void set(CAMcategory_t value){ + size_t index; + m_CAMcategory.details = value.details; + m_CAMcategory.attributes.clear(); + for (index=0;indexin this implementation, the variant data is string +{ +public: + struct CAMcategoryUpdate_t //no class used into this public structure + { + categoryId_t unique_id; + std::vector attributes; + std::vector sortOptions; + }; + + typedef ::DBus::Struct< uint32_t, std::vector< ::DBus::Struct< uint32_t, std::string, int32_t, std::vector< ::DBus::Struct< int32_t, std::string, DBusCommonAPIVariant > > > >, std::vector< ::DBus::Struct< uint32_t, std::string > > > DBus_CAMcategoryUpdate_t; + + DBus_CAMcategoryUpdate(){ + DBus_categoryAttribute attrib; + DBus_categorySortOption sortOption; + + m_CAMcategoryUpdate.unique_id = 0; + m_CAMcategoryUpdate.attributes.clear(); + m_CAMcategoryUpdate.attributes.push_back(attrib.get()); //one element by default + m_CAMcategoryUpdate.sortOptions.clear(); + m_CAMcategoryUpdate.sortOptions.push_back(sortOption.get()); //one element by default + } + + ~DBus_CAMcategoryUpdate(){} + + void set(CAMcategoryUpdate_t value){ + size_t index; + m_CAMcategoryUpdate.unique_id = value.unique_id; + m_CAMcategoryUpdate.attributes.clear(); + for (index=0;indexin this implementation, the variant data depends on the value of 'type' +{ +public: + struct PoiAddedDetails_t + { + std::string name; + DBus_geoCoordinate3D::geoCoordinate3D_t location; + std::vector attributes; + }; + + typedef ::DBus::Struct< std::string, ::DBus::Struct< double, double, double >, std::vector< ::DBus::Struct< uint32_t, int32_t, DBusCommonAPIVariant > > > DBus_PoiAddedDetails_t; + + + DBus_PoiAddedDetails(){ + DBus_geoCoordinate3D loc; + DBus_poiAttribute attrib; + + m_PoiAddedDetails.name = ""; + m_PoiAddedDetails.location = loc.get(); + m_PoiAddedDetails.attributes.clear(); + m_PoiAddedDetails.attributes.push_back(attrib.get()); //one element by default + } + + ~DBus_PoiAddedDetails(){} + + void set(PoiAddedDetails_t value){ + size_t index; + m_PoiAddedDetails.name = value.name; + m_PoiAddedDetails.location = value.location; + + m_PoiAddedDetails.attributes.clear(); + for (index=0;index