attributeConfigParser.h

Go to the documentation of this file.

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


#pragma once

#include <iosfwd>
#include <features/feature.h>
#include <features/query.h>
#include <features/featuresDefines.h>

#include <vlutil/vlExceptions.h>

#include <boost/ptr_container/ptr_map.hpp>
#include <tbb/recursive_mutex.h>

namespace MAKVRinTerra
{
   class DtAttributeConfigParser;

   struct DT_DLL_features DtFeatureTransform
   {
      enum AttributeType
      {
         StringAttr,
         IntAttr,
         DoubleAttr
      };

      static AttributeType stringToType(const std::string& str);

      boost::optional<DtFeature::Attribute> evaluate() const;

      boost::optional<DtFeature::Attribute> evaluate(const DtFeature& feature) const;

      void print(std::ostream&) const;

      std::string myQueryName;
      AttributeType myAttributeType;
      DtFeature::Key::String myAttributeName;
      std::string myExpression;
   };

   std::ostream& operator<<(std::ostream&, const DtFeatureTransform&);

   class DT_DLL_features DtAttributeConfigParser
   {
   public:
      typedef std::map<std::string, DtQuery>    DtQueryMap;
      typedef std::vector<DtFeatureTransform>   TransformVector;

      DtAttributeConfigParser();
      virtual ~DtAttributeConfigParser();

      virtual bool readAttributeConfig(const std::string& filename, const DtQuery& schema= DtQuery());

      virtual DtQueryMap queryMap() const;

      virtual DtQuery findQuery(std::string) const;

      virtual TransformVector transforms() const;

      virtual void print(std::ostream&) const;

      virtual std::string pprintQueries() const;
      virtual std::string pprintTransforms() const;

      virtual void resolveNamedQueries();

      class DtParseException : public DtException
      {
      public:
         DtParseException(const char *errorMessage, 
            const DtException *previousException = 0) throw() 
            : DtException(errorMessage, previousException) {};

         virtual ~DtParseException() throw() {};
      };

      class DtNamedQueryException : public DtParseException
      {
      public:
         DtNamedQueryException(std::string missingQueryName,
            bool existsUnresolved, const DtException* previousException = 0) throw()
            : DtParseException("Missing Query", previousException)
            , queryName(missingQueryName)
            , queryExistsUnresolved(existsUnresolved)
         {
            
         };

         virtual ~DtNamedQueryException() throw() {};

         std::string queryName;
         //true if the missing query is simply not yet resolved, false if
         //the missing query is actually non-existent in all the feature configuration.
         bool queryExistsUnresolved; 
      };

      virtual DtQuery buildQuery(const std::vector<std::string>& queryToks);

      virtual DtQuery buildQueryNoThrow(std::string line);

   protected:
      struct UnresolvedQuery
      {
         std::string name;
         std::vector<std::string> tokens;
         DtQuery schema;
      };

      typedef std::list<UnresolvedQuery> UnresolvedQueryList;

      virtual std::vector<std::string> extractQuery(std::vector<std::string>::iterator& itr,
         const std::vector<std::string>& tokList);

      virtual DtQuery buildQueryAndBlock(const std::vector<std::string>& queryToks,
         std::vector<std::string>::const_iterator& itr);

      virtual DtQuery buildFirstQuery(const std::vector<std::string>& queryToks,
         std::vector<std::string>::const_iterator& itr);

      virtual DtQuery queryInsideParen(const std::vector<std::string>& parenToks,
         std::vector<std::string>::const_iterator& itr);

   protected:
      typedef tbb::recursive_mutex Mutex;
      mutable Mutex myMutex;
             
      UnresolvedQueryList myUnresolvedQueries;

      //Map of named queries, defined in config file
      DtQueryMap myQueryMap;

      bool myResolvedFlag;

      TransformVector myTransforms;

      std::set<std::string> theQueryJoinTokens;
   };

   std::ostream& operator<<(std::ostream&, const DtAttributeConfigParser&);
}