How to create new Entities in MemoryX

• define a class in slice which inherits from EntityBase and add custom accessor methods

  #include <MemoryX/interface/core/EntityBase.ice>
   
  memoryx
  {
      ["cpp:virtual"]
      class CountBase extends EntityBase
      {
          ["cpp:const"]
          int getCount();
          void setCount(int count);
      };
  };

• Define C++ class

  #ifndef ARMARX_MEMORYX_CORE_COUNT_ENTITY_H_
  #define ARMARX_MEMORYX_CORE_COUNT_ENTITY_H_
   
  #include <MemoryX/core/entity/Entity.h>
  #include <MemoryX/interface/core/EntityBase.h>
  #include <MemoryX/interface/memorytypes/MyNewEntities.h>
   
  // the following is required for the friend class declaration used together with private/protected constructors
  // see http://stackoverflow.com/a/2060691
  //
  //namespace armarx
  //{
  //    template <class IceBaseClass, class DerivedClass> class GenericFactory;
  //}
   
  namespace memoryx
  {
      class Count;
      using CountPtr = IceInternal::Handle<Count>;
   
      class Count :
          public memoryx::CountBase,
          public memoryx::Entity
      {
          // add this line if you want to make your constructor private/protected
          // you also need to uncomment the namespace declaration for this to work
          // template <class IceBaseClass, class DerivedClass> friend class armarx::GenericFactory;
      public:
          Count();
          Count(const Count& source);
          virtual ~Count();
   
          // cloning
          Ice::ObjectPtr ice_clone() const;
          CountPtr clone(const Ice::Current& c = Ice::emptyCurrent) const;
   
          // interface
          Ice::Int getCount(const Ice::Current& context = Ice::emptyCurrent) const;
          void setCount(Ice::Int count, const Ice::Current& context = Ice::emptyCurrent);
   
      private:
          void output(std::ostream &stream) const;
   
      public:
          // streaming operator
          friend std::ostream &operator<<(std::ostream &stream, const Count& rhs)
          {
              rhs.output(stream);
              return stream;
          }
   
          friend std::ostream &operator<<(std::ostream &stream, const CountPtr& rhs)
          {
              rhs->output(stream);
              return stream;
          }
   
          friend std::ostream &operator<<(std::ostream &stream, const CountBasePtr& rhs)
          {
              stream << CountPtr::dynamicCast(rhs);
              return stream;
          }
      };
  }
  #endif

• implement C++ class

  #include <ArmarXCore/core/system/Synchronization.h>
   
  #include "Count.h"
   
  namespace memoryx
  {
      Count::Count() :
          Entity()
      {
          EntityAttributePtr countAttribute = new EntityAttribute("count");
          putAttribute(countAttribute);
      }
   
      Count::Count(const Count& source):
          IceUtil::Shared(source),
          ::armarx::Serializable(source),
          EntityBase(),// dont copy
          CountBase(source),
          Entity(source)
      {
      }
   
      Count::~Count()
      {
      }
   
      void Count::output(std::ostream &stream) const
      {
          Entity::output(stream);
      }
   
   
      Ice::ObjectPtr Count::ice_clone() const
      {
          return this->clone();
      }
   
      CountPtr Count::clone(const Ice::Current& c) const
      {
          boost::shared_lock<boost::shared_mutex> entityLock(entityMutex);
          armarx::ScopedLock attributesLock(attributesMutex);
          armarx::RecursiveMutex::scoped_lock wrappersLock(wrappersMutex);
          CountPtr ret = new Count(*this);
          return ret;
      }
   
      Ice::Int Count::getCount(const Ice::Current& context) const
      {
          return getAttribute("count")->getValue()->getInt();
      }
   
      void Count::setCount(Ice::Int count, const Ice::Current& context)
      {
          getAttribute("count")->setValue(new armarx::Variant(count));
      }
  }

• add files to a library SOURCES/HEADERS variables in respective CMakeLists.txt

• create and register new ObjectFactory for your specialized memoryx::Entity subclass (this is required so Ice knows how to deserialize your new entity)

  namespace ObjectFactories
  {
      class NewTypesObjectFactories : public armarx::FactoryCollectionBase
      {
      public:
          armarx::ObjectFactoryMap getFactories()
          {
              armarx::ObjectFactoryMap map;
   
              // here be other types as well
              // add<XBase, X>(map);
   
              // call template function with Ice type and C++ specific type
              add<CountBase, Count>(map);
   
              return map;
          }
      };
   
      const armarx::FactoryCollectionBaseCleanUp NewTypesObjectFactoriesVar = armarx::FactoryCollectionBase::addToPreregistration(new NewTypesObjectFactories());
  }