feature.h

Go to the documentation of this file.

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

#pragma once

#include <features/featuresDefines.h>

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

#include <features/featureGeometry.h>

namespace MAKVRinTerra
{
   class DT_DLL_features DtFeature : private boost::noncopyable
   {
   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;

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

            const char* c_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;
      };

      typedef boost::function<void (const Key&, const Attribute&)> ForEachFunction;
      
      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 std::string TypeOfAttribute(const Attribute&);

      static CPtr GetPtr(const DtFeature&);

      static Ptr CreateEmptyFeature();

      static Ptr CreateGeometryFeature(DtFeatureGeometry);

      static Ptr CreateGeometryFeature(
         DtFeatureGeometry, unsigned char red, unsigned char green, unsigned char blue);

      static Ptr CreateCopy(const DtFeature& feature);

      virtual ~DtFeature();

      virtual CPtr getPtr() const;

      virtual DtFeatureGeometry geometry() const = 0;

      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::optional<T>();
      }

      template <typename Feature>
      class Wrapper;

   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>
   class DtFeatureWrapper : public Feature
   {
   public:
      typedef typename Feature::ForEachFunction ForEachFunction;
      typedef typename Feature::Attribute       Attribute;
      typedef typename Feature::Key             Key;

      typename Feature::CPtr getPtr() const { return typename Feature::Ptr(clone()); }

      DtFeatureGeometry geometry() const { return myWrappedFeature->geometry(); }

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

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

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

   protected:
      explicit DtFeatureWrapper(const Feature& f)
         : myWrappedFeature(Feature::GetPtr(f)) { }

      explicit DtFeatureWrapper(typename Feature::CPtr f)
         : myWrappedFeature(f) { }

      virtual DtFeatureWrapper* clone() const = 0;

      typename Feature::CPtr myWrappedFeature;
   };

   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&);

}