Line data Source code
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_FONT_DATA_TABLE_H_
18 : #define SFNTLY_CPP_SRC_SFNTLY_TABLE_FONT_DATA_TABLE_H_
19 :
20 : #include "sfntly/data/readable_font_data.h"
21 : #include "sfntly/data/writable_font_data.h"
22 : #include "sfntly/port/refcount.h"
23 :
24 : namespace sfntly {
25 :
26 : // An abstract base for any table that contains a FontData. This is the root of
27 : // the table class hierarchy.
28 : class FontDataTable : virtual public RefCount {
29 : public:
30 : // Note: original version is abstract Builder<T extends FontDataTable>
31 : // C++ template is not designed that way so plain class is chosen.
32 : class Builder : virtual public RefCount {
33 : public:
34 : // Get a snapshot copy of the internal data of the builder.
35 : // This causes any internal data structures to be serialized to a new data
36 : // object. This data object belongs to the caller and must be properly
37 : // disposed of. No changes are made to the builder and any changes to the
38 : // data directly do not affect the internal state. To do that a subsequent
39 : // call must be made to {@link #SetData(WritableFontData)}.
40 : // @return a copy of the internal data of the builder
41 : CALLER_ATTACH WritableFontData* Data();
42 : virtual void SetData(ReadableFontData* data);
43 :
44 : // Note: changed from protected to avoid accessibility error in C++
45 : virtual CALLER_ATTACH FontDataTable* Build();
46 : virtual bool ReadyToBuild();
47 :
48 : ReadableFontData* InternalReadData();
49 : WritableFontData* InternalWriteData();
50 :
51 0 : bool data_changed() { return data_changed_; }
52 0 : bool model_changed() {
53 0 : return current_model_changed() || contained_model_changed();
54 : }
55 0 : bool current_model_changed() { return model_changed_; }
56 0 : bool contained_model_changed() { return contained_model_changed_; }
57 :
58 0 : bool set_model_changed() { return set_model_changed(true); }
59 0 : bool set_model_changed(bool changed) {
60 0 : bool old = model_changed_;
61 0 : model_changed_ = changed;
62 0 : return old;
63 : }
64 :
65 : protected:
66 : explicit Builder();
67 :
68 : // Construct a FontDataTable.Builder with a WritableFontData backing store
69 : // of size given. A positive size will create a fixed size backing store and
70 : // a 0 or less size is an estimate for a growable backing store with the
71 : // estimate being the absolute of the size.
72 : // @param dataSize if positive then a fixed size; if 0 or less then an
73 : // estimate for a growable size
74 : Builder(int32_t data_size);
75 : Builder(WritableFontData* data);
76 : Builder(ReadableFontData* data);
77 : virtual ~Builder();
78 :
79 : // subclass API
80 : virtual void NotifyPostTableBuild(FontDataTable* table);
81 : virtual int32_t SubSerialize(WritableFontData* new_data) = 0;
82 : virtual bool SubReadyToSerialize() = 0;
83 : virtual int32_t SubDataSizeToSerialize() = 0;
84 : virtual void SubDataSet() = 0;
85 : virtual CALLER_ATTACH FontDataTable*
86 : SubBuildTable(ReadableFontData* data) = 0;
87 :
88 : private:
89 : void InternalSetData(WritableFontData* data, bool data_changed);
90 : void InternalSetData(ReadableFontData* data, bool data_changed);
91 :
92 : WritableFontDataPtr w_data_;
93 : ReadableFontDataPtr r_data_;
94 : bool model_changed_;
95 : bool contained_model_changed_; // may expand to list of submodel states
96 : bool data_changed_;
97 : };
98 :
99 : explicit FontDataTable(ReadableFontData* data);
100 : virtual ~FontDataTable();
101 :
102 : // Get the readable font data for this table.
103 : ReadableFontData* ReadFontData();
104 :
105 : // Get the length of the data for this table in bytes. This is the full
106 : // allocated length of the data underlying the table and may or may not
107 : // include any padding.
108 : virtual int32_t DataLength();
109 :
110 : virtual int32_t Serialize(OutputStream* os);
111 :
112 : protected:
113 : virtual int32_t Serialize(WritableFontData* data);
114 :
115 : // TODO(arthurhsu): style guide violation: protected member, need refactoring
116 : ReadableFontDataPtr data_;
117 : };
118 : typedef Ptr<FontDataTable> FontDataTablePtr;
119 : typedef Ptr<FontDataTable::Builder> FontDataTableBuilderPtr;
120 :
121 : } // namespace sfntly
122 :
123 : #endif // SFNTLY_CPP_SRC_SFNTLY_TABLE_FONT_DATA_TABLE_H_
|