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