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