Home | History | Annotate | Download | only in table 
      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     bool data_changed() { return data_changed_; }
     52     bool model_changed() {
     53       return current_model_changed() || contained_model_changed();
     54     }
     55     bool current_model_changed() { return model_changed_; }
     56     bool contained_model_changed() { return contained_model_changed_; }
     57 
     58     bool set_model_changed() { return set_model_changed(true); }
     59     bool set_model_changed(bool changed) {
     60       bool old = model_changed_;
     61       model_changed_ = changed;
     62       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_
    124