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>
#include <boost/foreach.hpp>

namespace MAKVRinTerra
{
   class DT_DLL_features DtSimpleFeature
      : public DtFeature
      , public DtObjectDebugger<DtSimpleFeature>
   {
   public:
      typedef boost::shared_ptr<DtSimpleFeature>         Ptr;
      typedef boost::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, _1, _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;
      }

      DtFeatureGeometry geometry() const
      {
         return myGeometry;
      }

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

         return 0;
      }

      boost::optional<Attribute> attribute(const Key & k) const
      {
         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>();
      }

      void forEachAttribute(ForEachFunction f) const
      {
         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]);
      }

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

      bool isDeleted() const
      {
         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
      , public DtObjectDebugger< DtDeletableFeature<F> >
   {
   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<void ()> 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);