feature.h

Go to the documentation of this file.

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

#pragma once

#include <features/featuresDefines.h>
#include <features/featureGeometry.h>

#include <boost/shared_ptr.hpp>
#include <boost/function.hpp>
#include <boost/variant.hpp>
#include <boost/lexical_cast.hpp>
#include <boost/signals2.hpp>

#include <tbb/spin_mutex.h>

#include <vrfutil/objectCounter.h>

#include <vlutil/vlPrint.h>

namespace MAKVRinTerra
{
   class DT_DLL_features DtFeature
      : private boost::noncopyable
      , public DtObjectDebugger<DtFeature>
   {
   public:
      static const char* TypeName;

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

      typedef boost::variant<
         std::string,
         int,
         double
      > Attribute;

      template <typename T>
      static boost::optional<T> ConvertAttribute(const Attribute& attr)
      {
         return boost::apply_visitor(AttributeConverter<T>(), attr);
      }

      struct DT_DLL_features Key
      {
         class DT_DLL_features String
         {
         public:
            String();
            String(const std::string&);
            String(const char*);

            const char* c_str() const;

            const std::string& str() const;

            bool operator==(const String&) const;
            bool operator!=(const String&) const;
            bool operator<(const String&) const;

         private:
            std::string myString;
         };

         Key(const std::string& name, unsigned index = 0);
         Key(const String& name, unsigned index = 0);
         Key(const char* name, unsigned index = 0);
         Key(const Key& key, unsigned index = 0);

         bool operator== (const Key&) const;
         bool operator!= (const Key&) const;
         bool operator< (const Key&) const;

         String name;
         unsigned index;
      };
      
      static bool Equal(const Attribute&, const Attribute&);
      static bool NotEqual(const Attribute&, const Attribute&);
      static bool Less(const Attribute&, const Attribute&);
      static bool LessOrEqual(const Attribute&, const Attribute&);
      static bool Greater(const Attribute&, const Attribute&);
      static bool GreaterOrEqual(const Attribute&, const Attribute&);
      static bool Regex(const Attribute& text, const Attribute& pattern);

      static std::string TypeOfAttribute(const Attribute&);

      static std::auto_ptr<DtFeature> CreateEmptyFeature();

      static std::auto_ptr<DtFeature> CreateGeometryFeature(const DtFeatureGeometry&);

      static std::auto_ptr<DtFeature> CreateGeometryFeature(
         const DtFeatureGeometry&,
         unsigned char red, unsigned char green, unsigned char blue);

      static std::auto_ptr<DtFeature> CreateCopy(const DtFeature& feature);

      virtual ~DtFeature();

      virtual DtFeature* clone() const;

      virtual DtFeatureGeometry geometry() const = 0;

      typedef boost::function<void (const Key&, const Attribute&)> ForEachFunction;

      virtual void forEachAttribute(ForEachFunction f) const = 0;

      virtual unsigned numberOfAttributes(const Key::String &) const = 0;

      virtual bool hasAttribute(const Key & k) const;

      virtual boost::optional<Attribute> attribute(const Key &) const = 0;

      template <typename T>
      boost::optional<T> attributeAs(const Key& k) const
      {
         if (boost::optional<Attribute> attr = attribute(k))
            return boost::apply_visitor(AttributeConverter<T>(), *attr);

         return boost::none;
      }

      typedef boost::function<void ()> DetachCallback;

      typedef boost::function<void ()> DeleteCallback;

      virtual DetachCallback addDeleteCallback(
         const DeleteCallback& callback) const = 0;

      virtual bool isDeleted() const = 0;

   private:
      template <typename T>
      struct AttributeConverter : public boost::static_visitor< boost::optional<T> >
      {
         template <typename From>
         boost::optional<T> operator()(const From& from) const
         {
            try
            {
               return boost::lexical_cast<T>(from);
            }
            catch (boost::bad_lexical_cast&)
            {
               return boost::optional<T>();
            }
         }
      };
   };

   template <typename Feature, typename Inner = Feature>
   class DtFeatureRefWrapper : public Feature
   {
   public:
      typedef typename Feature::ForEachFunction ForEachFunction;
      typedef typename Feature::Attribute       Attribute;
      typedef typename Feature::Key             Key;

      typedef typename Inner::DetachCallback DetachCallback;

      DtFeatureGeometry geometry() const
      {
         return myFeature.geometry();
      }

      void forEachAttribute(ForEachFunction func) const
      {
         myFeature.forEachAttribute(func);
      }

      unsigned numberOfAttributes(const typename Key::String& str) const
      {
         return myFeature.numberOfAttributes(str);
      }

      boost::optional<Attribute> attribute(const Key& key) const
      {
         return myFeature.attribute(key);
      }

      DetachCallback addDeleteCallback(
         const typename Inner::DeleteCallback& callback) const
      {
         return myFeature.addDeleteCallback(callback);
      }

      bool isDeleted() const
      {
         return myFeature.isDeleted();
      }

      Feature* clone() const
      {
         return myFeature.clone();
      }

      explicit DtFeatureRefWrapper(const DtFeatureRefWrapper& from)
         : myFeature(from.myFeature)
      {
      }

      explicit DtFeatureRefWrapper(const Inner& feature)
         : myFeature(feature)
      {
      }

      //protected:
      //Inner& wrappedFeature() { return myFeature; }
      //const Inner& wrappedFeature() const { return myFeature; }

