IdentityPoints.h

Go to the documentation of this file.

#ifndef   gra_IdentityPoints_H__
#define   gra_IdentityPoints_H__

#include "../Self.h"

#include "../math/Vector.h"

#include "../oo/ObjBase.h"

#include <map>

#include <cstdlib>

namespace meow {

template<class ID, class Scalar>
class IdentityPoints: public ObjBase {
public:
  typedef typename std::map<ID, Vector<Scalar> >     IdentityPointsMap;
  typedef typename IdentityPointsMap::      iterator IdentityPointsMapIter;
  typedef typename IdentityPointsMap::const_iterator IdentityPointsMapIterK;
  
private:
  struct Myself {
    IdentityPointsMap    points_;
    size_t            dimension_;
    
    Myself() {
      dimension_ = 1;
    }
    ~Myself() {
    }
    Myself& copyFrom(Myself const& b) {
      points_    = b.points_;
      dimension_ = b.dimension_;
      return *this;
    }
  };
  
  Self<Myself> const self;
public:
  IdentityPoints(): self(true) {
  }
  
  IdentityPoints(IdentityPoints const& b): self(false) {
    copyFrom(b);
  }
  
  ~IdentityPoints() {
  }
  
  IdentityPoints& copyFrom(IdentityPoints const& b) {
    self().copyFrom(b.self);
    return *this;
  }
  
  IdentityPoints& referenceFrom(IdentityPoints const& b) {
    self().referenceFrom(b.self);
    return *this;
  }
  
  void clear() {
    self()->points_.clear();
  }
  
  size_t size() const {
    return self->points_.size();
  }
  
  bool empty() const {
    return (size() == 0u);
  }
  
  bool exist(ID const& id) const {
    return (self->points_.find(id) != self->points_.end());
  }
  
  size_t dimension() const {
    return self->dimension_;
  }
  
  size_t dimension(size_t dim) {
    self()->dimension_ = dim;
    clear();
    return dimension();
  }
  
  size_t dimension(size_t dim, Scalar const& init_value) {
    self()->dimension_ = dim;
    for (IdentityPointsMapIter
         it = self()->points_.begin(); it != self()->points_.end(); ++it) {
      it.second.dimension(dim, init_value);
    }
    return dimension();
  }
  
  IdentityPointsMap const& identityPoints() const {
    return self->points_;
  }
  
  IdentityPointsMap const& identityPoints(IdentityPointsMap const& points) {
    clear();
    return identityPointsAdd(points);
  }
  
  IdentityPointsMap const& identityPointsAdd(IdentityPointsMap const& points) {
    for (IdentityPointsMapIterK it = points.begin(); it != points.end(); ++it) {
      identityPointAdd(it.first, it.second);
    }
    return identityPoints();
  }
  
  IdentityPointsMap const& identityPointsDel(std::set<ID> const& ids) {
    for (typename std::set<ID>::const_iterator
         it = ids.begin(); it != ids.end(); ++it) {
      identityPointDel(*it);
    }
    return identityPoints();
  }
  
  Vector<Scalar> identityPoint(ID const& id) const {
    return (exist(id) ? self->points_.find(id)->second : Vector<Scalar>());
  }
  
  Vector<Scalar> identityPoint(ID const& id, Vector<Scalar> const& b) {
    if (b.dimension() == self->dimension_ && exist(id)) {
      self()->points_[id].copyFrom(b);
    }
    return identityPoint(id);
  }
  
  Vector<Scalar> identityPointAdd(ID const& id, Vector<Scalar> const& b) {
    if (b.dimension() == self->dimension_ && !exist(id)) {
      self()->points_[id].copyFrom(b);
    }
    return identityPoint(id);
  }
  
  void identityPointDel(ID const& id) {
    self()->points_.erase(id);
  }
  
  Vector<Scalar>& identityPointGet(ID const& id) {
    return self()->points_[id];
  }
  
  IdentityPoints& operator=(IdentityPoints const& b) {
    return copyFrom(b);
  }
  
  bool write(FILE* f, bool bin, unsigned int fg) const {
    return false;
  }
  
  bool read(FILE* f, bool bin, unsigned int fg) {
    return false;
  }

  ObjBase* create() const {
    return new IdentityPoints();
  }
  
  ObjBase* copyFrom(ObjBase const* b) {
    return &(copyFrom(*(IdentityPoints*)b));
  }
  
  char const* ctype() const{
    static char const* ptr = typeid(*this).name();
    return ptr;
  }
  
  std::string type() const {
    return std::string(ctype());
  }
};

}

#endif // gra_IdentityPoints_H__