store.cc

   1 #include <store.h>
   2 #include <reader.h>
   3
   4 #include <iostream>
   5
   6
   7 namespace odc {
   8
   9 template<class T, class A> T join(const A & begin, const A & end, const T &sep) {
  10         T result;
  11
  12         if (begin != end) {
  13                 A it = begin;
  14                 result.append(*it);
  15                 for (++it; it != end; ++it) {
  16                         result.append(sep).append(*it);
  17                 }
  18         }
  19
  20         return result;
  21 }
  22
  23 std::string TypePath::toString() const {
  24         return join(begin(), end(), std::string("->"));
  25 }
  26
  27 const std::string Store::TYPENAME("Stores.Store^");
  28 const TypeProxy<Store> Store::PROXY;
  29
  30 Store::Store(INTEGER id): d_id(id) {}
  31
  32 INTEGER Store::getId() {
  33         return d_id;
  34 }
  35
  36 const std::string &Store::getType() {
  37         return Store::TYPENAME;
  38 }
  39
  40 const std::string *Store::getSuper() {
  41         return 0;
  42 }
  43
  44 const std::string &Store::getTypeName() const {
  45         return Store::getType();
  46 }
  47
  48 void Store::getTypePath(TypePath *out) const {
  49         return calcTypePath(out, getTypeName());
  50 }
  51
  52 void Store::calcTypePath(TypePath *path, const std::string &name) const {
  53         const std::string *super = TypeRegister::getInstance().get(name)->getSuper();
  54         if (super != 0) {
  55                 calcTypePath(path, *super);
  56         }
  57         path->push_back(name);
  58 }
  59
  60 void Store::internalize(Reader &reader) {
  61         reader.readVersion(0, 0);
  62 }
  63
  64 std::string Store::toString() {
  65         return getTypeName();
  66 }
  67
  68 std::string Store::toPlainText() {
  69         return std::string();
  70 }
  71
  72 const std::string Elem::TYPENAME("Stores.Elem^");
  73 const TypeProxy<Elem> Elem::PROXY;
  74
  75 Elem::Elem(INTEGER id) : Store(id) {}
  76
  77 const std::string &Elem::getType() {
  78         return TYPENAME;
  79 }
  80
  81 const std::string *Elem::getSuper() {
  82         return &Store::getType();
  83 }
  84
  85 const std::string &Elem::getTypeName() const {
  86         return getType();
  87 }
  88
  89 void Elem::internalize(Reader &reader) {
  90         Store::internalize(reader);
  91         if (reader.isCancelled()) return;
  92         reader.readVersion(0, 0);
  93 }
  94
  95 const std::string Model::TYPENAME("Models.Model^");
  96 const TypeProxy<Model> Model::PROXY;
  97
  98 Model::Model(INTEGER id) : Elem(id) {}
  99
 100 const std::string &Model::getType() {
 101         return TYPENAME;
 102 }
 103
 104 const std::string *Model::getSuper() {
 105         return &Elem::getType();
 106 }
 107
 108 const std::string &Model::getTypeName() const {
 109         return getType();
 110 }
 111
 112 void Model::internalize(Reader &reader) {
 113         Elem::internalize(reader);
 114         if (reader.isCancelled()) return;
 115         reader.readVersion(0, 0);
 116 }
 117
 118 const std::string ContainerModel::TYPENAME("Containers.Model^");
 119 const TypeProxy<ContainerModel> ContainerModel::PROXY;
 120
 121 ContainerModel::ContainerModel(INTEGER id) : Model(id) {}
 122
 123 const std::string &ContainerModel::getType() {
 124         return TYPENAME;
 125 }
 126
 127 const std::string *ContainerModel::getSuper() {
 128         return &Model::getType();
 129 }
 130
 131 const std::string &ContainerModel::getTypeName() const {
 132         return getType();
 133 }
 134
 135 void ContainerModel::internalize(Reader &reader) {
 136         Model::internalize(reader);
 137         if (reader.isCancelled()) return;
 138         reader.readVersion(0, 0);
 139 }
 140
 141 } // namespace odc