query.h

Go to the documentation of this file.

#pragma once

#include <features/feature.h>

#include <boost/scoped_ptr.hpp>
#include <boost/logic/tribool.hpp>

#include <iosfwd>

namespace MAKVRinTerra
{
   class DtTrueQuery;
   class DtFalseQuery;
   class DtAndQuery;
   class DtOrQuery;

   class DT_DLL_features DtQuery
   {
   public:
      enum Type
      {
         EOther,
         ETrue,
         EFalse,
         EAnd,
         EOr
      };

      typedef DtTrueQuery  True;
      typedef DtFalseQuery False;
      typedef DtAndQuery   And;
      typedef DtOrQuery    Or;

      static void SetDebugOutput(std::ostream&);
      static void DisableDebugOutput();

      template <typename Result = void>
      class Visitor;

      class DT_DLL_features Implementation
         : public boost::enable_shared_from_this<Implementation>
         , private boost::noncopyable
      {
      public:
         typedef boost::shared_ptr<Implementation>       Ptr;
         typedef boost::shared_ptr<const Implementation> CPtr;

         typedef DtQuery::Type Type;

         virtual ~Implementation();

         virtual Type type() const;

         virtual bool matches(const DtFeature&) const = 0;

         virtual void print(std::ostream&) const = 0;
         virtual void pprint(std::ostream&, unsigned indent) const;
      };

      DtQuery();
      DtQuery(bool val);
      DtQuery(const Implementation& i) : myImpl(i.shared_from_this()) { }
      DtQuery(Implementation* i) : myImpl(i) { }
      DtQuery(Implementation::CPtr p) : myImpl(p) { }

      DtQuery& operator=(const DtQuery& q)
      {
         myImpl = q.myImpl;
         return *this;
      }

      const Implementation& impl() const
      {
         return *myImpl;
      }

      template <typename T>
      const T& cast() const
      {
         return *boost::polymorphic_downcast<const T*>(myImpl.get());
      }

      template <typename T>
      const T* trycast() const
      {
         return dynamic_cast<const T*>(myImpl.get());
      }

      Type type() const { return myImpl->type(); }

      bool isTrue() const { return type() == ETrue; }
      bool isFalse() const { return type() == EFalse; }

      bool matches(const DtFeature& feature) const { return myImpl->matches(feature); }

      boost::optional<DtQuery> remove(boost::function<bool (const DtQuery&)>) const;

      boost::optional<DtFeatureGeometry> findEnclosingGeometry() const;

      void print(std::ostream& stream) const { myImpl->print(stream); }
      
      void pprint(std::ostream& stream, unsigned indent = 0) const { myImpl->pprint(stream,indent); }
      std::string pprint(unsigned indent = 0) const;

   protected:
      Implementation::CPtr myImpl;
   };

   DT_DLL_features DtQuery operator|| (const DtQuery&, const DtQuery&);
   DT_DLL_features DtQuery operator&& (const DtQuery&, const DtQuery&);

   DT_DLL_features std::ostream& operator<< (std::ostream&, const DtQuery&);

   template <typename Result>
   class DT_DLL_features DtQuery::Visitor
   {
   public:
      virtual ~Visitor() { }

      virtual Result apply(const DtQuery& query)
      {
         switch (query.type())
         {
            case ETrue:    return visit(query.cast<True>());
            case EFalse:   return visit(query.cast<False>());
            case EAnd:     return visit(query.cast<And>());
            case EOr:      return visit(query.cast<Or>());
            case EOther:   return visit(query);

            default:
               assert(false);
               DtTHROW_NEW(DtException, "logic error");
         }
      }

      virtual Result visit(const DtQuery&) = 0;
      virtual Result visit(const True&) = 0;
      virtual Result visit(const False&) = 0;
      virtual Result visit(const And&) = 0;
      virtual Result visit(const Or&) = 0;
   };

   template <>
   class DT_DLL_features DtQuery::Visitor<DtQuery>
   {
   public:
      virtual ~Visitor();

      virtual DtQuery apply(const DtQuery&);

      virtual DtQuery visit(const DtQuery&) = 0;
      virtual DtQuery visit(const True&);
      virtual DtQuery visit(const False&);
      virtual DtQuery visit(const And&);
      virtual DtQuery visit(const Or&);
   };

