dynamicFeature.h

Go to the documentation of this file.

/*******************************************************************************
** Copyright (c) 2020 MAK Technologies, Inc.
** All rights reserved.
*******************************************************************************/


#pragma once

#include "features/feature.h"

#include <boost/signals2.hpp>
#include <boost/foreach.hpp>

namespace MAKVRinTerra
{
   template <typename F>
   class DtDynamicFeature
      : public F
      , public boost::enable_shared_from_this< DtDynamicFeature<F> >
#ifdef DtObjectDebugger_Enable
      , public DtObjectDebugger< DtDynamicFeature<F> >
#endif
   {
   public:
      typedef typename F::ForEachFunction ForEachFunction;
      typedef typename F::Key Key;
      typedef typename F::Attribute Attribute;
      typedef typename F::DeleteCallback DeleteCallback;
      typedef typename F::DetachCallback DetachCallback;

      typedef boost::shared_ptr<DtDynamicFeature>       Ptr;
      typedef boost::shared_ptr<const DtDynamicFeature> CPtr;

      explicit DtDynamicFeature(DtFeatureGeometry geom = DtFeatureGeometry())
         : myDeletedFlag(false)
         , myGeometry(geom)
      {

      }

      ~DtDynamicFeature()
      {
         if (!myDeletedFlag)
            myDeleteSignal();
      }

      DtFeature* clone() const
      {
         return new DtFeatureWrapper<F>(
            const_cast<DtDynamicFeature*>(this)->shared_from_this());
      }

      DtFeatureGeometry geometry() const
      {
         return myGeometry;
      }

      void forEachAttribute(ForEachFunction func) const
      {
         BOOST_FOREACH(const typename AttributeMap::value_type& pair, myAttributes)
            func(pair.first, pair.second);
      }

      unsigned numberOfAttributes(const typename Key::String & name) const
      {
         if (myAttributes.find(name) != myAttributes.end())
            return 1;

         return 0;
      }

      bool hasAttribute(const Key & k) const
      {
         if (k.index == 0 && myAttributes.find(k.name) != myAttributes.end())
            return true;

         return false;
      }

      boost::optional<Attribute> attribute(const Key & k) const
      {
         if (k.index == 0)
         {
            typename AttributeMap::const_iterator i = myAttributes.find(k.name);
            if (i != myAttributes.end())
               return Attribute(i->second);
         }

         return boost::none_t();
      }

      DetachCallback addDeleteCallback(const DeleteCallback& callback) const
      {
         if (!callback)
            return DetachCallback();

         Mutex::scoped_lock lock(myMutex, false);
         if (myDeletedFlag)
         {
            lock.release();
            callback();
            return DetachCallback();
         }

         if (!lock.upgrade_to_writer() && myDeletedFlag)
         {
            lock.release();
            callback();
            return DetachCallback();
         }

         boost::signals2::connection conn(myDeleteSignal.connect(callback, boost::signals2::at_front));
         return boost::bind(&boost::signals2::connection::disconnect, conn);
      }

      bool isDeleted() const
      {
         Mutex::scoped_lock lock(myMutex, false);
         return myDeletedFlag;
      }

      void setDeleted()
      {
         {
            Mutex::scoped_lock lock(myMutex, true);
            if (myDeletedFlag)
               return;

            myDeletedFlag = true;
         }

         myDeleteSignal();
         myDeleteSignal.disconnect_all_slots();
      }

   protected:
      typedef tbb::spin_rw_mutex Mutex;
      mutable Mutex myMutex;
      bool myDeletedFlag;

      typedef boost::signals2::signal<void ()> DeleteSignal;
      mutable DeleteSignal myDeleteSignal;

      DtFeatureGeometry myGeometry;

      typedef std::map<Key, Attribute> AttributeMap;
      AttributeMap myAttributes;
   };
}