textmodel.cc

   1 #include <textmodel.h>
   2 #include <reader.h>
   3
   4 #include <vector>
   5 #include <assert.h>
   6
   7 namespace odc {
   8
   9 const std::string TextModel::TYPENAME("TextModels.Model^");
  10 const TypeProxy<TextModel, ContainerModel> TextModel::PROXY;
  11
  12 TextModel::TextModel(INTEGER id) : ContainerModel(id) {}
  13
  14 const std::string &TextModel::getTypeName() const {
  15         return TYPENAME;
  16 }
  17
  18 void TextModel::internalize(Reader &reader) {
  19         ContainerModel::internalize(reader);
  20         if (reader.isCancelled()) return;
  21         reader.readVersion(0, 0);
  22 }
  23
  24 const std::string StdTextModel::TYPENAME("TextModels.StdModel^");
  25 const TypeProxy<StdTextModel, TextModel> StdTextModel::PROXY;
  26
  27 StdTextModel::StdTextModel(INTEGER id) : TextModel(id), d_pieces() {}
  28
  29 const std::string &StdTextModel::getTypeName() const {
  30         return TYPENAME;
  31 }
  32
  33 /*
  34  * This is my current theory of how the StdTextModel storage format works:
  35  * byte 0: version
  36  * byte 1-5: len (length of piece descriptions)
  37  * byte 6-5+len: piece descriptions
  38  * byte 6+len-end: pieces (length of each defined in piece descriptions)
  39  */
  40 void StdTextModel::internalize(Reader &reader) {
  41         TextModel::internalize(reader);
  42         if (reader.isCancelled()) return;
  43         reader.readVersion(0, 1);
  44         if (reader.isCancelled()) return;
  45
  46         std::vector<Store *> dict; // attribute dictionary
  47
  48         // reads the meta-data
  49         INTEGER len = reader.readInt(); // lenght of meta-data section
  50         BYTE ano = reader.readByte();
  51         while (ano != -1) {
  52                 // This part reads the piece's attributes. These are ignored for now,
  53                 // but may be needed in the future.
  54                 if (ano == dict.size()) {
  55                         dict.push_back(reader.readStore());
  56                 }
  57                 Store *attr = dict[ano];
  58
  59                 INTEGER pieceLen = reader.readInt();
  60                 if (pieceLen > 0) { // shortchar piece
  61                         d_pieces.push_back(new ShortPiece(pieceLen));
  62                 } else if (pieceLen < 0) { // longchar piece
  63                         assert(pieceLen % 2 == 0);
  64                         d_pieces.push_back(new LongPiece(-pieceLen / 2));
  65                 } else { // embedded view
  66                         reader.readInt(); reader.readInt(); // view width + height: ignore
  67                         Store *view = reader.readStore();
  68                         d_pieces.push_back(new ViewPiece(view));
  69                 }
  70                 ano = reader.readByte();
  71         }
  72
  73         // reads the pieces described in the meta-data
  74         for (int i = 0; i < d_pieces.size(); ++i) {
  75                 d_pieces[i]->read(reader);
  76         }
  77
  78         // free memory from stores in the dictionary
  79         for (int i = 0; i < dict.size(); ++i) {
  80                 delete dict[i];
  81         }
  82 }
  83
  84 std::string StdTextModel::toString() {
  85         std::string sofar = "StdTextModel { ";
  86         for (int i = 0; i < d_pieces.size(); ++i) {
  87                 sofar += d_pieces[i]->toString() + " ";
  88         }
  89         return sofar + "}";
  90 }
  91
  92 void StdTextModel::accept(Visitor &visitor) const {
  93         visitor.partStart();
  94         for (int i = 0; i < d_pieces.size(); ++i) {
  95                 d_pieces[i]->accept(visitor);
  96         }
  97         visitor.partEnd();
  98 }
  99
 100 TextPiece::TextPiece(size_t len): d_len(len) {}
 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 std::wstring LongPiece::getText() const {
 119         return std::wstring((wchar_t*)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 std::string ShortPiece::getText() const {
 143         std::string str(d_buf);
 144         for (std::string::iterator it = str.begin(); it < str.end(); ++it) {
 145                 if (*it == '\r') *it = '\n';
 146         }
 147         return str;
 148 }
 149
 150 void ShortPiece::accept(Visitor &visitor) const {
 151         visitor.textShortPiece(this);
 152 }
 153
 154 ViewPiece::ViewPiece(Store *view): TextPiece(1), d_view(view) {}
 155
 156 ViewPiece::~ViewPiece() {
 157         delete d_view;
 158 }
 159
 160 void ViewPiece::read(Reader &reader) {
 161         reader.readByte();
 162 }
 163
 164 std::string ViewPiece::toString() const {
 165         return std::string("ViewPiece { ") + d_view->toString() + " }";
 166 }
 167
 168 void ViewPiece::accept(Visitor &visitor) const {
 169         return d_view->accept(visitor);
 170 }
 171
 172 } // namespace odc