textmodel/textmodel.cc

   1 #include "textmodel/module.ih"
   2
   3 namespace odc {
   4
   5 const std::string TextModel::TYPENAME("TextModels.Model^");
   6 const TypeProxy<TextModel, ContainerModel> TextModel::PROXY;
   7
   8 TextModel::TextModel(INTEGER id) : ContainerModel(id) {}
   9
  10 const std::string &TextModel::getTypeName() const {
  11         return TYPENAME;
  12 }
  13
  14 void TextModel::internalize(Reader &reader) {
  15         ContainerModel::internalize(reader);
  16         if (reader.isCancelled()) return;
  17         reader.readVersion(0, 0);
  18 }
  19
  20 const std::string StdTextModel::TYPENAME("TextModels.StdModel^");
  21 const TypeProxy<StdTextModel, TextModel> StdTextModel::PROXY;
  22
  23 StdTextModel::StdTextModel(INTEGER id) : TextModel(id), d_pieces() {}
  24
  25 const std::string &StdTextModel::getTypeName() const {
  26         return TYPENAME;
  27 }
  28
  29 /*
  30  * This is my current theory of how the StdTextModel storage format works:
  31  * byte 0: version
  32  * byte 1-5: len (length of piece descriptions)
  33  * byte 6-5+len: piece descriptions
  34  * byte 6+len-end: pieces (length of each defined in piece descriptions)
  35  */
  36 void StdTextModel::internalize(Reader &reader) {
  37         TextModel::internalize(reader);
  38         if (reader.isCancelled()) return;
  39         reader.readVersion(0, 1);
  40         if (reader.isCancelled()) return;
  41
  42         std::vector<Store *> dict; // attribute dictionary
  43
  44         // reads the meta-data
  45         INTEGER len = reader.readInt(); // lenght of meta-data section
  46         BYTE ano = reader.readByte();
  47         while (ano != -1) {
  48                 // This part reads the piece's attributes. These are ignored for now,
  49                 // but may be needed in the future.
  50                 if (ano == dict.size()) {
  51                         dict.push_back(reader.readStore());
  52                 }
  53                 Store *attr = dict[ano];
  54
  55                 INTEGER pieceLen = reader.readInt();
  56                 if (pieceLen > 0) { // shortchar piece
  57                         d_pieces.push_back(new ShortPiece(pieceLen));
  58                 } else if (pieceLen < 0) { // longchar piece
  59                         assert(pieceLen % 2 == 0);
  60                         d_pieces.push_back(new LongPiece(-pieceLen / 2));
  61                 } else { // embedded view
  62                         reader.readInt(); reader.readInt(); // view width + height: ignore
  63                         Store *view = reader.readStore();
  64                         d_pieces.push_back(new ViewPiece(view));
  65                 }
  66                 ano = reader.readByte();
  67         }
  68
  69         // reads the pieces described in the meta-data
  70         for (int i = 0; i < d_pieces.size(); ++i) {
  71                 d_pieces[i]->read(reader);
  72         }
  73
  74         // free memory from stores in the dictionary
  75         for (int i = 0; i < dict.size(); ++i) {
  76                 delete dict[i];
  77         }
  78 }
  79
  80 std::string StdTextModel::toString() {
  81         std::string sofar = "StdTextModel { ";
  82         for (int i = 0; i < d_pieces.size(); ++i) {
  83                 sofar += d_pieces[i]->toString() + " ";
  84         }
  85         return sofar + "}";
  86 }
  87
  88 void StdTextModel::accept(Visitor &visitor) const {
  89         visitor.partStart();
  90         for (int i = 0; i < d_pieces.size(); ++i) {
  91                 d_pieces[i]->accept(visitor);
  92         }
  93         visitor.partEnd();
  94 }
  95
  96 TextPiece::TextPiece(size_t len): d_len(len) {}
  97
  98 unsigned TextPiece::size() const {
  99         return d_len;
 100 }
 101
 102 LongPiece::LongPiece(size_t len): TextPiece(len * 2) {}
 103
 104 LongPiece::~LongPiece() {
 105         delete d_buf;
 106 }
 107
 108 void LongPiece::read(Reader &reader) {
 109         d_buf = new CHAR[d_len / 2 + 1];
 110         reader.readLChar(d_buf, d_len / 2);
 111         d_buf[d_len / 2] = 0;
 112 }
 113
 114 std::string LongPiece::toString() const {
 115         return std::string("LongPiece(FIXME)");
 116 }
 117
 118 CHAR* LongPiece::getBuffer() const {
 119         return d_buf;
 120 }
 121
 122 void LongPiece::accept(Visitor &visitor) const {
 123         visitor.textLongPiece(this);
 124 }
 125
 126 ShortPiece::ShortPiece(size_t len): TextPiece(len) {}
 127
 128 ShortPiece::~ShortPiece() {
 129         delete d_buf;
 130 }
 131
 132 void ShortPiece::read(Reader &reader) {
 133         d_buf = new SHORTCHAR[d_len + 1];
 134         reader.readSChar(d_buf, d_len);
 135         d_buf[d_len] = 0;
 136 }
 137
 138 std::string ShortPiece::toString() const {
 139         return std::string("ShortPiece(") + std::string(d_buf) + std::string(")");
 140 }
 141
 142 SHORTCHAR* ShortPiece::getBuffer() const {
 143         return d_buf;
 144 }
 145
 146 void ShortPiece::accept(Visitor &visitor) const {
 147         visitor.textShortPiece(this);
 148 }
 149
 150 ViewPiece::ViewPiece(Store *view): TextPiece(1), d_view(view) {}
 151
 152 ViewPiece::~ViewPiece() {
 153         delete d_view;
 154 }
 155
 156 void ViewPiece::read(Reader &reader) {
 157         reader.readByte();
 158 }
 159
 160 std::string ViewPiece::toString() const {
 161         return std::string("ViewPiece { ") + d_view->toString() + " }";
 162 }
 163
 164 void ViewPiece::accept(Visitor &visitor) const {
 165         return d_view->accept(visitor);
 166 }
 167
 168 } // namespace odc