table.h revision 584bf6606b53bda8bf0810e7c0ad57e24cacb4f1 
1/*
2 * Copyright 2011 Google Inc. All Rights Reserved.
3 *
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
7 *
8 *      http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
15 */
16
17#ifndef SFNTLY_CPP_SRC_SFNTLY_TABLE_TABLE_H_
18#define SFNTLY_CPP_SRC_SFNTLY_TABLE_TABLE_H_
19
20#include <set>
21#include <map>
22#include <vector>
23#include <utility>
24
25#include "sfntly/port/type.h"
26#include "sfntly/table/font_data_table.h"
27
28namespace sfntly {
29class Font;
30class Table : public FontDataTable, public FontDataTableBuilderContainer {
31 public:
32  class Header : public RefCounted<Header> {
33   public:
34    explicit Header(int32_t tag);
35    Header(int32_t tag, int32_t length);
36    Header(int32_t tag, int64_t checksum, int32_t offset, int32_t length);
37    virtual ~Header();
38
39    int32_t tag() { return tag_; }
40    int32_t offset() { return offset_; }
41    int32_t length() { return length_; }
42    bool offset_valid() { return offset_valid_; }
43    int64_t checksum() { return checksum_; }
44    bool checksum_valid() { return checksum_valid_; }
45
46   private:
47    int32_t tag_;
48    int32_t offset_;
49    int32_t length_;
50    bool offset_valid_;
51    int64_t checksum_;
52    bool checksum_valid_;
53
54    friend class TableHeaderComparator;
55  };
56
57  // Note: original version is Builder<T extends Table>
58  //       C++ template is not designed that way so plain old inheritance is
59  //       chosen.
60  class Builder : public FontDataTable::Builder,
61                  public FontDataTableBuilderContainer {
62   public:
63    virtual ~Builder();
64    virtual Header* header() { return header_; }
65    virtual void NotifyPostTableBuild(FontDataTable* table);
66    virtual WritableFontData* GetNewData(int32_t size);
67
68    static CALLER_ATTACH Builder*
69        GetBuilder(FontDataTableBuilderContainer* font_builder,
70                   Header* header,
71                   WritableFontData* table_data);
72
73   protected:
74    // Note: original version is Font.Builder font_builder. This results in
75    //       mutual inclusion happiness that Java solved for C++.  Therefore,
76    //       we need to avoid that happiness when we port it to C++.
77    Builder(FontDataTableBuilderContainer* font_builder,
78            Header* header,
79            WritableFontData* data);
80    Builder(FontDataTableBuilderContainer* font_builder,
81            Header* header,
82            ReadableFontData* data);
83    Builder(FontDataTableBuilderContainer* font_builder,
84            Header* header);
85
86   private:
87    Ptr<Header> header_;
88  };
89
90  class TableBasedTableBuilder : public Builder {
91   public:
92    virtual ~TableBasedTableBuilder();
93
94    virtual int32_t SubSerialize(WritableFontData* new_data);
95    virtual bool SubReadyToSerialize();
96    virtual int32_t SubDataSizeToSerialize();
97    virtual void SubDataSet();
98
99   protected:
100    TableBasedTableBuilder(FontDataTableBuilderContainer* font_builder,
101                           Header* header,
102                           WritableFontData* data);
103    TableBasedTableBuilder(FontDataTableBuilderContainer* font_builder,
104                           Header* header,
105                           ReadableFontData* data);
106    TableBasedTableBuilder(FontDataTableBuilderContainer* font_builder,
107                           Header* header);
108
109    // C++ port: renamed table() to GetTable()
110    virtual Table* GetTable();
111
112    // TODO(arthurhsu): style guide violation: protected member, need refactor
113    Ptr<Table> table_;
114  };
115
116  class GenericTableBuilder : public TableBasedTableBuilder,
117                              public RefCounted<GenericTableBuilder> {
118   public:
119    GenericTableBuilder(FontDataTableBuilderContainer* font_builder,
120                        Header* header,
121                        WritableFontData* data);
122    virtual CALLER_ATTACH FontDataTable* SubBuildTable(ReadableFontData* data);
123  };
124
125  class ArrayElementTableBuilder : public Builder {
126   public:
127    virtual ~ArrayElementTableBuilder();
128
129   protected:
130    ArrayElementTableBuilder(FontDataTableBuilderContainer* font_builder,
131                             Header* header,
132                             WritableFontData* data);
133    ArrayElementTableBuilder(FontDataTableBuilderContainer* font_builder,
134                             Header* header,
135                             ReadableFontData* data);
136  };
137
138  virtual ~Table();
139  virtual int64_t CalculatedChecksum();
140  virtual Header* header()          { return header_; }
141  virtual int32_t header_tag()      { return header_->tag(); }
142  virtual int32_t header_offset()   { return header_->offset(); }
143  virtual int32_t header_length()   { return header_->length(); }
144  virtual int64_t header_checksum() { return header_->checksum(); }
145  virtual WritableFontData* GetNewData(int32_t size);
146  virtual void SetFont(Font* font);
147
148 protected:
149  Table(Header* header, ReadableFontData* data);
150
151 private:
152  Ptr<Header> header_;
153  Ptr<Font> font_;
154};
155
156// C++ port only
157class GenericTable : public Table, public RefCounted<GenericTable> {
158 public:
159  GenericTable(Header* header, ReadableFontData* data) : Table(header, data) {}
160  virtual ~GenericTable() {}
161};
162
163typedef Ptr<Table> TablePtr;
164typedef Ptr<Table::Header> TableHeaderPtr;
165typedef std::vector<TableHeaderPtr> TableHeaderList;
166typedef Ptr<Table::Builder> TableBuilderPtr;
167typedef std::map<int32_t, TablePtr> TableMap;
168typedef std::pair<int32_t, TablePtr> TableMapEntry;
169
170typedef std::map<TableHeaderPtr, WritableFontDataPtr> DataBlockMap;
171typedef std::pair<TableHeaderPtr, WritableFontDataPtr> DataBlockEntry;
172typedef std::map<int32_t, TableBuilderPtr> TableBuilderMap;
173typedef std::pair<int32_t, TableBuilderPtr> TableBuilderEntry;
174
175class TableHeaderComparator {
176 public:
177  bool operator()(const TableHeaderPtr h1, const TableHeaderPtr h2);
178};
179typedef std::set<TableHeaderPtr, TableHeaderComparator> TableHeaderSortedSet;
180
181}  // namespace sfntly
182
183#endif  // SFNTLY_CPP_SRC_SFNTLY_TABLE_TABLE_H_
184