Group.hpp

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

#ifndef FIRE_GROUP_HPP_INCLUDED
#define FIRE_GROUP_HPP_INCLUDED

#include <boost/iterator/filter_iterator.hpp>

#include <exception>
#include <set>
#include <cstddef>
#include <algorithm>
#include <vector>

#include "fire/Object.hpp"
#include "fire/Filter.hpp"
#include "fire/Predicate.hpp"
#include "fire/exception/Exception.hpp"

namespace fire {
template < class T >
class Group : public fire::Object {
 public:
  typedef typename std::set< T >::iterator iterator;
  typedef typename std::set< T >::const_iterator const_iterator;
  typedef typename std::set< T >::reverse_iterator reverse_iterator;
  typedef typename std::set< T >::const_reverse_iterator const_reverse_iterator;

 private:
  bool objectsIteratorInitialized;
  std::size_t index;
  iterator objectsIterator;
  fire::Predicate< T >* predicate;
  boost::filter_iterator< fire::Predicate< T >, iterator >* firstFilteredObject;
  boost::filter_iterator< fire::Predicate< T >, iterator >* lastFilteredObject;
  boost::filter_iterator< fire::Predicate< T >, iterator >* filteredObjectsIterator;

 protected:
  std::set< T > objects;

 public:
  Group() {
    try {
      this->objectsIteratorInitialized = false;
      this->predicate = NULL;
      this->firstFilteredObject = NULL;
      this->lastFilteredObject = NULL;
      this->filteredObjectsIterator = NULL;
    } catch (const std::exception& exception) {
      throw;
    }
  }
  virtual ~Group() {
    try {
      if (this->predicate != NULL) {
        delete this->predicate;
      }
      if (this->firstFilteredObject != NULL) {
        delete this->firstFilteredObject;
      }
      if (this->lastFilteredObject != NULL) {
        delete this->lastFilteredObject;
      }
      if (this->filteredObjectsIterator != NULL) {
        delete this->filteredObjectsIterator;
      }
    } catch (const std::exception& exception) {
      throw;
    }
  }
  virtual void include(T object) {
    try {
      this->objects.insert(object);
    } catch (const std::exception& exception) {
      throw;
    }
  }
  void include(const std::set< T >& objects) {
    try {
      for (typename std::set< T >::iterator objectsIterator = objects.begin() ; objectsIterator != objects.end() ; ++objectsIterator) {
        this->include(*objectsIterator);
      }
    } catch (const std::exception& exception) {
      throw;
    }
  }
  void include(const fire::Group< T >& group) {
    try {
      this->include(group.objects);
    } catch (const std::exception& exception) {
      throw;
    }
  }
  virtual void exclude(T object) {
    try {
      this->objects.erase(object);
    } catch (const std::exception& exception) {
      throw;
    }
  }
  void exclude(const std::set< T >& objects) {
    try {
      for (typename std::set< T >::iterator objectsIterator = objects.begin() ; objectsIterator != objects.end() ; ++objectsIterator) {
        this->exclude(*objectsIterator);
      }
    } catch (const std::exception& exception) {
      throw;
    }
  }
  void exclude(const fire::Group< T >& group) {
    try {
      this->exclude(group.objects);
    } catch (const std::exception& exception) {
      throw;
    }
  }
  virtual void clear() {
    try {
      this->objects.clear();
    } catch (const std::exception& exception) {
      throw;
    }
  }
  bool empty() const {
    bool value = false;
    try {
      value = this->objects.empty();
    } catch (const std::exception& exception) {
      throw;
    }
    return value;
  }
  std::size_t size() const {
    std::size_t value = 0;
    try {
      value = this->objects.size();
    } catch (const std::exception& exception) {
      throw;
    }
    return value;
  }
  virtual bool contains(T object) const {
    bool value = true;
    try {
      if (this->objects.count(object) == 0) {
        value = false;
      }
    } catch (const std::exception& exception) {
      throw;
    }
    return value;
  }
  bool contains(const std::set< T >& objects) const {
    bool value = true;
    try {
      for (typename std::set< T >::iterator objectsIterator = objects.begin() ; objectsIterator != objects.end() ; ++objectsIterator) {
        if (!this->contains(*objectsIterator)) {
          value = false;
        }
      }
    } catch (const std::exception& exception) {
      throw;
    }
    return value;
  }
  bool contains(const fire::Group< T >& group) const {
    bool value = true;
    try {
      if (!this->contains(group.objects)) {
        value = false;
      }
    } catch (const std::exception& exception) {
      throw;
    }
    return value;
  }
  virtual fire::Group< T > filter(const fire::Filter< T >& filter) const {
    fire::Group< T > value;
    try {
      std::auto_ptr< fire::Predicate< T > > predicate(new Predicate< T >(filter));
      boost::filter_iterator< fire::Predicate< T >, typename std::set< T >::iterator > firstObject(*predicate, this->objects.begin(), this->objects.end());
      boost::filter_iterator< fire::Predicate< T >, typename std::set< T >::iterator > lastObject(*predicate, this->objects.end(), this->objects.end());
      std::set< T > objects;
      std::copy(firstObject, lastObject, std::inserter(objects, objects.begin()));
      value.include(objects);
    } catch (const std::exception& exception) {
      throw;
    }
    return value;
  }
  fire::Group< T >& operator=(T object) {
    fire::Group< T >& value = *this;
    try {
      this->objects.clear();
      this->include(object);
    } catch (const std::exception& exception) {
      throw;
    }
    return value;
  }
  fire::Group< T >& operator=(const std::set< T >& objects) {
    fire::Group< T >& value = *this;
    try {
      this->objects.clear();
      this->include(objects);
    } catch (const std::exception& exception) {
      throw;
    }
    return value;
  }
  fire::Group< T >& operator=(const fire::Group< T >& group) {
    fire::Group< T >& value = *this;
    try {
      if (this != &group) {
        this->objects.clear();
        this->include(group);
      }
    } catch (const std::exception& exception) {
      throw;
    }
    return value;
  }
  fire::Group< T >& operator+=(const T& object) {
    fire::Group< T >& value = *this;
    try {
      this->include(object);
    } catch (const std::exception& exception) {
      throw;
    }
    return value;
  }
  fire::Group< T >& operator+=(const std::set< T >& objects) {
    fire::Group< T >& value = *this;
    try {
      this->include(objects);
    } catch (const std::exception& exception) {
      throw;
    }
    return value;
  }
  fire::Group< T >& operator+=(const fire::Group< T >& group) {
    fire::Group< T >& value = *this;
    try {
      this->include(group);
    } catch (const std::exception& exception) {
      throw;
    }
    return value;
  }
  fire::Group< T >& operator-=(const T& object) {
    fire::Group< T >& value = *this;
    try {
      this->exclude(object);
    } catch (const std::exception& exception) {
      throw;
    }
    return value;
  }
  fire::Group< T >& operator-=(const std::set< T >& objects) {
    fire::Group< T >& value = *this;
    try {
      this->exclude(objects);
    } catch (const std::exception& exception) {
      throw;
    }
    return value;
  }
  fire::Group< T >& operator-=(const fire::Group< T >& group) {
    fire::Group< T >& value = *this;
    try {
      this->exclude(group);
    } catch (const std::exception& exception) {
      throw;
    }
    return value;
  }
  fire::Group< T > operator+(const T& object) const {
    fire::Group< T > value;
    try {
      value = *this;
      value += object;
    } catch (const std::exception& exception) {
      throw;
    }
    return value;
  }
  fire::Group< T > operator+(const std::set< T >& objects) const {
    fire::Group< T > value;
    try {
      value = *this;
      value += objects;
    } catch (const std::exception& exception) {
      throw;
    }
    return value;
  }
  fire::Group< T > operator+(const fire::Group< T >& group) const {
    fire::Group< T > value;
    try {
      value = *this;
      value += group;
    } catch (const std::exception& exception) {
      throw;
    }
    return value;
  }
  fire::Group< T > operator-(const T& object) const {
    fire::Group< T > value;
    try {
      value = *this;
      value -= object;
    } catch (const std::exception& exception) {
      throw;
    }
    return value;
  }
  fire::Group< T > operator-(const std::set< T >& objects) const {
    fire::Group< T > value;
    try {
      value = *this;
      value -= objects;
    } catch (const std::exception& exception) {
      throw;
    }
    return value;
  }
  fire::Group< T > operator-(const fire::Group< T >& group) const {
    fire::Group< T > value;
    try {
      value = *this;
      value -= group;
    } catch (const std::exception& exception) {
      throw;
    }
    return value;
  }
  fire::Group< T > operator%(const fire::Filter< T >& filter) const {
    fire::Group< T > value;
    try {
      value = this->filter(filter);
    } catch (const std::exception& exception) {
      throw;
    }
    return value;
  }
  std::vector< T > toVector() const {
    std::vector< T > value;
    try {
      for (typename std::set< T >::iterator objectsIterator = this->objects.begin() ; objectsIterator != this->objects.end() ; ++objectsIterator) {
        value.push_back(*objectsIterator);
      }
    } catch (const std::exception& exception) {
      throw;
    }
    return value;
  }
  iterator begin() {
    iterator value;
    try {
      value = this->objects.begin();
    } catch (const std::exception& exception) {
      throw;
    }
    return value;
  }
  const_iterator begin() const {
    iterator value;
    try {
      value = this->objects.begin();
    } catch (const std::exception& exception) {
      throw;
    }
    return value;
  }
  iterator end() {
    iterator value;
    try {
      value = this->objects.end();
    } catch (const std::exception& exception) {
      throw;
    }
    return value;
  }
  const_iterator end() const {
    iterator value;
    try {
      value = this->objects.end();
    } catch (const std::exception& exception) {
      throw;
    }
    return value;
  }
  reverse_iterator rbegin() {
    reverse_iterator value;
    try {
      value = this->objects.rbegin();
    } catch (const std::exception& exception) {
      throw;
    }
    return value;
  }
  const_reverse_iterator rbegin() const {
    reverse_iterator value;
    try {
      value = this->objects.rbegin();
    } catch (const std::exception& exception) {
      throw;
    }
    return value;
  }
  reverse_iterator rend() {
    reverse_iterator value;
    try {
      value = this->objects.rend();
    } catch (const std::exception& exception) {
      throw;
    }
    return value;
  }
  const_reverse_iterator rend() const {
    reverse_iterator value;
    try {
      value = this->objects.rend();
    } catch (const std::exception& exception) {
      throw;
    }
    return value;
  }
  void setIteratorFilter(const fire::Filter< T >& filter) {
    try {
      this->predicate = new Predicate< T >(filter);
      this->firstFilteredObject = new boost::filter_iterator< fire::Predicate< T >, iterator >(*this->predicate, this->objects.begin(), this->objects.end());
      this->lastFilteredObject = new boost::filter_iterator< fire::Predicate< T >, iterator >(*this->predicate, this->objects.end(), this->objects.end());
      this->objectsIteratorInitialized = false;
    } catch (const std::exception& exception) {
      throw;
    }
  }
  void unsetIteratorFilter() {
    try {
      if (this->predicate != NULL) {
        delete this->predicate;
        this->predicate = NULL;
      }
      if (this->firstFilteredObject != NULL) {
        delete this->firstFilteredObject;
        this->firstFilteredObject = NULL;
      }
      if (this->lastFilteredObject != NULL) {
        delete this->lastFilteredObject;
        this->lastFilteredObject = NULL;
      }
      if (this->filteredObjectsIterator != NULL) {
        delete this->filteredObjectsIterator;
        this->filteredObjectsIterator = NULL;
      }
      this->objectsIteratorInitialized = false;
    } catch (const std::exception& exception) {
      throw;
    }
  }
  void rewind() {
    try {
      if ((this->firstFilteredObject != NULL) && (this->lastFilteredObject != NULL)) {
        this->filteredObjectsIterator = new boost::filter_iterator< fire::Predicate< T >, iterator >(*this->predicate, this->objects.begin(), this->objects.end());
      } else {
        this->objectsIterator = this->objects.begin();
      }
      this->objectsIteratorInitialized = true;
      this->index = -1;
    } catch (const std::exception& exception) {
      throw;
    }
  }
  T next() {
    T value;
    try {
      if (this->objectsIteratorInitialized == false) {
        this->rewind();
      }
      if (this->filteredObjectsIterator != NULL) {
        if (this->index == -1) {
          if (*this->filteredObjectsIterator != *this->lastFilteredObject) {
            value = **this->filteredObjectsIterator;
            ++this->index;
          } else {
            throw fire::exception::Exception("iterator is out of bounds");
          }
        } else {
          if (*this->filteredObjectsIterator != --*this->lastFilteredObject) {
            delete this->lastFilteredObject;
            this->lastFilteredObject = new boost::filter_iterator< fire::Predicate< T >, iterator >(*this->predicate, this->objects.end(), this->objects.end());
            ++*this->filteredObjectsIterator;
            value = **this->filteredObjectsIterator;
          } else {
            throw fire::exception::Exception("iterator is out of bounds");
          }
        }
      } else {
        if (this->index == -1) {
          if (this->objectsIterator != this->objects.end()) {
            value = *this->objectsIterator;
            ++this->index;
          } else {
            throw fire::exception::Exception("iterator is out of bounds");
          }
        } else {
          if (this->objectsIterator != --this->objects.end()) {
            ++this->objectsIterator;
            value = *this->objectsIterator;
            ++this->index;
          } else {
            throw fire::exception::Exception("iterator is out of bounds");
          }
        }
      }
    } catch (const std::exception& exception) {
      throw;
    }
    return value;
  }
  bool hasNext() {
    bool value = false;
    try {
      if (this->objectsIteratorInitialized == false) {
        this->rewind();
      }
      if (this->filteredObjectsIterator != NULL) {
        if (this->index == -1) {
          if (*this->filteredObjectsIterator != *this->lastFilteredObject) {
            value = true;
          }
        } else {
          if (*this->filteredObjectsIterator != --*this->lastFilteredObject) {
            delete this->lastFilteredObject;
            this->lastFilteredObject = new boost::filter_iterator< fire::Predicate< T >, iterator >(*this->predicate, this->objects.end(), this->objects.end());
            value = true;
          }
        }
      } else {
        if (this->index == -1) {
          if (this->objectsIterator != this->objects.end()) {
            value = true;
          }
        } else {
          if (this->objectsIterator != --this->objects.end()) {
            value = true;
          }
        }
      }
    } catch (const std::exception& exception) {
      throw;
    }
    return value;
  }
  void forward() {
    try {
      if ((this->firstFilteredObject != NULL) && (this->lastFilteredObject != NULL)) {
        this->filteredObjectsIterator = new boost::filter_iterator< fire::Predicate< T >, iterator >(*this->predicate, this->objects.end(), this->objects.end());
      } else {
        this->objectsIterator = this->objects.end();
      }
      this->objectsIteratorInitialized = true;
    } catch (const std::exception& exception) {
      throw;
    }
  }
  T previous() {
    T value;
    try {
      if (this->objectsIteratorInitialized == false) {
        this->forward();
      }
      if (this->filteredObjectsIterator != NULL) {
        if (*this->filteredObjectsIterator != *this->firstFilteredObject) {
          --*this->filteredObjectsIterator;
          value = **this->filteredObjectsIterator;
        } else {
          throw fire::exception::Exception("iterator is out of bounds");
        }
      } else {
        if (this->objectsIterator != this->objects.begin()) {
          --this->objectsIterator;
          value = *this->objectsIterator;
        } else {
          throw fire::exception::Exception("iterator is out of bounds");
        }
      }
    } catch (const std::exception& exception) {
      throw;
    }
    return value;
  }
  bool hasPrevious() {
    bool value = false;
    try {
      if (this->objectsIteratorInitialized == false) {
        this->forward();
      }
      if (this->filteredObjectsIterator != NULL) {
        if (*this->filteredObjectsIterator != *this->firstFilteredObject) {
          value = true;
        }
      } else {
        if (this->objectsIterator != this->objects.begin()) {
          value = true;
        }
      }
    } catch (const std::exception& exception) {
      throw;
    }
    return value;
  }
};
}  // namespace fire

#endif