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 <set>

#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 const& m): points_(m.points_), dimension_(m.dimension_) {
    }
    ~Myself() {
    }
  };

  Self<Myself> const self;
public:
  IdentityPoints(): self() {
  }

  IdentityPoints(IdentityPoints const& b):
  self(b.self, Self<Myself>::COPY_FROM) {
  }

  ~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 {
    if (bin) {
      long dim, ct;
      if (fwrite(&(dim = dimension()), sizeof(dim), 1, f) < 1) return false;
      if (fwrite(&(ct = size()), sizeof(ct), 1, f) < 1) return false;
      for (IdentityPointsMapIterK
           it = identityPoints().begin(), ed = identityPoints().end();
           it != ed; ++it) {
        double tmp;
        if (fwrite(&(tmp = it->first), sizeof(tmp), 1, f) < 1) return false;
        for (long i = 0; i < dim; ++i) {
          if (fwrite(&(tmp = it->second(i)), sizeof(tmp), 1, f) < 1)
            return false;
        }
      }
    }
    else {
      if (fprintf(f, "%ld %lu\n", dimension(), size()) < 1) return false;
      for (IdentityPointsMapIterK
           it = identityPoints().begin(), ed = identityPoints().end();
           it != ed; ++it) {
        if (fprintf(f, "%f   ", (double)it->first) < 1) return false;
        for (long i = 0, I = dimension(); i < I; ++i) {
          if (fprintf(f, "%f ", (double)it->second(i)) < 1) return false;
        }
        fprintf(f, "\n");
      }
    }
    return true;
  }

  bool read(FILE* f, bool bin, unsigned int fg) {
    long dim, ct;
    if (bin) {
      if (fread(&dim, sizeof(dim), 1, f) < 1) return false;
      dimension(dim);
      if (fread(&ct, sizeof(ct), 1, f) < 1) return false;
      double id, tt;
      Vector<Scalar> tmp(dim, 0);
      for (int i = 0; i < ct; ++i) {
        if (fread(&id, sizeof(id), 1, f) < 1) return false;
        for (size_t j = 0, J = dim; j < J; ++j) {
          if (fread(&tt, sizeof(tt), 1, f) < 1) return false;
          tmp.entry(j, tt);
        }
        identityPointAdd((ID)id, tmp);
      }
    }
    else {
      if (fscanf(f, "%ld %ld", &dim, &ct) < 2) return false;
      dimension(dim);
      double id, tt;
      Vector<Scalar> tmp(dim, 0);
      for (int i = 0; i < ct; ++i) {
        if (fscanf(f, "%lf", &id) < 1) return false;
        for (int j = 0, J = dim; j < J; ++j) {
          if (fscanf(f, "%lf", &tt) < 1) return false;
          tmp.entry(j, tt);
        }
        identityPointAdd((ID)id, tmp);
      }
    }
    return true;
  }

  ObjBase* create() const {
    return new IdentityPoints();
  }

  ObjBase* copyFrom(ObjBase const* b) {
    return &(copyFrom(*(IdentityPoints*)b));
  }

  char const* ctype() const {
    return typeid(*this).name();
  }

  std::string type() const {
    return std::string(ctype());
  }
};

}

#endif // gra_IdentityPoints_H__