   protected:
      const Inner& myFeature;
   };

   template <typename Feature, typename Inner = Feature>
   class DtFeatureWrapper : public Feature
   {
   public:
      typedef typename Feature::ForEachFunction ForEachFunction;
      typedef typename Feature::Attribute       Attribute;
      typedef typename Feature::Key             Key;

      typedef typename Inner::DetachCallback DetachCallback;

      ~DtFeatureWrapper()
      {
         myConnection.disconnect();
      }

      DtFeatureGeometry geometry() const
      {
         return myData->feature->geometry();
      }

      void forEachAttribute(ForEachFunction func) const
      {
         myData->feature->forEachAttribute(func);
      }

      unsigned numberOfAttributes(const typename Key::String& str) const
      {
         return myData->feature->numberOfAttributes(str);
      }

      boost::optional<Attribute> attribute(const Key& key) const
      {
         return myData->feature->attribute(key);
      }

      struct DeletedCounter
         : public DtObjectDebugger<DeletedCounter>
      {
         const typename Inner::DeleteCallback callback;
         explicit DeletedCounter(const typename Inner::DeleteCallback& cb) : callback(cb) { }
         void operator()() const { callback(); }
      };
      
      DetachCallback addDeleteCallback(
         const typename Inner::DeleteCallback& callback) const
      {
         if (!callback)
            return DetachCallback();

         Mutex::scoped_lock lock(myData->mutex);
         if (myData->deleted)
         {
            lock.release();
            callback();
            return DetachCallback();
         }

         //Connection conn(mySignal.connect(callback, boost::signals2::at_front));
         Connection conn = mySignal.connect(DeletedCounter(callback), boost::signals2::at_front);

         return boost::bind(&Connection::disconnect, conn);
      }

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

      DtFeatureWrapper* clone() const
      {
         return new DtFeatureWrapper(*this);
      }

      void setDeleted()
      {
         typename Data::SPtr d(myData);
         d->deletedCallback();
      }

      explicit DtFeatureWrapper(const DtFeatureWrapper& from)
         : myData(from.myData)
         , myConnection()
      {
         Mutex::scoped_lock lock(myData->mutex);
         if (!myData->deleted)
            myConnection = myData->signal.connect(boost::ref(mySignal), boost::signals2::at_front);
      }

      explicit DtFeatureWrapper(const typename Inner::Ptr& f)
         : myData(new Data(f))
         , myConnection(myData->signal.connect(boost::ref(mySignal)))
      {
         myData->init(myData);
      }

      explicit DtFeatureWrapper(Inner* feature)
         : myData(new Data(typename Inner::Ptr(feature)))
         , myConnection(myData->signal.connect(boost::ref(mySignal)))
      {
         myData->init(myData);
      }

      explicit DtFeatureWrapper(const Inner& feature)
         : myData(new Data(typename Inner::Ptr(feature.clone())))
         , myConnection(myData->signal.connect(boost::ref(mySignal)))
      {
         myData->init(myData);
      }

      Inner& wrappedFeature() { return *myData->feature; }
      const Inner& wrappedFeature() const { return *myData->feature; }


   private:
      typedef tbb::spin_mutex Mutex;

      typedef boost::signals2::signal<void ()> Signal;
      typedef boost::signals2::connection      Connection;

      struct Data : boost::noncopyable
      {
      public:
         typedef boost::shared_ptr<Data> SPtr;
         typedef boost::weak_ptr<Data>   WPtr;

         void deletedCallback()
         {
            Mutex::scoped_lock lock(mutex);
            if (!deleted)
            {
               deleted = true;
               DetachCallback localDetacher;
               swap(localDetacher, detacher);

               lock.release();

               try
               {
                  if (localDetacher)
                     localDetacher();

                  signal();
                  signal.disconnect_all_slots();
               }
               catch (...)
               {
                  DtWarn << "Exception thrown in delete callback" << std::endl;
               }
            }
         }

         explicit Data(const typename Inner::Ptr& f)
            : feature(f)
            , deleted(feature->isDeleted())
         {
         }

         ~Data()
         {
            if (detacher)
               detacher();
         }

         bool init(const SPtr& This)
         {
            assert(!detacher);

            if (!deleted)
               detacher = feature->addDeleteCallback(Caller(This));

            return detacher;
         }

         struct Caller
         {
            WPtr datawptr;
            explicit Caller(const SPtr& data) : datawptr(data) { }

            void operator()() const
            {
               SPtr data(datawptr.lock());
               if (data)
                  data->deletedCallback();
            }
         };

         mutable Mutex mutex;
         typename Inner::Ptr feature;
         DetachCallback detacher;
         Signal signal;
         bool deleted;
      };

      boost::shared_ptr<Data> myData;
      mutable Signal mySignal;
      Connection myConnection;
   };

   DT_DLL_features std::ostream& operator<<(std::ostream&, const DtFeature::Attribute&);
   DT_DLL_features std::ostream& operator<<(std::ostream&, const DtFeature&);
   DT_DLL_features std::ostream& operator<<(std::ostream&, const DtFeature::Key&);
   DT_DLL_features std::ostream& operator<<(std::ostream&, const DtFeature::Key::String&);

}

DT_DEFINE_OBJECT_DEBUGGER_NAME(MAKVRinTerra::DtFeature);
DT_DEFINE_OBJECT_DEBUGGER_NAME_TEMPLATE2(MAKVRinTerra::DtFeatureWrapper);