   template <>
   class DT_DLL_features DtQuery::Visitor<void>
   {
   public:
      virtual ~Visitor();

      virtual void apply(const DtQuery&);

      virtual void visit(const DtQuery&) = 0;
      virtual void visit(const True&);
      virtual void visit(const False&);
      virtual void visit(const And&);
      virtual void visit(const Or&);
   };

   class DT_DLL_features DtTrueQuery : public DtQuery::Implementation
   {
   public:
      static DtQuery Create();

      Type type() const;
      bool matches(const DtFeature& feature) const;
      void print(std::ostream&) const;
   };

   class DT_DLL_features DtFalseQuery : public DtQuery::Implementation
   {
   public:
      static DtQuery Create();

      Type type() const;
      bool matches(const DtFeature& feature) const;
      void print(std::ostream&) const;
   };

   class DT_DLL_features DtAndQuery : public DtQuery::Implementation
   {
   public:
      friend class DtQuery;

      static DtQuery Create(const DtQuery&, const DtQuery&);

      Type type() const;
      bool matches(const DtFeature& feature) const;
      void print(std::ostream&) const;
      void pprint(std::ostream&, unsigned indent) const;

      const DtQuery& left() const;
      const DtQuery& right() const;

   protected:
      DtAndQuery(const DtQuery& left, const DtQuery& right);

   private:
      DtQuery myLeftQuery;
      DtQuery myRightQuery;
   };

   class DT_DLL_features DtOrQuery : public DtQuery::Implementation
   {
   public:
      friend class DtQuery;

      static DtQuery Create(const DtQuery&, const DtQuery&);

      Type type() const;
      bool matches(const DtFeature& feature) const;
      void print(std::ostream&) const;
      void pprint(std::ostream&, unsigned indent) const;

      const DtQuery& left() const;
      const DtQuery& right() const;

   protected:
      DtOrQuery(const DtQuery& left, const DtQuery& right);

   private:
      DtQuery myLeftQuery;
      DtQuery myRightQuery;
   };

   class DT_DLL_features DtGeometryIntersects : public DtQuery::Implementation
   {
   public:
      static DtQuery Create(DtFeatureGeometry);

      bool matches(const DtFeature&) const;
      void print(std::ostream&) const;

      DtFeatureGeometry geometry() const;

   protected:
      explicit DtGeometryIntersects(DtFeatureGeometry geometry);

   private:
      DtFeatureGeometry myGeometry;
   };

   class DT_DLL_features DtHasGeometry : public DtQuery::Implementation
   {
   public:
      static DtQuery Create(DtFeatureGeometry::Type);

      bool matches(const DtFeature&) const;
      void print(std::ostream&) const;

      DtFeatureGeometry::Type geometryType() const;
      
   protected:
      explicit DtHasGeometry(DtFeatureGeometry::Type);

   private:
      DtFeatureGeometry::Type myType;
   };

   class DT_DLL_features DtHasAttribute : public DtQuery::Implementation
   {
   public:
      static DtQuery Create(DtFeature::Key);
      static DtQuery Create(std::string);
      static DtQuery Create(const char*);

      bool matches(const DtFeature&) const;
      void print(std::ostream&) const;

      const DtFeature::Key& key() const;

   protected:
      explicit DtHasAttribute(const DtFeature::Key&);

   private:
      DtFeature::Key myKey;
   };

   class DT_DLL_features DtHasAttributeValue : public DtHasAttribute
   {
      typedef DtHasAttribute Base;

   public:
      enum Comparison
      {
         Equals,
         Less,
         LessEqual,
         Greater,
         GreaterEqual
      };

      static DtQuery Create(DtFeature::Key, DtFeature::Attribute, Comparison);
      static DtQuery Create(std::string, DtFeature::Attribute, Comparison);
      static DtQuery Create(const char*, DtFeature::Attribute, Comparison);

      bool matches(const DtFeature& feature) const;
      void print(std::ostream& stream) const;

      const DtFeature::Attribute& value() const;
      Comparison comparison() const;

   protected:
      explicit DtHasAttributeValue(DtFeature::Key key, DtFeature::Attribute, Comparison);

   private:
      DtFeature::Attribute myValue;
      Comparison myComparison;
   };
}