MIRA
MetaSerializer.h
Go to the documentation of this file.
1 /*
2  * Copyright (C) 2012 by
3  * MetraLabs GmbH (MLAB), GERMANY
4  * and
5  * Neuroinformatics and Cognitive Robotics Labs (NICR) at TU Ilmenau, GERMANY
6  * All rights reserved.
7  *
8  * Contact: info@mira-project.org
9  *
10  * Commercial Usage:
11  * Licensees holding valid commercial licenses may use this file in
12  * accordance with the commercial license agreement provided with the
13  * software or, alternatively, in accordance with the terms contained in
14  * a written agreement between you and MLAB or NICR.
15  *
16  * GNU General Public License Usage:
17  * Alternatively, this file may be used under the terms of the GNU
18  * General Public License version 3.0 as published by the Free Software
19  * Foundation and appearing in the file LICENSE.GPL3 included in the
20  * packaging of this file. Please review the following information to
21  * ensure the GNU General Public License version 3.0 requirements will be
22  * met: http://www.gnu.org/copyleft/gpl.html.
23  * Alternatively you may (at your option) use any later version of the GNU
24  * General Public License if such license has been publicly approved by
25  * MLAB and NICR (or its successors, if any).
26  *
27  * IN NO EVENT SHALL "MLAB" OR "NICR" BE LIABLE TO ANY PARTY FOR DIRECT,
28  * INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES ARISING OUT OF
29  * THE USE OF THIS SOFTWARE AND ITS DOCUMENTATION, EVEN IF "MLAB" OR
30  * "NICR" HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
31  *
32  * "MLAB" AND "NICR" SPECIFICALLY DISCLAIM ANY WARRANTIES, INCLUDING,
33  * BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND
34  * FITNESS FOR A PARTICULAR PURPOSE. THE SOFTWARE PROVIDED HEREUNDER IS
35  * ON AN "AS IS" BASIS, AND "MLAB" AND "NICR" HAVE NO OBLIGATION TO
36  * PROVIDE MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS OR MODIFICATIONS.
37  */
38 
48 #ifndef _MIRA_METASERIALIZER_H_
49 #define _MIRA_METASERIALIZER_H_
50 
51 #include <iostream>
52 
53 #include <type_traits>
54 
55 #include <platform/Platform.h>
56 #include <utils/MakeString.h>
58 
61 #include <serialization/adapters/boost/optional.hpp>
62 #include <serialization/adapters/std/list>
63 #include <serialization/adapters/std/vector>
64 
65 namespace mira {
66 
68 
70 namespace serialization {
71 
73 
74 // with c++20 this will be part of the language in std
75 template <typename T>
76 struct remove_cvref
77 {
79 };
80 
82 
83 } // namespace
84 
86 
97 class MIRA_BASE_EXPORT TypeMeta : public std::vector<uint8>
98 {
99  typedef std::vector<uint8> Base;
100 public:
101 
106  enum Type {
107  TYPE_INVALID = 0,
109 
110  // class type, (typename is stored in mIdentifier)
112 
113  // user-defined atomic type (typename is stored in mIdentifier)
115 
116  // built-in atomic types (mIdentifier stays empty)
117  TYPE_UINT8 , TYPE_INT8,
118  TYPE_UINT16, TYPE_INT16,
119  TYPE_UINT32, TYPE_INT32,
120  TYPE_UINT64, TYPE_INT64,
121  TYPE_FLOAT , TYPE_DOUBLE,
126 
127  LAST_TYPE_FIELD
128  };
129 
135  NO_QUALIFIER=0,
136  // first value must be larger than last value in TypeField
137  FIRST_TYPE_QUALIFIER = 0x20,
138  TYPE_COLLECTION = FIRST_TYPE_QUALIFIER,
140  TYPE_PROPERTY
141  };
142 
143  // this version is the format version of the TypeMeta
144  // only deviate from default if you really know what you are doing!
145  TypeMeta(uint8 version = 2) : mVersion(version) {}
146 
147  template<typename Reflector>
148  void reflect(Reflector& r) {
149  MIRA_REFLECT_BASE(r,Base);
150  if(getType()==TYPE_ATOMIC || getType()==TYPE_CLASS)
151  r.member("Identifier", mIdentifier, "The identifier of the class "
152  "or 'complex' atomic type");
153  r.member("Version", mVersion, "The metatype format version", 2);
154  }
155 
156  template<typename BinaryStream>
158  MIRA_REFLECT_BASE(r,Base);
159  if(getType()==TYPE_ATOMIC || getType()==TYPE_CLASS)
160  r.member("Identifier", mPlainIdentifier, "The identifier of the class "
161  "or 'complex' atomic type", REFLECT_CTRLFLAG_TEMP_TRACKING);
162  mVersion = 0;
163  if (getType()==TYPE_CLASS)
164  mIdentifier += mPlainIdentifier + " @v0";
165  else
166  mIdentifier = mPlainIdentifier;
167  }
168 
169  // just in case someone tries to use it...
170  template<typename BinaryStream>
172  MIRA_REFLECT_BASE(r,Base);
173  if(getType()==TYPE_ATOMIC || getType()==TYPE_CLASS)
174  r.member("Identifier", mPlainIdentifier, "The identifier of the class "
175  "or 'complex' atomic type", REFLECT_CTRLFLAG_TEMP_TRACKING);
176  }
177 
182  void addQualifier(TypeQualifier qualifier) {
183  assert(Base::size()>=1);
184  push_back(qualifier);
185  }
186 
191  assert(type!=TYPE_CLASS && type!=TYPE_ATOMIC && type!=TYPE_INVALID);
192  assert(Base::size()==0);
193  push_back(type);
194  }
195 
201  void setAtomicType(const std::string& typenam);
202 
206  template <typename T>
207  void setAtomicType() { setAtomicType(typeName<T>()); }
208 
212  void setClassType(const std::string& identifier) {
213  assert(Base::size()==0);
214  push_back(TYPE_CLASS);
215  mIdentifier = identifier;
216  mPlainIdentifier = mIdentifier;
217  }
218 
223  template <typename T>
224  void setType() {
226  setAtomicType<T>();
227  else
228  setClassType(typeName<T>());
229  }
230 
234  Type getType() const {
235  if(empty() || front() >= LAST_TYPE_FIELD)
236  return TYPE_INVALID;
237  return (Type)front();
238  }
239 
243  bool hasQualifier() const {
244  return Base::size()>1;
245  }
246 
250  int qualifierCount() const {
251  return std::max(size()-1,0);
252  }
253 
258  TypeQualifier getQualifier(int i=0) const {
259  assert(i>=0);
260  if(i>=qualifierCount())
261  return NO_QUALIFIER;
262  return (TypeQualifier)Base::at(size()-i-1);
263  }
264 
269  void removeQualifiers(int n)
270  {
271  assert(n>=0);
272  if(n>qualifierCount())
273  n=qualifierCount();
274  return Base::resize(size()-n);
275  }
276 
281  const std::string& getIdentifier() const {
282  return mIdentifier;
283  }
284 
289  std::string getTypename() const;
290 
295  std::string toString() const;
296 
298  int size() const { return (int)Base::size(); }
299 
301  uint8 version() const { return mVersion; }
302 
303 private:
304  std::string mIdentifier;
305  std::string mPlainIdentifier;
306  uint8 mVersion;
307 };
308 
309 typedef boost::shared_ptr<TypeMeta> TypeMetaPtr;
310 
312 
317 {
318  struct Parameter
319  {
322  type(iType) {}
324  const std::string& iName,
325  const std::string& iDescription) :
326  type(iType),
327  name(iName),
328  description(iDescription) {}
329 
330  template<typename Reflector>
331  void reflect(Reflector& r)
332  {
333  r.member("Type",type,"The meta type info of the parameter");
334  r.member("Name",name,"The name of the parameter");
335  r.member("Description",description,"The description for the parameter");
336  }
337 
341  std::string name;
343  std::string description;
344  };
345 
347  MethodMeta(const std::string& iName,
348  const std::string& iComment) :
349  name(iName),
350  comment(iComment) {}
351 
352  template<typename Reflector>
353  void reflect(Reflector& r)
354  {
355  r.member("Name",name,"The name of the method");
356  r.member("Comment",comment,"The user defined comment");
357  r.member("ReturnType",returnType,"The meta type info of the return type");
358  r.member("Parameters",parameters,"A list with type infos for each parameter");
359  }
360 
362  std::string name;
364  std::string comment;
368  std::list<Parameter> parameters;
369 };
370 
371 typedef boost::shared_ptr<MethodMeta> MethodMetaPtr;
372 
374 
380 {
381 public:
383  struct Member
384  {
385  Member() {}
386  Member(TypeMetaPtr iType, const std::string& iName, const std::string& iComment) :
387  type(iType), name(iName), comment(iComment) {}
388 
389  template<typename Reflector>
390  void reflect(Reflector& r)
391  {
392  r.member("Type", type, "The type of the member");
393  r.member("Name", name, "The name of the member");
394  r.member("Comment", comment, "The user defined comment");
395  }
396 
400  std::string name;
402  std::string comment;
403  };
404 
406 
407  template<typename Reflector>
408  void reflect(Reflector& r)
409  {
410  VersionType v = r.requireVersion(2, 1, this);
411 
412  if (v < 2) {
413  boost::optional<int> optVersion; // version was int32 back then
414  r.member("Version",optVersion,"The version of the serialization format");
415 
416  if (optVersion)
417  version[""] = *optVersion;
418  } else
419  r.member("Version",version,"The version of the serialization format");
420 
421  r.member("Members",members,"The members of the compound");
422  r.member("Interfaces",interfaces,"The supported interfaces");
423  r.member("Methods",methods,"The reflected methods");
424  }
425 
426  template<typename BinaryStream>
428  r.version(1, this); // version 2 of CompoundMeta was unknown back then
429 
430  boost::optional<int> optVersion; // serialization version type was int32 back then
431  if (!version.empty())
432  optVersion = version.cbegin()->second; // we assume the version of the serialized class did not change
433  // from v0, otherwise it will be unreadable for the recipient anyway
434  // --> it can have only one or no version at all now
435  r.member("Version",optVersion,"The version of the serialization format");
436 
437  r.member("Members",members,"The members of the compound");
438  r.member("Interfaces",interfaces,"The supported interfaces");
439  r.member("Methods",methods,"The reflected methods");
440  }
441 
442  void addMember(const ReflectMemberMeta& memberMeta, TypeMetaPtr type)
443  {
444  addMember(memberMeta.id, memberMeta.comment, type);
445  }
446 
447  void addMember(const std::string& name, TypeMetaPtr type)
448  {
449  addMember(name, "", type);
450  }
451 
452  void addMember(const std::string& name, const std::string& comment, TypeMetaPtr type)
453  {
454  members.push_back(Member(type, name, comment));
455  }
456 
457  void insertMember(const std::string& name, TypeMetaPtr type, int index)
458  {
459  std::list<Member>::iterator pos = members.begin();
460  while ((pos != members.end()) && (index-- > 0))
461  ++pos;
462  members.insert(pos, Member(type, name, ""));
463  }
464 
465  void insertMember(const std::string& name, TypeMetaPtr type, const std::string& before)
466  {
467  std::list<Member>::iterator pos = members.begin();
468  while ((pos != members.end()) && (pos->name != before))
469  ++pos;
470  members.insert(pos, Member(type, name, ""));
471  }
472 
473  void addInterface(const std::string& iface)
474  {
475  interfaces.push_back(iface);
476  }
477 
478  void addMethod(const MethodMetaPtr& method)
479  {
480  methods.push_back(method);
481  }
482 
483  void setVersion(VersionType version) {
484  this->version[""] = version;
485  }
486 
487  void setVersion(const std::string& type, VersionType version) {
488  this->version[type] = version;
489  }
490 
491  std::string toString() const;
492 
494  std::map<std::string, VersionType> version;
496  std::list<Member> members;
498  std::list<std::string> interfaces;
500  std::list<MethodMetaPtr> methods;
501 };
502 
503 typedef boost::shared_ptr<CompoundMeta> CompoundMetaPtr;
504 
509 class MIRA_BASE_EXPORT MetaTypeDatabase : public std::map<std::string, CompoundMetaPtr>
510 {
511  typedef std::map<std::string, CompoundMetaPtr> Base;
512 public:
513 
516  Base(other) {}
518  {
519  Base::operator=(other);
520  return *this;
521  }
522 
523  template<typename Reflector>
524  void reflect(Reflector& r)
525  {
526  MIRA_REFLECT_BASE(r,Base);
527  }
528 
529  template<typename BinaryStream>
531  {
532  MIRA_REFLECT_BASE(r,Base);
533 
534  // mark all loaded type keys as '@v0' (TypeMetas in entries are also marked by TypeMeta::reflect())
535  MetaTypeDatabase db;
536  foreach (auto p, *this)
537  db[p.first+" @v0"] = p.second;
538 
539  swap(db);
540  }
541 
542  // just in case...
543  template<typename BinaryStream>
545  {
546  MetaTypeDatabase db;
547  foreach (auto p, *this) {
548  // if tagged ' @v0', remove tag, else ignore
549  size_t s = p.first.size();
550  if (p.first.substr(s-4, std::string::npos) == " @v0")
551  db[p.first.substr(0, s-4)] = p.second;
552  }
553 
554  r.template reflectBase<Base>(db);
555  }
556 
560  void merge(const MetaTypeDatabase& other)
561  {
562  this->insert(other.begin(), other.end());
563  }
564 
570  {
571  MetaTypeDatabase db;
572  generateDependentTypesDB(type, db);
573  return db;
574  }
575 
576 private:
577 
578  void generateDependentTypesDB(TypeMetaPtr type, MetaTypeDatabase& db);
579 };
580 
581 template <>
582 class IsCollection<MetaTypeDatabase> : public std::true_type {};
583 
585 
586 class MIRA_BASE_EXPORT MetaSerializer : public BinarySerializer<MetaSerializer>
587 {
589 
590 public:
591  typedef boost::mpl::bool_<false> isObjectTrackingSupported;
592 
593  typedef boost::mpl::bool_<true> requireReflectBarriers;
595 
596 public:
597 
602  mMetaDatabase(database) {}
603 
604  template<typename T>
606  {
607 #ifdef CHECK_FORCE_SERIALIZE_BINARY_VERSION
609  if ((vf >= 0) && (vf < BinaryBufferSerializer::getSerializerFormatVersion()))
610  return TypeMetaPtr(); //disable meta serialization if an older binary format is forced
611 #endif
612  try
613  {
614  mCurrentMeta.reset();
615  mParentMeta.reset();
616  serialize(MIRA_REFLECTOR_TOPLEVEL_NAME, v);
617  return mCurrentMeta;
618  }
619  catch(XNotImplemented&)
620  {
621  return TypeMetaPtr(); //return a null ptr as we are not able to extract meta information
622  }
623  }
624 
626 
627 private:
628 
629  void setVersion(VersionType version, const std::string& type,
630  const std::string& versionString) {
631  if(mParentMeta)
632  mParentMeta->setVersion(type, version);
633 
634  mCurrentVersion->name = versionString;
635  mCurrentVersion->comment = "";
636  }
637 
638 protected:
639 
640  // required for subclasses that can only tell the type by name (e.g. Python toolbox)
641  VersionType version(VersionType version, const std::string& type,
642  bool acceptDesiredVersion = false) {
643  version = this->queryDesiredClassVersion(version, type, acceptDesiredVersion);
644  setVersion(version, type, "@version[" + type + "]");
645  return version;
646  }
647 
648 public:
649 
650  template <typename T>
651  VersionType version(VersionType version, const T* caller = NULL) {
652  return this->version(version, typeName<T>(), false);
653  }
654 
655  MIRA_DEPRECATED("Please call as version<MyType>(v) or version(v, this)",
656  VersionType version(VersionType version)) {
657  if(mParentMeta)
658  mParentMeta->setVersion(version);
659 
660  mCurrentVersion->name = std::string("@version");
661 
662  return version;
663  }
664 
665  template <typename T>
666  VersionType version(VersionType version, AcceptDesiredVersion, const T* caller = NULL) {
667  return this->version(version, typeName<T>(), true);
668  }
669 
670 public:
671 
672  ReflectState preReflect(const char* context = "")
673  {
674  ReflectState state = mCurrentVersion;
675 
676  mCurrentMeta.reset(new TypeMeta);
677  mCurrentMeta->setBaseAtomicType(TypeMeta::TYPE_VERSION);
678  if(mParentMeta) {
679  mParentMeta->addMember("@version_default", std::string("implicit: ") + context, mCurrentMeta);
680  mCurrentVersion = &(mParentMeta->members.back());
681  }
682 
683  return state;
684  }
685 
686  void postReflect(const ReflectState& prev)
687  {
688  mCurrentVersion = prev;
689  }
690 
691  template <typename T>
692  void write(const T* data, std::size_t count) {
693 
694  }
695 
701  template <typename T>
702  bool hasCodec() const {
703  return false;
704  }
705 
713  template <typename T>
714  bool codec(const T& obj)
715  {
716  return false;
717  }
718 
719  void interface(const char* name)
720  {
721  assert(name != NULL); // check if user has specified NULL as interface name
722  if(mParentMeta)
723  mParentMeta->addInterface(name);
724  }
725 
727  {
728  assert(method);
729  if (mParentMeta)
730  mParentMeta->addMethod(method);
731  }
732 
733  /*
734  The following code uses boost preprocessor for generating the method(name, P1 ... Pn)
735  methods. Read documentation of boost preprocessor or use Eclipse to expand
736  the BOOST_PP_REPEAT macro below in order to see the code that is generated.
737  */
738 
739  // method(name, function<...>, comment)
740  #define META_GEN_METHODS(z,n,_) \
741  template<typename R BOOST_PP_ENUM_TRAILING_PARAMS_Z(z,n,typename P)> \
742  void method(const char* name, R (*fn)(BOOST_PP_ENUM_PARAMS_Z(z,n,P)), const char* comment) \
743  { \
744  createMethodMeta<R BOOST_PP_ENUM_TRAILING_PARAMS_Z(z,n,P)>(name, comment); \
745  } \
746  \
747  template<typename R, typename Class BOOST_PP_ENUM_TRAILING_PARAMS_Z(z,n,typename P)> \
748  void method(const char* name, R (Class::*fn)(BOOST_PP_ENUM_PARAMS_Z(z,n,P)), Class* This, const char* comment)\
749  { \
750  createMethodMeta<R BOOST_PP_ENUM_TRAILING_PARAMS_Z(z,n,P)>(name, comment); \
751  } \
752  \
753  template<typename R, typename Class BOOST_PP_ENUM_TRAILING_PARAMS_Z(z,n,typename P)> \
754  void method(const char* name, R (Class::*fn)(BOOST_PP_ENUM_PARAMS_Z(z,n,P)) const, Class* This, const char* comment) \
755  { \
756  createMethodMeta<R BOOST_PP_ENUM_TRAILING_PARAMS_Z(z,n,P)>(name, comment); \
757  } \
758  \
759  template<typename R BOOST_PP_ENUM_TRAILING_PARAMS_Z(z,n,typename P)> \
760  void method(const char* name, boost::function<R (BOOST_PP_ENUM_PARAMS_Z(z,n,P))> fn, const char* comment) \
761  { \
762  createMethodMeta<R BOOST_PP_ENUM_TRAILING_PARAMS_Z(z,n,P)>(name, comment); \
763  }
764 
765  BOOST_PP_REPEAT(BOOST_PP_INC(RPC_METHODS_MAX_PARAMS),META_GEN_METHODS,nil)
766  #undef META_GEN_METHODS
767 
768  #define META_GEN_METHODS_NAME_DESC(z,n,_) name##n, description##n
769 
770  // method(name, function<...>, comment, paramname, paramdescription, ... )
771  #define META_GEN_METHODS_PARAMDESC(z,n,_) \
772  template<typename R BOOST_PP_ENUM_TRAILING_PARAMS_Z(z,n,typename P)> \
773  void method(const char* name, R (*fn)(BOOST_PP_ENUM_PARAMS_Z(z,n,P)), \
774  const char* comment, BOOST_PP_ENUM(n,RPCGEN_CALL_NAME_DESC_DECL,nil)) \
775  { \
776  createMethodMeta<R BOOST_PP_ENUM_TRAILING_PARAMS_Z(z,n,P)>(name, comment, \
777  BOOST_PP_ENUM(n,META_GEN_METHODS_NAME_DESC,nil)); \
778  } \
779  \
780  template<typename R, typename Class BOOST_PP_ENUM_TRAILING_PARAMS_Z(z,n,typename P)> \
781  void method(const char* name, R (Class::*fn)(BOOST_PP_ENUM_PARAMS_Z(z,n,P)), Class* This, \
782  const char* comment, BOOST_PP_ENUM(n,RPCGEN_CALL_NAME_DESC_DECL,nil)) \
783  { \
784  createMethodMeta<R BOOST_PP_ENUM_TRAILING_PARAMS_Z(z,n,P)>(name, comment, \
785  BOOST_PP_ENUM(n,META_GEN_METHODS_NAME_DESC,nil)); \
786  } \
787  \
788  template<typename R, typename Class BOOST_PP_ENUM_TRAILING_PARAMS_Z(z,n,typename P)> \
789  void method(const char* name, R (Class::*fn)(BOOST_PP_ENUM_PARAMS_Z(z,n,P)) const, Class* This, \
790  const char* comment, BOOST_PP_ENUM(n,RPCGEN_CALL_NAME_DESC_DECL,nil)) \
791  { \
792  createMethodMeta<R BOOST_PP_ENUM_TRAILING_PARAMS_Z(z,n,P)>(name, comment, \
793  BOOST_PP_ENUM(n,META_GEN_METHODS_NAME_DESC,nil)); \
794  } \
795  \
796  template<typename R BOOST_PP_ENUM_TRAILING_PARAMS_Z(z,n,typename P)> \
797  void method(const char* name, boost::function<R (BOOST_PP_ENUM_PARAMS_Z(z,n,P))> fn, \
798  const char* comment, BOOST_PP_ENUM(n,RPCGEN_CALL_NAME_DESC_DECL,nil)) \
799  { \
800  createMethodMeta<R BOOST_PP_ENUM_TRAILING_PARAMS_Z(z,n,P)>(name, comment, \
801  BOOST_PP_ENUM(n,META_GEN_METHODS_NAME_DESC,nil)); \
802  }
803 
804  BOOST_PP_REPEAT_FROM_TO(1,BOOST_PP_INC(RPC_METHODS_MAX_PARAMS),META_GEN_METHODS_PARAMDESC,nil)
805  #undef META_GEN_METHODS_PARAMDESC
806 
807  // method(name, function<...>, comment, paramname, paramdescription, paramsamplevalue, ... )
808  // MetaSerializer ignores the sample params
809  #define META_GEN_METHODS_PARAMDESCSAMPLE(z,n,_) \
810  template<typename R, BOOST_PP_ENUM(n,RPCGEN_CALL_TYPENAME_PARAM_DECL,nil)> \
811  void method(const char* name, R (*fn)(BOOST_PP_ENUM_PARAMS_Z(z,n,P)), \
812  const char* comment, BOOST_PP_ENUM(n,RPCGEN_CALL_NAME_DESC_SAMPLE_DECL,nil)) \
813  { \
814  method(name, fn, comment, BOOST_PP_ENUM(n,META_GEN_METHODS_NAME_DESC,nil)); \
815  } \
816  \
817  template<typename R, typename Class, BOOST_PP_ENUM(n,RPCGEN_CALL_TYPENAME_PARAM_DECL,nil)> \
818  void method(const char* name, R (Class::*fn)(BOOST_PP_ENUM_PARAMS_Z(z,n,P)), Class* This, \
819  const char* comment, BOOST_PP_ENUM(n,RPCGEN_CALL_NAME_DESC_SAMPLE_DECL,nil)) \
820  { \
821  method(name, fn, This, comment, BOOST_PP_ENUM(n,META_GEN_METHODS_NAME_DESC,nil)); \
822  } \
823  \
824  template<typename R, typename Class, BOOST_PP_ENUM(n,RPCGEN_CALL_TYPENAME_PARAM_DECL,nil)> \
825  void method(const char* name, R (Class::*fn)(BOOST_PP_ENUM_PARAMS_Z(z,n,P)) const, Class* This, \
826  const char* comment, BOOST_PP_ENUM(n,RPCGEN_CALL_NAME_DESC_SAMPLE_DECL,nil)) \
827  { \
828  method(name, fn, This, comment, BOOST_PP_ENUM(n,META_GEN_METHODS_NAME_DESC,nil)); \
829  } \
830  \
831  template<typename R, BOOST_PP_ENUM(n,RPCGEN_CALL_TYPENAME_PARAM_DECL,nil)> \
832  void method(const char* name, boost::function<R (BOOST_PP_ENUM_PARAMS_Z(z,n,P))> fn, \
833  const char* comment, BOOST_PP_ENUM(n,RPCGEN_CALL_NAME_DESC_SAMPLE_DECL,nil)) \
834  { \
835  method(name, fn, comment, BOOST_PP_ENUM(n,META_GEN_METHODS_NAME_DESC,nil)); \
836  }
837 
838  BOOST_PP_REPEAT_FROM_TO(1,BOOST_PP_INC(RPC_METHODS_MAX_PARAMS),META_GEN_METHODS_PARAMDESCSAMPLE,nil)
839  #undef META_GEN_METHODS_PARAMDESCSAMPLE
840  #undef META_GEN_METHODS_NAME_DESC
841 
842  // method(name, function<...>, comment, ... )
843  // (these should match anything that does not match the more specific definitions above (i.e. it is invalid),
844  // will provide a much more informational error message than just failing to find a matching template instantiation)
845  #define META_GEN_METHODS_WRONG_ARGUMENT_NUMBER(z,n,_) \
846  template<typename R BOOST_PP_ENUM_TRAILING_PARAMS_Z(z,n,typename P), typename... Args> \
847  void method(const char* name, R (*fn)(BOOST_PP_ENUM_PARAMS_Z(z,n,P)), \
848  const char* comment, Args...) \
849  { \
850  invalid_method<R BOOST_PP_ENUM_TRAILING_PARAMS_Z(z,n,P)>(); \
851  } \
852  template<typename R, typename Class BOOST_PP_ENUM_TRAILING_PARAMS_Z(z,n,typename P), typename... Args> \
853  void method(const char* name, R (Class::*fn)(BOOST_PP_ENUM_PARAMS_Z(z,n,P)), Class* This, \
854  const char* comment, Args...) \
855  { \
856  invalid_method<R BOOST_PP_ENUM_TRAILING_PARAMS_Z(z,n,P)>(); \
857  } \
858  template<typename R, typename Class BOOST_PP_ENUM_TRAILING_PARAMS_Z(z,n,typename P), typename... Args> \
859  void method(const char* name, R (Class::*fn)(BOOST_PP_ENUM_PARAMS_Z(z,n,P)) const, Class* This, \
860  const char* comment, Args...) \
861  { \
862  invalid_method<R BOOST_PP_ENUM_TRAILING_PARAMS_Z(z,n,P)>(); \
863  } \
864  template<typename R BOOST_PP_ENUM_TRAILING_PARAMS_Z(z,n,typename P), typename... Args> \
865  void method(const char* name, boost::function<R (BOOST_PP_ENUM_PARAMS_Z(z,n,P))> fn, \
866  const char* comment, Args...) \
867  { \
868  invalid_method<R BOOST_PP_ENUM_TRAILING_PARAMS_Z(z,n,P)>(); \
869  }
870 
871  BOOST_PP_REPEAT(BOOST_PP_INC(RPC_METHODS_MAX_PARAMS),META_GEN_METHODS_WRONG_ARGUMENT_NUMBER,nil)
872  #undef META_GEN_METHODS_WRONG_ARGUMENT_NUMBER
873 
874  template<typename T>
875  void atomic(T& )
876  {
878  MIRA_THROW(XNotImplemented, "Type " << typeName<T>() << " is not meta-serializable");
879 
880  mCurrentMeta.reset(new TypeMeta);
881  mCurrentMeta->setAtomicType<T>();
882  addCurrentAsMemberToParent();
883  }
884 
885  template<typename T>
886  void enumeration(T& )
887  {
889  MIRA_THROW(XNotImplemented, "Type " << typeName<T>() << " is not meta-serializable");
890 
891  mCurrentMeta.reset(new TypeMeta);
892  mCurrentMeta->setBaseAtomicType(TypeMeta::TYPE_ENUMERATION);
893  addCurrentAsMemberToParent();
894  }
895 
896  template<typename T>
897  void pointer(T* &pointer)
898  {
900  MIRA_THROW(XNotImplemented, "Type " << typeName<T>() << " is not meta-serializable");
901 
902  if(pointer!=NULL)
903  Base::pointer(pointer);
904  else
906 
907  assert(mCurrentMeta);
908  mCurrentMeta->addQualifier(TypeMeta::TYPE_POINTER);
909  }
910 
911  template<typename T>
912  void object(T& member)
913  {
915  MIRA_THROW(XNotImplemented, "Type " << typeName<T>() << " is not meta-serializable");
916 
917  mCurrentMeta.reset(new TypeMeta);
918  mCurrentMeta->setClassType(typeName<T>());
919  addCurrentAsMemberToParent();
920 
921  // add us to the global type map
922  CompoundMetaPtr compound = createMapEntry(mCurrentMeta);
923  if(compound)
924  {
925  // push on "stack" and create new meta object for first member
926  TypeMetaPtr prevCurrentMeta = mCurrentMeta;
927  CompoundMetaPtr prevParentMeta = mParentMeta;
928  mParentMeta = compound;
929 
930  Base::object(member);
931 
932  // go "stack" back upwards
933  mCurrentMeta = prevCurrentMeta;
934  mParentMeta = prevParentMeta;
935  }
936  // else we were already reflected, so skip this object
937  }
938 
939  template<typename T>
940  void invokeOverwrite(T& object)
941  {
942 
943  static const std::string context = "invokeOverwrite " + typeName<T>();
944  ReflectState state = preReflect(context.c_str());
945 
946  Base::invokeOverwrite(object);
947 
948  postReflect(state);
949  }
950 
954  template<typename T>
955  void invokeOverwrite(serialization::PlainArray<T>& array)
956  {
957  static const std::string context = "invokeOverwrite PlainArray<" + typeName<T>() +">";
958  ReflectState prevState = preReflect(context.c_str());
959 
960  if(this->template isTrackingEnabled<T>() || !IsBitwiseSerializable<T>::value) {
961  Base::invokeOverwrite(array);
962  } else {
963  collectionItems<T>("@itemcount", true);
964  }
965 
966  postReflect(prevState);
967  }
968 
969 
970 protected:
971 
973  {
974  assert(type->getType() == TypeMeta::TYPE_CLASS);
975  const std::string& n = type->getIdentifier();
976 
977  if(mMetaDatabase.count(n)>0)
978  return CompoundMetaPtr();
979 
980  CompoundMetaPtr compound(new CompoundMeta);
981  mMetaDatabase[n] = compound;
982  return compound;
983  }
984 
986  {
987  if(mParentMeta)
988  mParentMeta->addMember(getCurrentMemberMeta(), mCurrentMeta);
989  }
990 
991  template <typename T, bool> friend struct TypeWithoutObjectHelper;
992  template<typename T, bool>
994  static void invoke(MetaSerializer* metaserializer) {
995  metaserializer->mCurrentMeta.reset(new TypeMeta);
996  metaserializer->mCurrentMeta->setType<T>();
997  metaserializer->addCurrentAsMemberToParent();
998  }
999  };
1000 
1001  template<typename T>
1002  struct TypeWithoutObjectHelper<T,true> {
1003  static void invoke(MetaSerializer* metaserializer) {
1004  T element;
1005  metaserializer->delegate(element);
1006  }
1007  };
1008 
1009  template<typename T>
1010  struct TypeWithoutObjectHelper<T*,true> {
1011  static void invoke(MetaSerializer* metaserializer) {
1012  T* element = NULL;
1013  metaserializer->delegate(element);
1014  }
1015  };
1016 
1017  template <typename T, bool> friend struct TypeWithoutObjectAbstractHelper;
1018  template<typename T, bool>
1020  static void invoke(MetaSerializer* metaserializer) {
1022  }
1023  };
1024 
1025  template<typename T>
1027  static void invoke(MetaSerializer* metaserializer) {
1028  metaserializer->mCurrentMeta.reset(new TypeMeta);
1029  metaserializer->mCurrentMeta->setType<T>();
1030  metaserializer->addCurrentAsMemberToParent();
1031  }
1032  };
1033 
1034  template<typename T>
1036  static void invoke(MetaSerializer* metaserializer) {
1037  metaserializer->mCurrentMeta.reset(new TypeMeta);
1038  metaserializer->mCurrentMeta->setType<T>();
1039  metaserializer->addCurrentAsMemberToParent();
1040  }
1041  };
1042 
1043  template <typename T>
1045  {
1046  // push on "stack" and create new meta object for first member
1047  TypeMetaPtr prevCurrentMeta = mCurrentMeta;
1048  CompoundMetaPtr prevParentMeta = mParentMeta;
1049  mParentMeta.reset();
1051  {
1052  T* dummy = NULL;
1053  delegate(*dummy); // is safe, even if element==NULL since atomic never accesses it here
1054  }
1055  else
1057 
1058  TypeMetaPtr meta = mCurrentMeta;
1059  // go "stack" back upwards
1060  mCurrentMeta = prevCurrentMeta;
1061  mParentMeta = prevParentMeta;
1062  return meta;
1063  }
1064 
1065  // call this when T could be void, will call the respective overload
1066  template<typename T>
1068  {
1069  typedef typename serialization::remove_cvref<T>::type Type;
1070  Type* dummy; // just to select the required createMetaHelper() overload
1071  return createMetaHelper(dummy);
1072  }
1073 
1074  // can directly call this when not necessary to check for void
1075  template<typename T>
1077  {
1078  typedef typename serialization::remove_cvref<T>::type Type;
1079  return createMeta<Type>();
1080  }
1081 
1082  // different overloads for void/non-void type (can't use void as type here -> use T*/void*)
1083 
1084  template<typename T>
1086  {
1087  return createMeta<T>();
1088  }
1089 
1091  {
1092  TypeMetaPtr meta(new TypeMeta);
1093  meta->setBaseAtomicType(TypeMeta::TYPE_VOID);
1094  return meta;
1095  }
1096 
1097  #define META_MAKE_METHODMETA_PUSH_PARAMETER(z, n, _) \
1098  m->parameters.push_back(MethodMeta::Parameter(createMetaHelper<P##n>()));
1099 
1100  #define META_MAKE_METHODMETA(z,n,_) \
1101  template <typename R BOOST_PP_ENUM_TRAILING_PARAMS_Z(z,n,typename P)> \
1102  void createMethodMeta(const std::string& name, const std::string& comment) { \
1103  MethodMetaPtr m(new MethodMeta(name, comment)); \
1104  m->returnType = createMetaOrVoidHelper<R>(); \
1105  BOOST_PP_REPEAT_ ## z(n, META_MAKE_METHODMETA_PUSH_PARAMETER, nil) \
1106  addMethod(m); \
1107  }
1108 
1109  BOOST_PP_REPEAT(RPC_METHODS_MAX_PARAMS,META_MAKE_METHODMETA,nil)
1110  #undef META_MAKE_METHODMETA_PUSH_PARAMETER
1111  #undef META_MAKE_METHODMETA
1112 
1113  #define META_MAKE_METHODMETA_PUSH_PARAMETERDESC(z, n, _) \
1114  m->parameters.push_back( \
1115  MethodMeta::Parameter(createMetaHelper<P##n>(), \
1116  name##n, description##n));
1117 
1118  #define META_MAKE_METHODMETA_CONSTSTRINGREF_NAME_DESC(z,n,_) \
1119  const std::string& name##n, const std::string& description##n
1120 
1121  #define META_MAKE_METHODMETA_PARAMETERDESC(z,n,_) \
1122  template <typename R BOOST_PP_ENUM_TRAILING_PARAMS_Z(z,n,typename P)> \
1123  void createMethodMeta(const std::string& name, const std::string& comment, \
1124  BOOST_PP_ENUM(n,META_MAKE_METHODMETA_CONSTSTRINGREF_NAME_DESC,nil)) { \
1125  MethodMetaPtr m(new MethodMeta(name, comment)); \
1126  m->returnType = createMetaOrVoidHelper<R>(); \
1127  BOOST_PP_REPEAT_ ## z(n, META_MAKE_METHODMETA_PUSH_PARAMETERDESC, nil) \
1128  addMethod(m); \
1129  }
1130 
1131  BOOST_PP_REPEAT_FROM_TO(1,BOOST_PP_INC(RPC_METHODS_MAX_PARAMS),META_MAKE_METHODMETA_PARAMETERDESC,nil)
1132  #undef META_MAKE_METHODMETA_PARAMETERDESC
1133  #undef META_MAKE_METHODMETA_CONSTSTRINGREF_NAME_DESC
1134  #undef META_MAKE_METHODMETA_PUSH_PARAMETERDESC
1135 
1136 public:
1137 
1138  // TODO: add the property qualifier just once at the end
1139 
1140  template<typename T>
1141  void property(const char* name, T& member, const char* comment,
1142  PropertyHint&& hint = PropertyHint(),
1144  Base::property(name,member,comment,std::move(hint), flags);
1145  //mCurrentMeta->addQualifier(TypeMeta::TYPE_PROPERTY);
1146  }
1147 
1148  template<typename T>
1149  void property(const char* name, const std::string& id, T& member,
1150  const char* comment, PropertyHint&& hint = PropertyHint(),
1152  Base::property(name,id,member,comment,std::move(hint), flags);
1153  //mCurrentMeta->addQualifier(TypeMeta::TYPE_PROPERTY);
1154  }
1155 
1156  template<typename T>
1157  void property(const char* name, const T& member, Setter<T> setter,
1158  const char* comment, PropertyHint&& hint = PropertyHint(),
1160  Base::property<T>(name,member,setter,comment,std::move(hint), flags);
1161  //mCurrentMeta->addQualifier(TypeMeta::TYPE_PROPERTY);
1162  }
1163 
1164  template<typename T>
1165  void property(const char* name, Getter<T> getter, Setter<T> setter,
1166  const char* comment, PropertyHint&& hint = PropertyHint(),
1168  Base::property(name,getter,setter,comment,std::move(hint), flags);
1169  //mCurrentMeta->addQualifier(TypeMeta::TYPE_PROPERTY);
1170  }
1171 
1172  template<typename T, typename U>
1173  void property(const char* name, T& member, const char* comment,
1174  const U& defaultValue, PropertyHint&& hint = PropertyHint(),
1176  Base::property(name,member,comment,defaultValue,std::move(hint), flags);
1177  //mCurrentMeta->addQualifier(TypeMeta::TYPE_PROPERTY);
1178  }
1179 
1180  template<typename T, typename U>
1181  void property(const char* name, const T& member, Setter<T> setter,
1182  const char* comment, const U& defaultValue,
1183  PropertyHint&& hint = PropertyHint(),
1185  Base::property(name,member,setter,comment,defaultValue, std::move(hint), flags);
1186  //mCurrentMeta->addQualifier(TypeMeta::TYPE_PROPERTY);
1187  }
1188 
1189  template<typename T, typename U>
1190  void property(const char* name, Getter<T> getter, Setter<T> setter,
1191  const char* comment, const U& defaultValue,
1192  PropertyHint&& hint = PropertyHint(),
1194  Base::property(name,getter,setter,comment,defaultValue,std::move(hint), flags);
1195  //mCurrentMeta->addQualifier(TypeMeta::TYPE_PROPERTY);
1196  }
1197 
1198  template<typename T>
1200  if (flags & REFLECT_CTRLFLAG_TEMP_TRACKING) {
1201  this->This()->pushObjectTrackingStore();
1202  this->invokeMember(member, ReflectMemberMeta("@transparent", "@transparent", "delegated") );
1203  this->This()->popObjectTrackingStore();
1204  } else
1205  this->invokeMember(member, ReflectMemberMeta("@transparent", "@transparent", "delegated") );
1206  }
1207 
1208  template<typename T>
1209  void delegate(const T& member, Setter<T> setter,
1211  auto a = makeAccessor(member, setter);
1212  this->This()->pushObjectTrackingStore();
1213  this->invokeMember(a, ReflectMemberMeta("@transparent", "@transparent", "delegated") );
1214  this->This()->popObjectTrackingStore();
1215  }
1216 
1217  template<typename T>
1220  auto a = makeAccessor(getter, setter);
1221  this->This()->pushObjectTrackingStore();
1222  this->invokeMember(a, ReflectMemberMeta("@transparent", "@transparent", "delegated") );
1223  this->This()->popObjectTrackingStore();
1224  }
1225 
1226  template<typename T>
1227  void collectionItems(const std::string& countName, bool blockdump = false)
1228  {
1230 
1231  assert(mCurrentMeta);
1232  mCurrentMeta->addQualifier(TypeMeta::TYPE_COLLECTION);
1233 
1234  assert(mParentMeta);
1235  if (blockdump) {
1236  mParentMeta->members.back().name = "@items_blockdump";
1237  mParentMeta->members.back().comment = countName;
1238  } else {
1239  mParentMeta->members.back().name = "@items";
1240  mParentMeta->members.back().comment = countName;
1241  }
1242  }
1243 
1244 protected:
1245 
1249 
1251 };
1252 
1253 
1255 
1262 template<typename T>
1263 class IsTransparentSerializableHelper<T, MetaSerializer> : public std::false_type {};
1264 
1265 template<typename T>
1266 class IsTransparentSerializableHelper<serialization::PlainArray<T>, MetaSerializer> : public std::true_type {};
1267 
1268 namespace serialization {
1269 
1271 
1280 template<typename Container>
1281 struct ReflectCollectionItems<MetaSerializer, Container>
1282 {
1283  static void reflect(MetaSerializer& r, Container& c)
1284  {
1285  typedef typename Container::value_type rawtype;
1286  typedef typename remove_cvref<rawtype>::type type;
1287 
1288  r.template collectionItems<type>("@itemcount");
1289  }
1290 };
1291 
1292 template<typename Allocator>
1293 struct ReflectReadBoolVectorItems<MetaSerializer, Allocator>
1294 {
1295  static void reflect(MetaSerializer& r, std::vector<bool, Allocator>& c)
1296  {
1297  r.template collectionItems<bool>("@itemcount");
1298  }
1299 };
1300 
1301 template<typename Container>
1302 struct ReflectReadSetItems<MetaSerializer, Container>
1303 {
1304  typedef typename Container::value_type rawtype;
1305  typedef typename remove_cvref<rawtype>::type type;
1306 
1307  static void reflect(MetaSerializer& r, Container& c)
1308  {
1309  r.template collectionItems<type>("@itemcount");
1310  }
1311 };
1312 
1313 template<typename Container>
1314 struct ReflectReadMapItems<MetaSerializer, Container>
1315 {
1316  typedef typename Container::key_type rawkeytype;
1317  typedef typename Container::mapped_type rawmappedtype;
1320 
1321  static void reflect(MetaSerializer& r, Container& c)
1322  {
1323  r.template collectionItems<type>("@itemcount");
1324  }
1325 };
1326 
1328 
1329 } // namespace
1330 
1332 
1334 
1335 } // namespace
1336 
1337 #endif
Member(TypeMetaPtr iType, const std::string &iName, const std::string &iComment)
Definition: MetaSerializer.h:386
This object can use object tracking internally, but the object tracking system&#39;s state remains unchan...
Definition: ReflectControlFlags.h:82
void reflect(Reflector &r)
Definition: MetaSerializer.h:524
void property(const char *name, const T &member, Setter< T > setter, const char *comment, PropertyHint &&hint=PropertyHint(), ReflectCtrlFlags flags=REFLECT_CTRLFLAG_NONE)
Definition: MetaSerializer.h:1157
TypeMetaPtr createMetaHelper(T *)
Definition: MetaSerializer.h:1085
void merge(const MetaTypeDatabase &other)
Merge meta information from other database into THIS.
Definition: MetaSerializer.h:560
#define META_MAKE_METHODMETA_PARAMETERDESC(z, n, _)
Definition: MetaSerializer.h:1121
MethodMeta()
Definition: MetaSerializer.h:346
Database that stores all meta type information and provides additional functions for accessing the da...
Definition: MetaSerializer.h:509
int qualifierCount() const
Returns the number of qualifiers.
Definition: MetaSerializer.h:250
std::list< Parameter > parameters
A list with info for each parameter.
Definition: MetaSerializer.h:368
std::list< Member > members
The members of the compound.
Definition: MetaSerializer.h:496
boost::shared_ptr< CompoundMeta > CompoundMetaPtr
Definition: MetaSerializer.h:503
Definition: BinarySerializer.h:324
void reflect(ConcreteBinarySerializer< BinaryStream, 0 > &r)
Definition: MetaSerializer.h:427
#define RPC_METHODS_MAX_PARAMS
Definition: ReflectorInterface.h:583
bool hasQualifier() const
Returns true, if the type meta contains qualifiers.
Definition: MetaSerializer.h:243
static void invoke(MetaSerializer *metaserializer)
Definition: MetaSerializer.h:1036
Definition: MetaSerializer.h:114
Type
The different types (ranging from fundamental types to user-defined class).
Definition: MetaSerializer.h:106
Class for in place stream formatting.
bool hasCodec() const
Returns true, of there is a codec for the specified type T.
Definition: MetaSerializer.h:702
std::string name
The name of the method.
Definition: MetaSerializer.h:362
static void reflect(Reflector &r, Container &c)
Definition: StlCollections.h:142
Parameter()
Definition: MetaSerializer.h:320
TypeMetaPtr type
The meta type info of the return parameter.
Definition: MetaSerializer.h:339
void object(T &member)
Definition: MetaSerializer.h:912
void addMember(const std::string &name, const std::string &comment, TypeMetaPtr type)
Definition: MetaSerializer.h:452
void addQualifier(TypeQualifier qualifier)
Adds a type qualifier.
Definition: MetaSerializer.h:182
Definition: MetaSerializer.h:117
void reflect(ConcreteBinarySerializer< BinaryStream, 0 > &r)
Definition: MetaSerializer.h:171
Parameter(TypeMetaPtr iType)
Definition: MetaSerializer.h:321
Type trait that indicates whether a type can be serialized bitwise by just copying the data buffer...
Definition: IsBitwiseSerializable.h:70
specialize cv::DataType for our ImgPixel and inherit from cv::DataType<Vec>
Definition: IOService.h:67
void reflect(Reflector &r)
Definition: MetaSerializer.h:408
MetaTypeDatabase(const MetaTypeDatabase &other)
Definition: MetaSerializer.h:515
void delegate(Getter< T > getter, Setter< T > setter, ReflectCtrlFlags flags=REFLECT_CTRLFLAG_NONE)
Definition: MetaSerializer.h:1218
void member(const char *name, T &member, const char *comment, ReflectCtrlFlags flags=REFLECT_CTRLFLAG_NONE)
Definition: RecursiveMemberReflector.h:871
Definition: MetaSerializer.h:108
Definition: MetaSerializer.h:119
Definition: MetaSerializer.h:120
ReflectState preReflect(const char *context="")
Definition: MetaSerializer.h:672
Definition: MetaSerializer.h:138
#define MIRA_REFLECT_BASE(reflector, BaseClass)
Macro that can be used to reflect the base class easily.
Definition: ReflectorInterface.h:956
void collectionItems(const std::string &countName, bool blockdump=false)
Definition: MetaSerializer.h:1227
void addMember(const ReflectMemberMeta &memberMeta, TypeMetaPtr type)
Definition: MetaSerializer.h:442
void addMethod(MethodMetaPtr method)
Definition: MetaSerializer.h:726
Setter< T > setter(void(*f)(const T &))
Creates a Setter for global or static class methods taking the argument by const reference.
Definition: GetterSetter.h:443
Definition: BinarySerializer.h:991
void property(const char *name, const std::string &id, T &member, const char *comment, PropertyHint &&hint=PropertyHint(), ReflectCtrlFlags flags=REFLECT_CTRLFLAG_NONE)
Definition: MetaSerializer.h:1149
Holds a boost::function object to a special setter function that must meet the signature "void method...
Definition: GetterSetter.h:395
Stores meta information for each member.
Definition: ReflectMemberMeta.h:64
Type trait that indicates whether a type can be serialized as an atomic value.
Definition: IsAtomicSerializable.h:71
void addMethod(const MethodMetaPtr &method)
Definition: MetaSerializer.h:478
static void invoke(MetaSerializer *metaserializer)
Definition: MetaSerializer.h:994
void reflect(Reflector &r)
Definition: MetaSerializer.h:353
VersionType version(VersionType version, AcceptDesiredVersion, const T *caller=NULL)
Definition: MetaSerializer.h:666
void reflect(Reflector &r)
Definition: MetaSerializer.h:148
#define META_GEN_METHODS_PARAMDESC(z, n, _)
Definition: MetaSerializer.h:771
uint8 VersionType
Definition: ReflectorInterface.h:72
#define MIRA_THROW(ex, msg)
Macro for throwing an exception.
Definition: Exception.h:81
Type trait to check if a class is default constructible.
MetaTypeDatabase()
Definition: MetaSerializer.h:514
A property hint gives optional instructions to the property editor, i.e.
Definition: PropertyHint.h:82
std::string toString(const T &value, int precision=-1)
Converts any data type to string (the data type must support the stream << operator).
Definition: ToString.h:256
TypeQualifier getQualifier(int i=0) const
Returns the i-th type qualifier, or NO_QUALIFIER if there is no such qualifier.
Definition: MetaSerializer.h:258
void insertMember(const std::string &name, TypeMetaPtr type, int index)
Definition: MetaSerializer.h:457
void pointer(T *&pointer)
Definition: MetaSerializer.h:897
serialization::VersionType VersionType
Definition: MetaSerializer.h:625
serialization::VersionType VersionType
Definition: MetaSerializer.h:405
std::string name
The name of the parameter.
Definition: MetaSerializer.h:341
void setBaseAtomicType(Type type)
Sets the datatype to one of the built-in atomic types (TYPE_INT,FLOAT, etc).
Definition: MetaSerializer.h:190
static void invoke(MetaSerializer *metaserializer)
Definition: MetaSerializer.h:1020
Type trait that indicates whether a type does not support to gather meta information about it...
Definition: IsNotMetaSerializable.h:65
TypeMetaPtr type
The meta type info of the member.
Definition: MetaSerializer.h:398
Type trait that indicates whether a type does not support to gather meta information about it...
#define META_GEN_METHODS(z, n, _)
Definition: MetaSerializer.h:740
void removeQualifiers(int n)
Removes the n last qualifiers.
Definition: MetaSerializer.h:269
Binary serializer and deserializer.
Parameter(TypeMetaPtr iType, const std::string &iName, const std::string &iDescription)
Definition: MetaSerializer.h:323
Definition: MetaSerializer.h:586
void atomic(T &)
Definition: MetaSerializer.h:875
static void reflect(Reflector &r, Container &c)
Definition: StlCollections.h:343
#define META_GEN_METHODS_WRONG_ARGUMENT_NUMBER(z, n, _)
Definition: MetaSerializer.h:845
No flags.
Definition: ReflectControlFlags.h:65
PropertyHint type(const std::string &t)
Sets the attribute "type" to the specified value.
Definition: PropertyHint.h:295
uint8 version() const
Returns the metatype format version.
Definition: MetaSerializer.h:301
void delegate(const T &member, Setter< T > setter, ReflectCtrlFlags flags=REFLECT_CTRLFLAG_NONE)
Definition: MetaSerializer.h:1209
void reflect(Reflector &r)
Definition: MetaSerializer.h:331
void delegate(T &member, ReflectCtrlFlags flags=REFLECT_CTRLFLAG_NONE)
Definition: MetaSerializer.h:1199
void reflect(Reflector &r)
Definition: MetaSerializer.h:390
TypeMetaPtr createMeta()
Definition: MetaSerializer.h:1044
Definition: MetaSerializer.h:125
VersionType version(VersionType version, const T *caller=NULL)
Definition: MetaSerializer.h:651
ReflectorInterface< MetaSerializer >::AcceptDesiredVersion AcceptDesiredVersion
Definition: AbstractReflector.h:200
Container::value_type type
Definition: ReflectCollection.h:87
Getter< T > getter(T(*f)())
Creates a Getter for global or static class methods returning the result by value.
Definition: GetterSetter.h:136
void property(const char *name, T &member, const char *comment, PropertyHint &&hint=PropertyHint(), ReflectCtrlFlags flags=REFLECT_CTRLFLAG_NONE)
Definition: MetaSerializer.h:1141
void reflect(Reflector &r, LogRecord &record)
Non-intrusive reflector for LogRecord.
Definition: LoggingCore.h:136
static void reflect(Reflector &r, Container &c)
Definition: ReflectCollection.h:89
TypeMetaPtr returnType
The meta type info of the return type.
Definition: MetaSerializer.h:366
boost::shared_ptr< TypeMeta > TypeMetaPtr
Definition: MetaSerializer.h:309
void property(const char *name, Getter< T > getter, Setter< T > setter, const char *comment, const U &defaultValue, PropertyHint &&hint=PropertyHint(), ReflectCtrlFlags flags=REFLECT_CTRLFLAG_NONE)
Definition: MetaSerializer.h:1190
CompoundMetaPtr mParentMeta
Definition: MetaSerializer.h:1248
TypeQualifier
Additional qualifiers.
Definition: MetaSerializer.h:134
Definition: MetaSerializer.h:122
const char * comment
Additional user comments.
Definition: ReflectMemberMeta.h:76
std::list< std::string > interfaces
The reflected interfaces.
Definition: MetaSerializer.h:498
void addMember(const std::string &name, TypeMetaPtr type)
Definition: MetaSerializer.h:447
void reflect(ConcreteBinaryDeserializer< BinaryStream, 0 > &r)
Definition: MetaSerializer.h:157
void property(const char *name, const T &member, Setter< T > setter, const char *comment, const U &defaultValue, PropertyHint &&hint=PropertyHint(), ReflectCtrlFlags flags=REFLECT_CTRLFLAG_NONE)
Definition: MetaSerializer.h:1181
Definition: MetaSerializer.h:123
Type getType() const
Returns the type flag which is the first item in the vector.
Definition: MetaSerializer.h:234
CompoundMeta::Member * mCurrentVersion
Definition: MetaSerializer.h:1250
MIRA_DEPRECATED("Please call as version<MyType>(v) or version(v, this)", VersionType version(VersionType version))
Definition: MetaSerializer.h:655
TypeMetaPtr createMetaOrVoidHelper()
Definition: MetaSerializer.h:1067
VersionType version(VersionType version, const T *caller=NULL)
Definition: BinarySerializer.h:617
static int forcedSerializeVersion()
Returns either the version number from value of environment variable &#39;MIRA_FORCE_SERIALIZE_VERSION&#39;, or -1 (= do not force a version).
Definition: Serializer.h:145
void write(const T *data, std::size_t count)
Definition: MetaSerializer.h:692
boost::mpl::bool_< false > isObjectTrackingSupported
Definition: MetaSerializer.h:591
void postReflect(const ReflectState &prev)
Definition: MetaSerializer.h:686
MetaTypeDatabase & operator=(const MetaTypeDatabase &other)
Definition: MetaSerializer.h:517
CompoundMeta::Member * ReflectState
Definition: MetaSerializer.h:594
std::string comment
The user defined comment as specified in the r.method() call.
Definition: MetaSerializer.h:364
Holds a boost::function object to a special getter function that must meet the signature "T method()"...
Definition: GetterSetter.h:87
Definition: MetaSerializer.h:111
Meta Type information.
Definition: MetaSerializer.h:97
std::map< std::string, VersionType > version
The version(s) of the described type&#39;s serialization format.
Definition: MetaSerializer.h:494
void addCurrentAsMemberToParent()
Definition: MetaSerializer.h:985
TypeMetaPtr createMetaHelper(void *)
Definition: MetaSerializer.h:1090
Definition: MetaSerializer.h:993
const std::string & getIdentifier() const
Returns the identifier of the user-defined atomic type or class type.
Definition: MetaSerializer.h:281
Meta information for RPC methods.
Definition: MetaSerializer.h:316
void setAtomicType()
Same as above, but typename is extracted from T.
Definition: MetaSerializer.h:207
Definition: BinarySerializer.h:257
static void invoke(MetaSerializer *metaserializer)
Definition: MetaSerializer.h:1027
MetaTypeDatabase getDependentTypesDB(TypeMetaPtr type)
Generates a database which is a subset of THIS database and contains all types that are necessary to ...
Definition: MetaSerializer.h:569
int size() const
Returns the number of items (the type item + qualifier items)
Definition: MetaSerializer.h:298
void insertMember(const std::string &name, TypeMetaPtr type, const std::string &before)
Definition: MetaSerializer.h:465
void setVersion(const std::string &type, VersionType version)
Definition: MetaSerializer.h:487
VersionType version(VersionType version, const std::string &type, bool acceptDesiredVersion=false)
Definition: MetaSerializer.h:641
std::string name
The name of the member.
Definition: MetaSerializer.h:400
ReflectCtrlFlags
Control Flags that can modify the behavior of certain reflectors.
Definition: ReflectControlFlags.h:63
void setType()
Sets the datatype.
Definition: MetaSerializer.h:224
std::string comment
The user defined comment as specified in the r.member() call.
Definition: MetaSerializer.h:402
Definition: MetaSerializer.h:139
void setClassType(const std::string &identifier)
Sets the data type to TYPE_CLASS and sets the class identifier.
Definition: MetaSerializer.h:212
TypeMeta(uint8 version=2)
Definition: MetaSerializer.h:145
#define MIRA_BASE_EXPORT
This is required because on windows there is a macro defined called ERROR.
Definition: Platform.h:153
Type trait that indicates whether a type is a collection.
Definition: IsCollection.h:63
void property(const char *name, Getter< T > getter, Setter< T > setter, const char *comment, PropertyHint &&hint=PropertyHint(), ReflectCtrlFlags flags=REFLECT_CTRLFLAG_NONE)
Definition: MetaSerializer.h:1165
TypeMetaPtr createMetaHelper()
Definition: MetaSerializer.h:1076
void property(const char *name, T &member, const char *comment, const U &defaultValue, PropertyHint &&hint=PropertyHint(), ReflectCtrlFlags flags=REFLECT_CTRLFLAG_NONE)
Definition: MetaSerializer.h:1173
std::string description
The description for the parameter.
Definition: MetaSerializer.h:343
void reflect(ConcreteBinaryDeserializer< BinaryStream, 0 > &r)
Definition: MetaSerializer.h:530
void reflect(ConcreteBinarySerializer< BinaryStream, 0 > &r)
Definition: MetaSerializer.h:544
Definition: MetaSerializer.h:124
void invokeOverwrite(T &object)
Definition: MetaSerializer.h:940
Definition: IsTransparentSerializable.h:84
Accessor< Getter, Setter > makeAccessor(const Getter &getter, const Setter &setter)
Helper method that creates an accessor from a different combination of either direct access to a vari...
Definition: Accessor.h:300
MethodMeta(const std::string &iName, const std::string &iComment)
Definition: MetaSerializer.h:347
TypeMetaPtr mCurrentMeta
Definition: MetaSerializer.h:1247
void invokeOverwrite(serialization::PlainArray< T > &array)
Specialized for PlainArray, because the BinarySerializer does it...
Definition: MetaSerializer.h:955
boost::mpl::bool_< true > requireReflectBarriers
Definition: MetaSerializer.h:593
void addInterface(const std::string &iface)
Definition: MetaSerializer.h:473
const char * id
The id (used for containers where the name is identical, in all other cases the id usually is equal t...
Definition: ReflectMemberMeta.h:73
A single member of the compound.
Definition: MetaSerializer.h:383
void interface(const char *name)
Definition: MetaSerializer.h:719
void setVersion(VersionType version)
Definition: MetaSerializer.h:483
Definition: MetaSerializer.h:118
Meta information for complex compounds, like classes and structs.
Definition: MetaSerializer.h:379
Definition: MetaSerializer.h:318
#define META_MAKE_METHODMETA(z, n, _)
Definition: MetaSerializer.h:1100
TypeMetaPtr addMeta(T &v)
Definition: MetaSerializer.h:605
static void invoke(MetaSerializer *metaserializer)
Definition: MetaSerializer.h:1003
#define META_GEN_METHODS_PARAMDESCSAMPLE(z, n, _)
Definition: MetaSerializer.h:809
CompoundMetaPtr createMapEntry(TypeMetaPtr &type)
Definition: MetaSerializer.h:972
MetaTypeDatabase & mMetaDatabase
Definition: MetaSerializer.h:1246
void enumeration(T &)
Definition: MetaSerializer.h:886
Definition: MetaSerializer.h:121
std::list< MethodMetaPtr > methods
The reflected methods (RPC methods)
Definition: MetaSerializer.h:500
static void invoke(MetaSerializer *metaserializer)
Definition: MetaSerializer.h:1011
Platform dependent defines and macros.
boost::shared_ptr< MethodMeta > MethodMetaPtr
Definition: MetaSerializer.h:371
MetaSerializer(MetaTypeDatabase &database)
The meta serializer will work on the database and adds new types there.
Definition: MetaSerializer.h:601
bool codec(const T &obj)
Encodes the specified object containing the data using a matching codec.
Definition: MetaSerializer.h:714
Container::value_type type
Definition: StlCollections.h:140
Member()
Definition: MetaSerializer.h:385