simpleFeature.h

Go to the documentation of this file.

#pragma once

#include <features/feature.h>

#include <tbb/spin_mutex.h>
#include <tbb/spin_rw_mutex.h>

#include <boost/signals2.hpp>

namespace MAKVRinTerra
{
   class DT_DLL_features DtSimpleFeature
      : public DtFeature
#ifdef DtObjectDebugger_Enable
      , public DtObjectDebugger<DtSimpleFeature>
#endif
   {
   public:
      typedef std::shared_ptr<DtSimpleFeature>         Ptr;
      typedef std::shared_ptr<const DtSimpleFeature>   CPtr;

      DtSimpleFeature()
      {
      }

      explicit DtSimpleFeature(const DtFeatureGeometry& geom) : myGeometry(geom)
      {
      }

      template <DtFeatureGeometry::Type T>
      explicit DtSimpleFeature(const typename DtFeatureGeometry::Handle<T>& h)
         : myGeometry(h)
      {
      }

      explicit DtSimpleFeature(const DtFeature & f) : myGeometry(f.geometry())
      {
         f.forEachAttribute(boost::bind(&DtSimpleFeature::addAttribute, this, boost::placeholders::_1, boost::placeholders::_2));
      }

      void addAttribute(const Key& k, Attribute attr)
      {
         AttributeVector& vec = myAttributeVectorMap[k.name];
         if (vec.size() <= k.index)
         {
            vec.resize(k.index + 1);
         }
         vec[k.index] = attr;
      }

      virtual DtFeatureGeometry geometry() const override { return myGeometry; }

      virtual unsigned numberOfAttributes(const Key::String& name) const override
      {
         AttributeVectorMap::const_iterator set = myAttributeVectorMap.find(name);
         if (set != myAttributeVectorMap.end())
         {
            return set->second.size();
         }

         return 0;
      }

      virtual boost::optional<Attribute> attribute(const Key& k) const override
      {
         AttributeVectorMap::const_iterator set = myAttributeVectorMap.find(k.name);
         if (set != myAttributeVectorMap.end())
         {
            if (k.index < set->second.size())
            {
               return set->second[k.index];
            }
         }

         return boost::optional<Attribute>();
      }

      virtual void forEachAttribute(ForEachFunction f) const override
      {
         typedef AttributeVectorMap::const_iterator MapIterator;

         for (MapIterator set = myAttributeVectorMap.begin(); set != myAttributeVectorMap.end(); ++set)
         {
            for (unsigned setIndex = 0; setIndex < set->second.size(); ++setIndex)
            {
               f(Key(set->first, setIndex), set->second[setIndex]);
            }
         }
      }

      virtual DetachCallback addDeleteCallback(const DeleteCallback&) const override { return DetachCallback(); }

      virtual bool isDeleted() const override {
         return false;
      }

   private:
      typedef std::vector<Attribute> AttributeVector;
      typedef std::map<DtFeature::Key::String, AttributeVector> AttributeVectorMap;

      AttributeVectorMap myAttributeVectorMap;
      DtFeatureGeometry myGeometry;
   };

   template <typename F = DtFeature>
   class DtDeletableFeature
      : public F
#ifdef DtObjectDebugger_Enable
      , public DtObjectDebugger< DtDeletableFeature<F> >
#endif
   {
   public:
      typedef typename F::DetachCallback DetachCallback;
      typedef typename F::DeleteCallback DeleteCallback;

      explicit DtDeletableFeature(bool deleted = false)
         : deleted(deleted)
      {
      }

      bool isDeleted() const
      {
         Mutex::scoped_lock lock(mutex);
         return deleted;
      }

      DetachCallback addDeleteCallback(const DeleteCallback& callback) const
      {
         Mutex::scoped_lock lock(mutex);
         if (deleted)
         {
            lock.release();
            callback();
            return DetachCallback();
         }

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

      void setDeleted()
      {
         Mutex::scoped_lock lock(mutex);
         if (!deleted)
         {
            deleted = true;
            lock.release();

            signal();
            signal.disconnect_all_slots();
         }
      }

   private:
      typedef tbb::spin_mutex                  Mutex;

      typedef boost::signals2::signal_type<
         void (),
         boost::signals2::keywords::mutex_type<tbb::spin_mutex> >::type Signal;

      typedef boost::signals2::connection      Connection;

      mutable Mutex mutex;
      mutable Signal signal;
      bool deleted;
   };
}

DT_DEFINE_OBJECT_DEBUGGER_NAME(MAKVRinTerra::DtSimpleFeature);
DT_DEFINE_OBJECT_DEBUGGER_NAME_TEMPLATE(MAKVRinTerra::DtDeletableFeature);