Filter.hpp

// Copyright 2015 GEOSYSTEMS SRL
// All Rights Reserved.

#ifndef FIRE_FILTER_HPP_INCLUDED
#define FIRE_FILTER_HPP_INCLUDED

#include <exception>

#include "fire/Object.hpp"
#include "fire/LogicOperator.hpp"

namespace fire {
template < class T >
class Filter : public fire::Object {
 private:
  fire::LogicOperator::LogicOperator logicOperator;
  fire::Filter< T >* leftFilter;
  fire::Filter< T >* rightFilter;

 public:
  Filter() {
    try {
      this->logicOperator = fire::LogicOperator::None;
      this->leftFilter = NULL;
      this->rightFilter = NULL;
    } catch (const std::exception& exception) {
      throw;
    }
  }
  virtual ~Filter() {
    try {
    } catch (const std::exception& exception) {
      throw;
    }
  }
  virtual bool condition(T object) {
    bool value = false;
    try {
      value = true;
    } catch (const std::exception& exception) {
      throw;
    }
    return value;
  }
  bool expression(T object) {
    bool value = false;
    try {
      value = this->condition(object);
      switch (this->logicOperator) {
        case fire::LogicOperator::None: {
          break;
        }
        case fire::LogicOperator::Not: {
          value = !this->leftFilter->expression(object);
          break;
        }
        case fire::LogicOperator::And: {
          value = this->leftFilter->expression(object) && this->rightFilter->expression(object);
          break;
        }
        case fire::LogicOperator::Or: {
          value = this->leftFilter->expression(object) || this->rightFilter->expression(object);
          break;
        }
      }
    } catch (const std::exception& exception) {
      throw;
    }
    return value;
  }
  fire::Filter< T > NOT() {
    fire::Filter< T > value;
    try {
      value.logicOperator = fire::LogicOperator::Not;
      value.leftFilter = this;
    } catch (const std::exception& exception) {
      throw;
    }
    return value;
  }
  fire::Filter< T > AND(fire::Filter< T >& filter) {
    fire::Filter< T > value;
    try {
      value.logicOperator = fire::LogicOperator::And;
      value.leftFilter = this;
      value.rightFilter = &filter;
    } catch (const std::exception& exception) {
      throw;
    }
    return value;
  }
  fire::Filter< T > OR(fire::Filter< T >& filter) {
    fire::Filter< T > value;
    try {
      value.logicOperator = fire::LogicOperator::Or;
      value.leftFilter = this;
      value.rightFilter = &filter;
    } catch (const std::exception& exception) {
      throw;
    }
    return value;
  }
  fire::Filter< T > operator!() {
    fire::Filter< T > value;
    try {
      value = this->NOT();
    } catch (const std::exception& exception) {
      throw;
    }
    return value;
  }
  fire::Filter< T > operator&&(fire::Filter< T >& filter) {
    fire::Filter< T > value;
    try {
      value = this->AND(filter);
    } catch (const std::exception& exception) {
      throw;
    }
    return value;
  }
  fire::Filter< T > operator||(fire::Filter< T >& filter) {
    fire::Filter< T > value;
    try {
      value = this->OR(filter);
    } catch (const std::exception& exception) {
      throw;
    }
    return value;
  }
};
}  // namespace fire

#endif