textmodel.cc

   1 #include <textmodel.h>
   2 #include <reader.h>
   3
   4 #include <vector>
   5 #include <assert.h>
   6
   7 //#include <fstream>
   8 //#include <iostream>
   9
  10 namespace odc {
  11
  12 const std::string TextModel::TYPENAME("TextModels.Model^");
  13 const TypeProxy<TextModel> TextModel::PROXY;
  14
  15 TextModel::TextModel(INTEGER id) : ContainerModel(id) {}
  16
  17 const std::string &TextModel::getType() {
  18         return TYPENAME;
  19 }
  20
  21 const std::string *TextModel::getSuper() {
  22         return &ContainerModel::getType();
  23 }
  24
  25 const std::string &TextModel::getTypeName() const {
  26         return getType();
  27 }
  28
  29 void TextModel::internalize(Reader &reader) {
  30         ContainerModel::internalize(reader);
  31         if (reader.isCancelled()) return;
  32         reader.readVersion(0, 0);
  33 }
  34
  35 const std::string StdTextModel::TYPENAME("TextModels.StdModel^");
  36 const TypeProxy<StdTextModel> StdTextModel::PROXY;
  37
  38 StdTextModel::StdTextModel(INTEGER id) : TextModel(id), d_pieces() {}
  39
  40 const std::string &StdTextModel::getType() {
  41         return TYPENAME;
  42 }
  43
  44 const std::string *StdTextModel::getSuper() {
  45         return &TextModel::getType();
  46 }
  47
  48 const std::string &StdTextModel::getTypeName() const {
  49         return getType();
  50 }
  51
  52 /*
  53  * This is my current theory of how the StdTextModel storage format works:
  54  * byte 0: version
  55  * byte 1-5: len (length of piece descriptions)
  56  * byte 6-5+len: piece descriptions
  57  * byte 6+len-end: pieces (length of each defined in piece descriptions)
  58  */
  59 void StdTextModel::internalize(Reader &reader) {
  60         TextModel::internalize(reader);
  61         if (reader.isCancelled()) return;
  62         reader.readVersion(0, 1);
  63         if (reader.isCancelled()) return;
  64
  65         std::vector<Store *> dict;
  66         INTEGER len = reader.readInt();
  67         BYTE ano = reader.readByte();
  68         //std::cout << "len " << len << " ano " << (int)ano << std::endl;
  69         int skip = 0;
  70         while (ano != -1) {
  71                 if (ano == dict.size()) {
  72                         Store *attr = reader.readStore(); // readAttributes(); Stores.Join(t, attr)
  73                         dict.push_back(attr);
  74                 }
  75                 INTEGER pieceLen = reader.readInt();
  76                 if (pieceLen > 0) { // shortchar piece
  77                         //std::cout << "Found SChar piece" << std::endl;
  78                         d_pieces.push_back(new ShortPiece(pieceLen));
  79 //                              NEW(sp); sp.len := len; sp.attr := attr;
  80 //                              sp.file := rd.rider.Base(); sp.org := org; un := sp;
  81 //                              INC(org, len) -- increment org by len ?
  82                 } else if (pieceLen < 0) { // longchar piece
  83                         //std::cout << "Found LChar piece" << std::endl;
  84                         assert(pieceLen % 2 == 0);
  85                         d_pieces.push_back(new LongPiece(pieceLen / 2));
  86 //                              len := -len; ASSERT(~ODD(len), 100);
  87 //                              NEW(lp); lp.len := len DIV 2; lp.attr := attr;
  88 //                              lp.file := rd.rider.Base(); lp.org := org; un := lp;
  89 //                              INC(org, len) -- increment org by len ?
  90                 } else { // embedded view
  91                         //std::cout << "Found View piece" << std::endl;
  92                         reader.readInt(); reader.readInt(); // view width + height: ignore
  93                         Store *view = reader.readStore();
  94 //                              NEW(v); v.len := 1; v.attr := attr;
  95 //                              rd.ReadInt(v.w); rd.ReadInt(v.h); Views.ReadView(rd, v.view);
  96 //                              v.view.InitContext(NewContext(v, t));
  97 //                              un := v; INC(org) -- increment org by one?? WTH?
  98                         d_pieces.push_back(new ViewPiece(view));
  99                         ++skip;
 100                 }
 101                 ano = reader.readByte();
 102         }
 103         for (int i = 0; i < d_pieces.size(); ++i) {
 104                 d_pieces[i]->read(reader);
 105         }
 106 //              rd.SetPos(org);
 107 }
 108 //      PROCEDURE (t: StdModel) Internalize (VAR rd: Stores.Reader);
 109 //              VAR u, un: Run; sp: Piece; lp: LPiece; v: ViewRef;
 110 //                      org, len: INTEGER; ano: BYTE; thisVersion: INTEGER;
 111 //                      attr: Attributes; dict: AttrDict;
 112 //      BEGIN
 113 //              ASSERT(t.Domain() = NIL, 20); ASSERT(t.len = 0, 21);
 114 //              t.Internalize^(rd); IF rd.cancelled THEN RETURN END;
 115 //              rd.ReadVersion(minVersion, maxStdModelVersion, thisVersion);
 116 //              IF rd.cancelled THEN RETURN END;
 117 //              StdInit(t);
 118 //              dict.len := 0; u := t.trailer;
 119 //              rd.ReadInt(len); org := rd.Pos() + len;
 120 //              rd.ReadByte(ano);
 121 //              WHILE ano # -1 DO
 122 //                      IF ano = dict.len THEN
 123 //                              ReadAttr(rd, attr); Stores.Join(t, attr);
 124 //                              IF dict.len < dictSize THEN dict.attr[dict.len] := attr; INC(dict.len) END
 125 //                      ELSE
 126 //                              attr := dict.attr[ano]
 127 //                      END;
 128 //                      rd.ReadInt(len);
 129 //                      IF len > 0 THEN (* piece *)
 130 //                              NEW(sp); sp.len := len; sp.attr := attr;
 131 //                              sp.file := rd.rider.Base(); sp.org := org; un := sp;
 132 //                              INC(org, len)
 133 //                      ELSIF len < 0 THEN      (* longchar piece *)
 134 //                              len := -len; ASSERT(~ODD(len), 100);
 135 //                              NEW(lp); lp.len := len DIV 2; lp.attr := attr;
 136 //                              lp.file := rd.rider.Base(); lp.org := org; un := lp;
 137 //                              INC(org, len)
 138 //                      ELSE    (* len = 0  =>  embedded view *)
 139 //                              NEW(v); v.len := 1; v.attr := attr;
 140 //                              rd.ReadInt(v.w); rd.ReadInt(v.h); Views.ReadView(rd, v.view);
 141 //                              v.view.InitContext(NewContext(v, t));
 142 //                              un := v; INC(org)
 143 //                      END;
 144 //                      INC(t.len, un.len); u.next := un; un.prev := u; u := un;
 145 //                      rd.ReadByte(ano)
 146 //              END;
 147 //              rd.SetPos(org);
 148 //              u.next := t.trailer; t.trailer.prev := u
 149 //      END Internalize;
 150 //
 151
 152 std::string StdTextModel::toString() {
 153         std::string sofar = "StdTextModel { ";
 154         for (int i = 0; i < d_pieces.size(); ++i) {
 155                 sofar += d_pieces[i]->toString() + " ";
 156         }
 157         return sofar + "}";
 158 }
 159
 160 TextPiece::TextPiece(size_t len): d_len(len) {}
 161
 162 LongPiece::LongPiece(size_t len): TextPiece(len) {}
 163
 164 LongPiece::~LongPiece() {
 165         delete d_buf;
 166 }
 167
 168 void LongPiece::read(Reader &reader) {
 169         d_buf = new CHAR[d_len];
 170         reader.readLChar(d_buf, d_len);
 171 }
 172
 173 std::string LongPiece::toString() {
 174         return std::string("LongPiece(FIXME)");// + std::wstring((wchar_t*)d_buf) + std::string(")");
 175 }
 176
 177 ShortPiece::ShortPiece(size_t len): TextPiece(len) {}
 178
 179 ShortPiece::~ShortPiece() {
 180         delete d_buf;
 181 }
 182
 183 void ShortPiece::read(Reader &reader) {
 184 //      static char piece[] = "pieceA";
 185         d_buf = new SHORTCHAR[d_len + 1];
 186         reader.readSChar(d_buf, d_len);
 187         d_buf[d_len] = 0;
 188 //      std::cout.write(buf, d_len);
 189 //      std::ofstream ofs(piece, std::ios::out);
 190 //      ofs.write(buf, d_len);
 191 //      ofs.close();
 192 //      ++piece[5];
 193 //      delete buf;
 194 }
 195
 196 std::string ShortPiece::toString() {
 197         return std::string("ShortPiece(") + std::string(d_buf) + std::string(")");
 198 }
 199
 200 ViewPiece::ViewPiece(Store *view): TextPiece(0), d_view(view) {}
 201
 202 void ViewPiece::read(Reader &reader) {
 203         reader.readByte();
 204 }
 205
 206 std::string ViewPiece::toString() {
 207         return std::string("ViewPiece { ") + d_view->toString() + " }";
 208 }
 209
 210 } // namespace odc