table/core/cmap_table.h

/*
 * Copyright 2011 Google Inc. All Rights Reserved.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

#ifndef SFNTLY_CPP_SRC_SFNTLY_TABLE_CORE_CMAP_TABLE_H_
#define SFNTLY_CPP_SRC_SFNTLY_TABLE_CORE_CMAP_TABLE_H_

// type.h needs to be included first because of building issues on Windows
// Type aliases we delcare are defined in other headers and make the build
// fail otherwise.
#include "sfntly/port/type.h"
#include <vector>
#include <map>

#include "sfntly/port/refcount.h"
#include "sfntly/table/subtable.h"
#include "sfntly/table/subtable_container_table.h"

namespace sfntly {

// CMap subtable formats
struct CMapFormat {
  enum {
    kFormat0 = 0,
    kFormat2 = 2,
    kFormat4 = 4,
    kFormat6 = 6,
    kFormat8 = 8,
    kFormat10 = 10,
    kFormat12 = 12,
    kFormat13 = 13,
    kFormat14 = 14
  };
};

// A CMap table
class CMapTable : public SubTableContainerTable, public RefCounted<CMapTable> {
public:
  // CMapTable::CMapId
  struct CMapId {
    int32_t platform_id;
    int32_t encoding_id;
    bool operator==(const CMapId& obj) const {
      return platform_id == obj.platform_id && encoding_id == obj.encoding_id;
    }
  };
  static CMapId WINDOWS_BMP;
  static CMapId WINDOWS_UCS4;
  static CMapId MAC_ROMAN;

  // CMapTable::CMapIdComparator
  class CMapIdComparator {
   public:
    bool operator()(const CMapId& lhs, const CMapId& rhs) const;
  };

  // A filter on cmap
  // CMapTable::CMapFilter
  class CMapFilter {
   public:
    // Test on whether the cmap is acceptable or not
    // @param cmap_id the id of the cmap
    // @return true if the cmap is acceptable; false otherwise
    virtual bool accept(const CMapId& cmap_id) const = 0;
    // Make gcc -Wnon-virtual-dtor happy.
    virtual ~CMapFilter() {}
  };

  // Filters CMaps by CMapId to implement CMapTable::get()
  // wanted_id is the CMap we'd like to find.
  // We compare the current CMap to it either by equality (==) or using a
  // comparator.
  // CMapTable::CMapIdFilter
  class CMapIdFilter : public CMapFilter {
   public:
    explicit CMapIdFilter(const CMapId wanted_id);
    CMapIdFilter(const CMapId wanted_id,
                 const CMapIdComparator* comparator);
    ~CMapIdFilter() {}
    virtual bool accept(const CMapId& cmap_id) const;
   private:
    CMapIdFilter& operator=(const CMapIdFilter& that);
    const CMapId wanted_id_;
    const CMapIdComparator *comparator_;
  };

  // The abstract base class for all cmaps.
  //
  // CMap equality is based on the equality of the (@link {@link CMapId} that
  // defines the CMap. In the cmap table for a font there can only be one cmap
  // with a given cmap id (pair of platform and encoding ids) no matter what the
  // type of the cmap is.
  //
  // The cmap offers CharacterIterator to allow iteration over
  // characters that are mapped by the cmap. This iteration mostly returns the
  // characters mapped by the cmap. It will return all characters mapped by the
  // cmap to anything but .notdef <b>but</b> it may return some that are not
  // mapped or are mapped to .notdef. Various cmap tables provide ranges and
  // such to describe characters for lookup but without going the full way to
  // mapping to the glyph id it isn't always possible to tell if a character
  // will end up with a valid glyph id. So, some of the characters returned from
  // the Iterator may still end up pointing to the .notdef glyph. However, the
  // number of such characters should be small in most cases with well designed
  // cmaps.
  class Builder;
  class CMap : public SubTable {
   public:
    // CMapTable::CMap::Builder
    class Builder : public SubTable::Builder {
     public:
      virtual ~Builder();

      CALLER_ATTACH static Builder*
          GetBuilder(ReadableFontData* data,
                     int32_t offset,
                     const CMapId& cmap_id);
      CALLER_ATTACH static Builder*
          GetBuilder(int32_t format,
                     const CMapId& cmap_id);

      // Note: yes, an object is returned on stack since it's small enough.
      virtual CMapId cmap_id() { return cmap_id_; }
      virtual int32_t platform_id() { return cmap_id_.platform_id; }
      virtual int32_t encoding_id() { return cmap_id_.encoding_id; }
      virtual int32_t format() { return format_; }
      virtual int32_t language() { return language_; }
      virtual void set_language(int32_t language) { language_ = language; }

     protected:
      Builder(ReadableFontData* data,
              int32_t format,
              const CMapId& cmap_id);
      Builder(WritableFontData* data,
              int32_t format,
              const CMapId& cmap_id);

      virtual int32_t SubSerialize(WritableFontData* new_data);
      virtual bool SubReadyToSerialize();
      virtual int32_t SubDataSizeToSerialize();
      virtual void SubDataSet();

     private:
      int32_t format_;
      CMapId cmap_id_;
      int32_t language_;

      friend class CMapTable::Builder;
    };
    // Abstract CMap character iterator
    // The fully qualified name is CMapTable::CMap::CharacterIterator
    class CharacterIterator {
     public:
      virtual ~CharacterIterator() {}
      virtual bool HasNext() = 0;
      // Returns -1 if there are no more characters to iterate through
      // and exceptions are turned off
      virtual int32_t Next() = 0;

     protected:
      // Use the CMap::Iterator method below instead of directly requesting
      // a CharacterIterator.
      CharacterIterator() {}
    };

    CMap(ReadableFontData* data, int32_t format, const CMapId& cmap_id);
    virtual ~CMap();

    virtual CMap::CharacterIterator* Iterator() = 0;

    virtual int32_t format() { return format_; }
    virtual CMapId cmap_id() { return cmap_id_; }
    virtual int32_t platform_id() { return cmap_id_.platform_id; }
    virtual int32_t encoding_id() { return cmap_id_.encoding_id; }

    // Get the language of the cmap.
    //
    // Note on the language field in 'cmap' subtables: The language field must
    // be set to zero for all cmap subtables whose platform IDs are other than
    // Macintosh (platform ID 1). For cmap subtables whose platform IDs are
    // Macintosh, set this field to the Macintosh language ID of the cmap
    // subtable plus one, or to zero if the cmap subtable is not
    // language-specific. For example, a Mac OS Turkish cmap subtable must set
    // this field to 18, since the Macintosh language ID for Turkish is 17. A
    // Mac OS Roman cmap subtable must set this field to 0, since Mac OS Roman
    // is not a language-specific encoding.
    //
    // @return the language id
    virtual int32_t Language() = 0;

    // Gets the glyph id for the character code provided.
    // The character code provided must be in the encoding used by the cmap
    // table.
    virtual int32_t GlyphId(int32_t character) = 0;

   private:
    int32_t format_;
    CMapId cmap_id_;
  };
  typedef Ptr<CMap> CMapPtr;
  typedef Ptr<CMap::Builder> CMapBuilderPtr;
  typedef std::map<CMapId, CMapBuilderPtr, CMapIdComparator> CMapBuilderMap;

  // A cmap format 0 sub table
  class CMapFormat0 : public CMap, public RefCounted<CMapFormat0> {
   public:
    // The fully qualified name is CMapTable::CMapFormat0::Builder
    class Builder : public CMap::Builder,
                    public RefCounted<Builder> {
     public:
      CALLER_ATTACH static Builder* NewInstance(ReadableFontData* data,
                                                int32_t offset,
                                                const CMapId& cmap_id);
      CALLER_ATTACH static Builder* NewInstance(WritableFontData* data,
                                                int32_t offset,
                                                const CMapId& cmap_id);
      CALLER_ATTACH static Builder* NewInstance(const CMapId& cmap_id);
      virtual ~Builder();

     protected:
      virtual CALLER_ATTACH FontDataTable*
          SubBuildTable(ReadableFontData* data);

     private:
      // When creating a new CMapFormat0 Builder, use NewInstance instead of
      // the constructors! This avoids a memory leak when slicing the FontData.
      Builder(ReadableFontData* data, int32_t offset, const CMapId& cmap_id);
      Builder(WritableFontData* data, int32_t offset, const CMapId& cmap_id);
      Builder(const CMapId& cmap_id);
    };

    // The fully qualified name is CMapTable::CMapFormat0::CharacterIterator
    class CharacterIterator : public CMap::CharacterIterator {
     public:
      virtual ~CharacterIterator();
      virtual bool HasNext();
      virtual int32_t Next();

     private:
      CharacterIterator(int32_t start, int32_t end);
      friend class CMapFormat0;
      int32_t character_, max_character_;
    };

    virtual ~CMapFormat0();
    virtual int32_t Language();
    virtual int32_t GlyphId(int32_t character);
    CMap::CharacterIterator* Iterator();

   private:
    CMapFormat0(ReadableFontData* data, const CMapId& cmap_id);
  };

  // A cmap format 2 sub table
  // The format 2 cmap is used for multi-byte encodings such as SJIS,
  // EUC-JP/KR/CN, Big5, etc.
  class CMapFormat2 : public CMap, public RefCounted<CMapFormat2> {
   public:
    // CMapTable::CMapFormat2::Builder
    class Builder : public CMap::Builder,
                    public RefCounted<Builder> {
     public:
      Builder(ReadableFontData* data,
              int32_t offset,
              const CMapId& cmap_id);
      Builder(WritableFontData* data,
              int32_t offset,
              const CMapId& cmap_id);
      virtual ~Builder();

     protected:
      virtual CALLER_ATTACH FontDataTable*
          SubBuildTable(ReadableFontData* data);
    };
    // CMapTable::CMapFormat2::CharacterIterator
    class CharacterIterator : public CMap::CharacterIterator {
     public:
      virtual ~CharacterIterator();
      virtual bool hasNext();
      virtual int32_t next();

     private:
      CharacterIterator();
    };

    virtual int32_t Language();
    virtual int32_t GlyphId(int32_t character);

    // Returns how many bytes would be consumed by a lookup of this character
    // with this cmap. This comes about because the cmap format 2 table is
    // designed around multi-byte encodings such as SJIS, EUC-JP, Big5, etc.
    // return the number of bytes consumed from this "character" - either 1 or 2
    virtual int32_t BytesConsumed(int32_t character);

    virtual ~CMapFormat2();

   private:
    CMapFormat2(ReadableFontData* data, const CMapId& cmap_id);

    int32_t SubHeaderOffset(int32_t sub_header_index);
    int32_t FirstCode(int32_t sub_header_index);
    int32_t EntryCount(int32_t sub_header_index);
    int32_t IdRangeOffset(int32_t sub_header_index);
    int32_t IdDelta(int32_t sub_header_index);
    CMap::CharacterIterator* Iterator();
  };

    // CMapTable::CMapFormat4
  class CMapFormat4 : public CMap,
                      public RefCounted<CMapFormat4> {
   public:
    // CMapTable::CMapFormat4::Builder
    class Builder : public CMap::Builder,
                    public RefCounted<Builder> {
     public:
        // CMapTable::CMapFormat4::Builder::Segment
      class Segment : public RefCounted<Segment> {
       public:
        Segment();
        explicit Segment(Segment* other);
        Segment(int32_t start_count,
                int32_t end_count,
                int32_t id_delta,
                int32_t id_range_offset);
        ~Segment();

        // @return the startCount
        int32_t start_count();
        // @param startCount the startCount to set
        void set_start_count(int32_t start_count);
        // @return the endCount
        int32_t end_count();
        // @param endcount the endCount to set
        void set_end_count(int32_t end_count);
        // @return the idDelta
        int32_t id_delta();
        // @param idDelta the idDelta to set
        void set_id_delta(int32_t id_delta);
        // @return the idRangeOffset
        int32_t id_range_offset();
        // @param idRangeOffset the idRangeOffset to set
        void set_id_range_offset(int32_t id_range_offset);

        static CALLER_ATTACH
        std::vector<Ptr<Segment> >*
        DeepCopy(std::vector<Ptr<Segment> >* original);

       private:
        int32_t start_count_;
        int32_t end_count_;
        int32_t id_delta_;
        int32_t id_range_offset_;
      };
      typedef std::vector<Ptr<Segment> > SegmentList;

      static CALLER_ATTACH Builder* NewInstance(WritableFontData* data,
                                                int32_t offset,
                                                const CMapId& cmap_id);
      static CALLER_ATTACH Builder* NewInstance(ReadableFontData* data,
                                                int32_t offset,
                                                const CMapId& cmap_id);
      static CALLER_ATTACH Builder* NewInstance(const CMapId& cmap_id);
      virtual ~Builder();
      SegmentList* segments();
      void set_segments(SegmentList* segments);
      std::vector<int32_t>* glyph_id_array();
      void set_glyph_id_array(std::vector<int32_t>* glyph_id_array);

     protected:
      Builder(WritableFontData* data, int32_t offset, const CMapId& cmap_id);
      Builder(ReadableFontData* data, int32_t offset, const CMapId& cmap_id);
      Builder(SegmentList* segments, std::vector<int32_t>* glyph_id_array,
              const CMapId& cmap_id);
      explicit Builder(const CMapId& cmap_id);

      virtual CALLER_ATTACH FontDataTable* SubBuildTable(
          ReadableFontData* data);
      virtual void SubDataSet();
      virtual int32_t SubDataSizeToSerialize();
      virtual bool SubReadyToSerialize();
      virtual int32_t SubSerialize(WritableFontData* new_data);

     private:
      void Initialize(ReadableFontData* data);

      SegmentList segments_;
      std::vector<int32_t> glyph_id_array_;
    };

    CMap::CharacterIterator* Iterator();
    // CMapTable::CMapFormat4::CharacterIterator
    class CharacterIterator : public CMap::CharacterIterator {
     public:
      bool HasNext();
      int32_t Next();
      virtual ~CharacterIterator() {}

     private:
      explicit CharacterIterator(CMapFormat4 *parent);
      friend CMap::CharacterIterator* CMapFormat4::Iterator();

      CMapFormat4* parent_;
      int32_t segment_index_;
      int32_t first_char_in_segment_;
      int32_t last_char_in_segment_;
      int32_t next_char_;
      bool next_char_set_;
    };

    virtual int32_t GlyphId(int32_t character);

    // Lower level glyph code retrieval that requires processing the Format 4
    // segments to use.
    // @param segment the cmap segment
    // @param startCode the start code for the segment
    // @param character the character to be looked up
    // @return the glyph id for the character; CMapTable.NOTDEF if not found
    int32_t RetrieveGlyphId(int32_t segment,
                            int32_t start_count,
                            int32_t character);
    virtual int32_t Language();

    // Get the count of the number of segments in this cmap.
    // @return the number of segments
    int32_t seg_count();
    int32_t Length();
    // Get the start code for a segment.
    // @param segment the segment in the lookup table
    // @return the start code for a segment
    int32_t StartCode(int32_t segment);
    // Get the end code for a segment.
    // @param segment the segment in the look up table
    // @return the end code for the segment
    int32_t EndCode(int32_t segment);
    // Get the id delta for a segment
    // @param segment the segment in the look up table
    // @return the id delta for the segment
    int32_t IdDelta(int32_t segment);
    // Get the id range offset for a segment
    // @param segment the segment in the look up table
    // @return the id range offset for the segment
    int32_t IdRangeOffset(int32_t segment);
    // Get the location of the id range offset for a segment
    // @param segment the segment in the look up table
    // @return the location of the id range offset for the segment
    int32_t IdRangeOffsetLocation(int32_t segment);
    // Declared above to allow friending inside CharacterIterator class.
    // CMap::CharacterIterator* Iterator();
    virtual ~CMapFormat4();

   protected:
    CMapFormat4(ReadableFontData* data, const CMapId& cmap_id);

   private:
    static int32_t Language(ReadableFontData* data);
    static int32_t Length(ReadableFontData* data);
    static int32_t SegCount(ReadableFontData* data);
    static int32_t StartCode(ReadableFontData* data,
                             int32_t seg_count,
                             int32_t index);
    static int32_t StartCodeOffset(int32_t seg_count);
    static int32_t EndCode(ReadableFontData* data,
                           int32_t seg_count,
                           int32_t index);
    static int32_t IdDelta(ReadableFontData* data,
                           int32_t seg_count,
                           int32_t index);
    static int32_t IdDeltaOffset(int32_t seg_count);
    static int32_t IdRangeOffset(ReadableFontData* data,
                                 int32_t seg_count,
                                 int32_t index);
    static int32_t IdRangeOffsetOffset(int32_t seg_count);
    static int32_t GlyphIdArrayOffset(int32_t seg_count);
    // Refactored void to bool to work without exceptions.
    bool IsValidIndex(int32_t segment);
    int32_t GlyphIdArray(int32_t index);

    int32_t seg_count_;
    int32_t start_code_offset_;
    int32_t id_delta_offset_;
    int32_t glyph_id_array_offset_;
  };

  // CMapTable::Builder
  class Builder : public SubTableContainerTable::Builder,
                  public RefCounted<Builder> {
   public:
    // Constructor scope is public because C++ does not allow base class to
    // instantiate derived class with protected constructors.
    Builder(Header* header, WritableFontData* data);
    Builder(Header* header, ReadableFontData* data);
    virtual ~Builder();

    virtual int32_t SubSerialize(WritableFontData* new_data);
    virtual bool SubReadyToSerialize();
    virtual int32_t SubDataSizeToSerialize();
    virtual void SubDataSet();
    virtual CALLER_ATTACH FontDataTable* SubBuildTable(ReadableFontData* data);

    static CALLER_ATTACH Builder* CreateBuilder(Header* header,
                                                WritableFontData* data);

    CMap::Builder* NewCMapBuilder(const CMapId& cmap_id,
                                  ReadableFontData* data);
    // Create a new empty CMapBuilder of the type specified in the id.
    CMap::Builder* NewCMapBuilder(int32_t format, const CMapId& cmap_id);
    CMap::Builder* CMapBuilder(const CMapId& cmap_id);

    int32_t NumCMaps();
    void SetVersion(int32_t version);

    CMapBuilderMap* GetCMapBuilders();

   protected:
    static CALLER_ATTACH CMap::Builder* CMapBuilder(ReadableFontData* data,
                                                    int32_t index);

   private:
    void Initialize(ReadableFontData* data);
    static int32_t NumCMaps(ReadableFontData* data);

    int32_t version_;
    CMapBuilderMap cmap_builders_;
  };
  typedef Ptr<Builder> CMapTableBuilderPtr;

  class CMapIterator {
   public:
    // If filter is NULL, filter through all tables.
    CMapIterator(CMapTable* table, const CMapFilter* filter);
    bool HasNext();
    CMap* Next();

   private:
    int32_t table_index_;
    const CMapFilter* filter_;
    CMapTable* table_;
  };

  // Make a CMapId from a platform_id, encoding_id pair
  static CMapId NewCMapId(int32_t platform_id, int32_t encoding_id);
  // Make a CMapId from another CMapId
  static CMapId NewCMapId(const CMapId& obj);

  // Get the CMap with the specified parameters if it exists.
  // Returns NULL otherwise.
  CALLER_ATTACH CMap* GetCMap(const int32_t index);
  CALLER_ATTACH CMap* GetCMap(const int32_t platform_id,
                              const int32_t encoding_id);
  CALLER_ATTACH CMap* GetCMap(const CMapId GetCMap_id);

  // Get the table version.
  virtual int32_t Version();

  // Get the number of cmaps within the CMap table.
  virtual int32_t NumCMaps();

  // Get the cmap id for the cmap with the given index.
  // Note: yes, an object is returned on stack since it's small enough.
  //       This function is renamed from cmapId to GetCMapId().
  virtual CMapId GetCMapId(int32_t index);

  virtual int32_t PlatformId(int32_t index);
  virtual int32_t EncodingId(int32_t index);

  // Get the offset in the table data for the cmap table with the given index.
  // The offset is from the beginning of the table.
  virtual int32_t Offset(int32_t index);

  virtual ~CMapTable();

  static const int32_t NOTDEF;

 private:
  // Offsets to specific elements in the underlying data. These offsets are
  // relative to the start of the table or the start of sub-blocks within
  // the table.
  struct Offset {
    enum {
      kVersion = 0,
      kNumTables = 2,
      kEncodingRecordStart = 4,

      // offsets relative to the encoding record
      kEncodingRecordPlatformId = 0,
      kEncodingRecordEncodingId = 2,
      kEncodingRecordOffset = 4,
      kEncodingRecordSize = 8,

      kFormat = 0,

      // Format 0: Byte encoding table
      kFormat0Format = 0,
      kFormat0Length = 2,
      kFormat0Language = 4,
      kFormat0GlyphIdArray = 6,

      // Format 2: High-byte mapping through table
      kFormat2Format = 0,
      kFormat2Length = 2,
      kFormat2Language = 4,
      kFormat2SubHeaderKeys = 6,
      kFormat2SubHeaders = 518,
      // offset relative to the subHeader structure
      kFormat2SubHeader_firstCode = 0,
      kFormat2SubHeader_entryCount = 2,
      kFormat2SubHeader_idDelta = 4,
      kFormat2SubHeader_idRangeOffset = 6,
      kFormat2SubHeader_structLength = 8,

      // Format 4: Segment mapping to delta values
      kFormat4Format = 0,
      kFormat4Length = 2,
      kFormat4Language = 4,
      kFormat4SegCountX2 = 6,
      kFormat4SearchRange = 8,
      kFormat4EntrySelector = 10,
      kFormat4RangeShift = 12,
      kFormat4EndCount = 14,
      kFormat4FixedSize = 16,

      // format 6: Trimmed table mapping
      kFormat6Format = 0,
      kFormat6Length = 2,
      kFormat6Language = 4,
      kFormat6FirstCode = 6,
      kFormat6EntryCount = 8,
      kFormat6GlyphIdArray = 10,

      // Format 8: mixed 16-bit and 32-bit coverage
      kFormat8Format = 0,
      kFormat8Length = 4,
      kFormat8Language = 8,
      kFormat8Is32 = 12,
      kFormat8nGroups204 = 8204,
      kFormat8Groups208 = 8208,
      // offset relative to the group structure
      kFormat8Group_startCharCode = 0,
      kFormat8Group_endCharCode = 4,
      kFormat8Group_startGlyphId = 8,
      kFormat8Group_structLength = 12,

      // Format 10: Trimmed array
      kFormat10Format = 0,
      kFormat10Length = 4,
      kFormat10Language = 8,
      kFormat10StartCharCode = 12,
      kFormat10NumChars = 16,
      kFormat10Glyphs0 = 20,

      // Format 12: Segmented coverage
      kFormat12Format = 0,
      kFormat12Length = 4,
      kFormat12Language = 8,
      kFormat12nGroups = 12,
      kFormat12Groups = 16,
      kFormat12Groups_structLength = 12,
      // offsets within the group structure
      kFormat12_startCharCode = 0,
      kFormat12_endCharCode = 4,
      kFormat12_startGlyphId = 8,

      // Format 13: Last Resort Font
      kFormat13Format = 0,
      kFormat13Length = 4,
      kFormat13Language = 8,
      kFormat13nGroups = 12,
      kFormat13Groups = 16,
      kFormat13Groups_structLength = 12,
      // offsets within the group structure
      kFormat13_startCharCode = 0,
      kFormat13_endCharCode = 4,
      kFormat13_glyphId = 8,

      // Format 14: Unicode Variation Sequences
      kFormat14Format = 0,
      kFormat14Length = 2,

      // TODO(stuartg): finish tables
      // Default UVS Table

      // Non-default UVS Table
      kLast = -1
    };
  };

  CMapTable(Header* header, ReadableFontData* data);

  // Get the offset in the table data for the encoding record for the cmap with
  // the given index. The offset is from the beginning of the table.
  static int32_t OffsetForEncodingRecord(int32_t index);
};
typedef std::vector<CMapTable::CMapId> CMapIdList;
typedef Ptr<CMapTable> CMapTablePtr;
typedef std::vector<Ptr<CMapTable::CMapFormat4::Builder::Segment> > SegmentList;
}  // namespace sfntly

#endif  // SFNTLY_CPP_SRC_SFNTLY_TABLE_CORE_CMAP_TABLE_H_