ExpressionTree.h

Go to the documentation of this file.

/* -*- C++ -*- */
 
#ifndef _MADARA_KNOWLEDGE_EXPRESSION_TREE_H_
#define _MADARA_KNOWLEDGE_EXPRESSION_TREE_H_
 
#ifndef _MADARA_NO_KARL_
 
#include <string>
#include <stdexcept>
#include "madara/utility/Refcounter.h"
 
#include "madara/logger/GlobalLogger.h"
#include "madara/expression/ComponentNode.h"
#include "madara/knowledge/KnowledgeRecord.h"
 
namespace madara
{
namespace expression
{
// Forward declarations.
class ExpressionTreeIterator;
class ExpressionTreeConstIterator;
 
class ExpressionTree
{
public:
  // Define a "trait"
  typedef madara::knowledge::KnowledgeRecord value_type;
  typedef ExpressionTreeIterator iterator;
  typedef ExpressionTreeConstIterator const_iterator;
 
  ExpressionTree(logger::Logger& logger = *logger::global_logger.get());
 
  ExpressionTree(
      logger::Logger& logger, ComponentNode* root, bool increase_count = false);
 
  ExpressionTree(logger::Logger& logger, const ExpressionTree& tree);
 
  ExpressionTree(const ExpressionTree& tree);
 
  ~ExpressionTree(void);
 
  ComponentNode* get_root(void);
 
  void operator=(const ExpressionTree& tree);
 
  bool is_null(void) const;
 
  madara::knowledge::KnowledgeRecord item(void) const;
 
  madara::knowledge::KnowledgeRecord prune(void);
 
  madara::knowledge::KnowledgeRecord evaluate(
      const madara::knowledge::KnowledgeUpdateSettings& settings =
          knowledge::KnowledgeUpdateSettings());
 
  ExpressionTree left(void);
 
  ExpressionTree right(void);
 
  iterator begin(const std::string& traversal_order);
 
  iterator end(const std::string& traversal_order);
 
  const_iterator begin(const std::string& traversal_order) const;
 
  const_iterator end(const std::string& traversal_order) const;
 
  void accept(Visitor& visitor) const;
 
private:
  logger::Logger* logger_;
 
  madara::utility::Refcounter<ComponentNode> root_;
};
}
}
 
#endif  // _MADARA_NO_KARL_
 
#endif /* _MADARA_KNOWLEDGE_EXPRESSION_TREE_H_ */