Readability clean up. The code conforms to Google C++ Coding Style.
git-svn-id: http://sfntly.googlecode.com/svn/trunk/cpp/src@30 672e30a5-4c29-85ac-ac6d-611c735e0a51
diff --git a/sample/subsetter/main.cc b/sample/subsetter/main.cc
index a9e1524..19a3e0e 100644
--- a/sample/subsetter/main.cc
+++ b/sample/subsetter/main.cc
@@ -34,7 +34,7 @@
}
sfntly::SubsetUtil subset_util;
- subset_util.subset(argv[1], argv[2]);
+ subset_util.Subset(argv[1], argv[2]);
#ifdef _CRTDBG_MAP_ALLOC
_CrtDumpMemoryLeaks();
diff --git a/sample/subsetter/subset_util.cc b/sample/subsetter/subset_util.cc
index 013a903..9e4e652 100644
--- a/sample/subsetter/subset_util.cc
+++ b/sample/subsetter/subset_util.cc
@@ -37,7 +37,7 @@
SubsetUtil::~SubsetUtil() {
}
-void SubsetUtil::subset(const char *input_file_path,
+void SubsetUtil::Subset(const char *input_file_path,
const char *output_file_path) {
UNREFERENCED_PARAMETER(output_file_path);
ByteVector input_buffer;
@@ -56,10 +56,10 @@
ByteArrayPtr ba = new MemoryByteArray(&(input_buffer[0]), file_size);
FontFactoryPtr factory;
- factory.attach(FontFactory::getInstance());
+ factory.Attach(FontFactory::GetInstance());
FontArray font_array;
- factory->loadFonts(ba, &font_array);
+ factory->LoadFonts(ba, &font_array);
if (font_array.empty() || font_array[0] == NULL)
return;
@@ -71,25 +71,25 @@
glyphs.push_back(10);
Ptr<Subsetter> subsetter = new Subsetter(font_array[0], factory);
- subsetter->setGlyphs(&glyphs);
+ subsetter->SetGlyphs(&glyphs);
IntegerSet remove_tables;
remove_tables.insert(Tag::DSIG);
- subsetter->setRemoveTables(&remove_tables);
+ subsetter->SetRemoveTables(&remove_tables);
FontBuilderPtr font_builder;
- font_builder.attach(subsetter->subset());
+ font_builder.Attach(subsetter->Subset());
FontPtr new_font;
- new_font.attach(font_builder->build());
+ new_font.Attach(font_builder->Build());
// TODO(arthurhsu): glyph renumbering/Loca table
// TODO(arthurhsu): alter CMaps
MemoryOutputStream output_stream;
- factory->serializeFont(new_font, &output_stream);
+ factory->SerializeFont(new_font, &output_stream);
FILE* output_file = fopen(output_file_path, "wb");
- fwrite(output_stream.get(), 1, output_stream.size(), output_file);
+ fwrite(output_stream.Get(), 1, output_stream.Size(), output_file);
fflush(output_file);
fclose(output_file);
}
diff --git a/sample/subsetter/subset_util.h b/sample/subsetter/subset_util.h
index bea28b8..109d63a 100644
--- a/sample/subsetter/subset_util.h
+++ b/sample/subsetter/subset_util.h
@@ -24,7 +24,7 @@
SubsetUtil();
virtual ~SubsetUtil();
- void subset(const char* input_file_path, const char* output_file_path);
+ void Subset(const char* input_file_path, const char* output_file_path);
};
} // namespace sfntly
diff --git a/sfntly/cmap_table.cc b/sfntly/cmap_table.cc
index 8cbc83e..668dc07 100644
--- a/sfntly/cmap_table.cc
+++ b/sfntly/cmap_table.cc
@@ -30,41 +30,43 @@
/******************************************************************************
* CMapTable class
******************************************************************************/
-CMapTable::CMapTable(Header* header, ReadableFontData* data)
- : Table(header, data) {}
CMapTable::~CMapTable() {}
-int32_t CMapTable::version() {
- return data_->readUShort(Offset::kVersion);
+int32_t CMapTable::Version() {
+ return data_->ReadUShort(Offset::kVersion);
}
-int32_t CMapTable::numCMaps() {
- return data_->readUShort(Offset::kNumTables);
+int32_t CMapTable::NumCMaps() {
+ return data_->ReadUShort(Offset::kNumTables);
}
-int32_t CMapTable::offsetForEncodingRecord(int32_t index) {
+CMapTable::CMapId CMapTable::GetCMapId(int32_t index) {
+ return CMapId(PlatformId(index), EncodingId(index));
+}
+
+int32_t CMapTable::PlatformId(int32_t index) {
+ return data_->ReadUShort(Offset::kEncodingRecordPlatformId +
+ OffsetForEncodingRecord(index));
+}
+
+int32_t CMapTable::EncodingId(int32_t index) {
+ return data_->ReadUShort(Offset::kEncodingRecordEncodingId +
+ OffsetForEncodingRecord(index));
+}
+
+int32_t CMapTable::Offset(int32_t index) {
+ return data_->ReadULongAsInt(Offset::kEncodingRecordOffset +
+ OffsetForEncodingRecord(index));
+}
+
+CMapTable::CMapTable(Header* header, ReadableFontData* data)
+ : Table(header, data) {
+}
+
+int32_t CMapTable::OffsetForEncodingRecord(int32_t index) {
return Offset::kEncodingRecordStart + index * Offset::kEncodingRecordSize;
}
-CMapTable::CMapId CMapTable::cmapId(int32_t index) {
- return CMapId(platformId(index), encodingId(index));
-}
-
-int32_t CMapTable::platformId(int32_t index) {
- return data_->readUShort(Offset::kEncodingRecordPlatformId +
- offsetForEncodingRecord(index));
-}
-
-int32_t CMapTable::encodingId(int32_t index) {
- return data_->readUShort(Offset::kEncodingRecordEncodingId +
- offsetForEncodingRecord(index));
-}
-
-int32_t CMapTable::offset(int32_t index) {
- return data_->readULongAsInt(Offset::kEncodingRecordOffset +
- offsetForEncodingRecord(index));
-}
-
/******************************************************************************
* CMapTable::CMapId class
******************************************************************************/
@@ -76,9 +78,6 @@
: platform_id_(obj.platform_id_), encoding_id_(obj.encoding_id_) {
}
-int32_t CMapTable::CMapId::platformId() { return platform_id_; }
-int32_t CMapTable::CMapId::encodingId() { return encoding_id_; }
-
bool CMapTable::CMapId::operator==(const CMapTable::CMapId& obj) {
return obj.platform_id_ == platform_id_ && obj.encoding_id_ == encoding_id_;
}
@@ -90,7 +89,7 @@
return *this;
}
-int CMapTable::CMapId::hashCode() const {
+int CMapTable::CMapId::HashCode() const {
return platform_id_ << 8 | encoding_id_;
}
@@ -106,7 +105,7 @@
bool CMapTable::CMapIdComparator::operator()(const CMapId& lhs,
const CMapId& rhs) {
- return lhs.hashCode() > rhs.hashCode();
+ return lhs.HashCode() > rhs.HashCode();
}
/******************************************************************************
@@ -117,101 +116,102 @@
: SubTable(data), format_(format), cmap_id_(cmap_id) {
}
-CMapTable::CMap::~CMap() {}
-int32_t CMapTable::CMap::format() { return format_; }
-CMapTable::CMapId CMapTable::CMap::cmapId() { return cmap_id_; }
-int32_t CMapTable::CMap::platformId() { return cmap_id_.platformId(); }
-int32_t CMapTable::CMap::encodingId() { return cmap_id_.encodingId(); }
+CMapTable::CMap::~CMap() {
+}
/******************************************************************************
* CMapTable::CMap::Builder class
******************************************************************************/
+CMapTable::CMap::Builder::~Builder() {
+}
+
+CALLER_ATTACH CMapTable::CMap::Builder*
+ CMapTable::CMap::Builder::GetBuilder(
+ FontDataTableBuilderContainer* container,
+ ReadableFontData* data,
+ int32_t offset,
+ const CMapId& cmap_id) {
+ // NOT IMPLEMENTED: Java enum value validation
+ int32_t format = data->ReadUShort(offset);
+ CMapBuilderPtr builder;
+ switch (format) {
+ case CMapFormat::kFormat0:
+ builder = new CMapFormat0::Builder(container, data, offset, cmap_id);
+ break;
+ case CMapFormat::kFormat2:
+ builder = new CMapFormat0::Builder(container, data, offset, cmap_id);
+ break;
+ default:
+ break;
+ }
+ return builder.Detach();
+}
+
CMapTable::CMap::Builder::Builder(FontDataTableBuilderContainer* container,
ReadableFontData* data, int32_t format,
const CMapId& cmap_id)
- : SubTable::Builder(container, data), format_(format), cmap_id_(cmap_id) {
+ : SubTable::Builder(container, data),
+ format_(format),
+ cmap_id_(cmap_id) {
}
CMapTable::CMap::Builder::Builder(FontDataTableBuilderContainer* container,
WritableFontData* data, int32_t format,
const CMapId& cmap_id)
- : SubTable::Builder(container, data), format_(format), cmap_id_(cmap_id) {
+ : SubTable::Builder(container, data),
+ format_(format),
+ cmap_id_(cmap_id) {
}
-CMapTable::CMap::Builder::~Builder() {}
-
-CMapTable::CMapId CMapTable::CMap::Builder::cmapId() {
- return cmap_id_;
+int32_t CMapTable::CMap::Builder::SubSerialize(WritableFontData* new_data) {
+ return InternalReadData()->CopyTo(new_data);
}
-int32_t CMapTable::CMap::Builder::platformId() {
- return cmap_id_.platformId();
-}
-
-int32_t CMapTable::CMap::Builder::encodingId() {
- return cmap_id_.encodingId();
-}
-
-int32_t CMapTable::CMap::Builder::subSerialize(WritableFontData* new_data) {
- return internalReadData()->copyTo(new_data);
-}
-
-bool CMapTable::CMap::Builder::subReadyToSerialize() {
+bool CMapTable::CMap::Builder::SubReadyToSerialize() {
return true;
}
-int32_t CMapTable::CMap::Builder::subDataSizeToSerialize() {
- return internalReadData()->length();
+int32_t CMapTable::CMap::Builder::SubDataSizeToSerialize() {
+ return InternalReadData()->Length();
}
-void CMapTable::CMap::Builder::subDataSet() {
+void CMapTable::CMap::Builder::SubDataSet() {
// NOP
}
-CALLER_ATTACH CMapTable::CMap::Builder* CMapTable::CMap::Builder::getBuilder(
- FontDataTableBuilderContainer* container, ReadableFontData* data,
- int32_t offset, const CMapId& cmap_id) {
- // NOT IMPLEMENTED: Java enum value validation
- int32_t format = data->readUShort(offset);
- CMapBuilderPtr builder;
- switch (format) {
- case CMapFormat::kFormat0:
- builder = new CMapFormat0::Builder(container, data, offset, cmap_id);
- case CMapFormat::kFormat2:
- builder = new CMapFormat0::Builder(container, data, offset, cmap_id);
- default:
- break;
- }
- return builder.detach();
+/******************************************************************************
+ * CMapTable::CMapFormat0
+ ******************************************************************************/
+CMapTable::CMapFormat0::~CMapFormat0() {
}
-/******************************************************************************
- * CMapTable::CMapFormat0 and CMapTable::CMapFormat0::Builder
- ******************************************************************************/
+int32_t CMapTable::CMapFormat0::Language() {
+ return 0;
+}
+
+int32_t CMapTable::CMapFormat0::GlyphId(int32_t character) {
+ if (character < 0 || character > 255) {
+ return CMapTable::NOTDEF;
+ }
+ return data_->ReadByte(character + Offset::kFormat0GlyphIdArray);
+}
+
CMapTable::CMapFormat0::CMapFormat0(ReadableFontData* data,
const CMapId& cmap_id)
: CMap(data, CMapFormat::kFormat0, cmap_id) {
}
-CMapTable::CMapFormat0::~CMapFormat0() {}
-
-int32_t CMapTable::CMapFormat0::glyphId(int32_t character) {
- if (character < 0 || character > 255) {
- return CMapTable::NOTDEF;
- }
- return data_->readByte(character + Offset::kFormat0GlyphIdArray);
-}
-
-int32_t CMapTable::CMapFormat0::language() {
- return 0;
-}
-
+/******************************************************************************
+ * CMapTable::CMapFormat0::Builder
+ ******************************************************************************/
CMapTable::CMapFormat0::Builder::Builder(
- FontDataTableBuilderContainer* container, WritableFontData* data,
- int32_t offset, const CMapId& cmap_id)
+ FontDataTableBuilderContainer* container,
+ WritableFontData* data,
+ int32_t offset,
+ const CMapId& cmap_id)
: CMapTable::CMap::Builder(container,
data ? down_cast<WritableFontData*>(
- data->slice(offset, data->readUShort(
+ data->Slice(offset, data->ReadUShort(
offset + Offset::kFormat0Length)))
: reinterpret_cast<WritableFontData*>(NULL),
CMapFormat::kFormat0, cmap_id) {
@@ -219,101 +219,68 @@
}
CMapTable::CMapFormat0::Builder::Builder(
- FontDataTableBuilderContainer* container, ReadableFontData* data,
- int32_t offset, const CMapId& cmap_id)
+ FontDataTableBuilderContainer* container,
+ ReadableFontData* data,
+ int32_t offset,
+ const CMapId& cmap_id)
: CMapTable::CMap::Builder(container,
data ? down_cast<ReadableFontData*>(
- data->slice(offset, data->readUShort(
+ data->Slice(offset, data->ReadUShort(
offset + Offset::kFormat0Length)))
: reinterpret_cast<WritableFontData*>(NULL),
CMapFormat::kFormat0, cmap_id) {
// TODO(arthurhsu): FIXIT: heavy lifting and leak, need fix.
}
-CMapTable::CMapFormat0::Builder::~Builder() {}
+CMapTable::CMapFormat0::Builder::~Builder() {
+}
-CALLER_ATTACH FontDataTable* CMapTable::CMapFormat0::Builder::subBuildTable(
- ReadableFontData* data) {
- FontDataTablePtr table = new CMapFormat0(data, cmapId());
- return table.detach();
+CALLER_ATTACH FontDataTable*
+ CMapTable::CMapFormat0::Builder::SubBuildTable(ReadableFontData* data) {
+ FontDataTablePtr table = new CMapFormat0(data, cmap_id());
+ return table.Detach();
}
/******************************************************************************
- * CMapTable::CMapFormat2 and CMapTable::CMapFormat2::Builder
+ * CMapTable::CMapFormat2
******************************************************************************/
-CMapTable::CMapFormat2::CMapFormat2(ReadableFontData* data,
- const CMapId& cmap_id)
- : CMap(data, CMapFormat::kFormat2, cmap_id) {
+CMapTable::CMapFormat2::~CMapFormat2() {
}
-CMapTable::CMapFormat2::~CMapFormat2() {}
-
-int32_t CMapTable::CMapFormat2::subHeaderOffset(int32_t sub_header_index) {
- return data_->readUShort(Offset::kFormat2SubHeaderKeys + sub_header_index *
- DataSize::kUSHORT);
+int32_t CMapTable::CMapFormat2::Language() {
+ return 0;
}
-int32_t CMapTable::CMapFormat2::firstCode(int32_t sub_header_index) {
- int32_t sub_header_offset = subHeaderOffset(sub_header_index);
- return data_->readUShort(sub_header_offset + Offset::kFormat2SubHeaderKeys +
- Offset::kFormat2SubHeader_firstCode);
-}
-
-int32_t CMapTable::CMapFormat2::entryCount(int32_t sub_header_index) {
- int32_t sub_header_offset = subHeaderOffset(sub_header_index);
- return data_->readUShort(sub_header_offset + Offset::kFormat2SubHeaderKeys +
- Offset::kFormat2SubHeader_entryCount);
-}
-
-int32_t CMapTable::CMapFormat2::idRangeOffset(int32_t sub_header_index) {
- int32_t sub_header_offset = subHeaderOffset(sub_header_index);
- return data_->readUShort(sub_header_offset + Offset::kFormat2SubHeaderKeys +
- Offset::kFormat2SubHeader_idRangeOffset);
-}
-
-int32_t CMapTable::CMapFormat2::idDelta(int32_t sub_header_index) {
- int32_t sub_header_offset = subHeaderOffset(sub_header_index);
- return data_->readUShort(sub_header_offset + Offset::kFormat2SubHeaderKeys +
- Offset::kFormat2SubHeader_idDelta);
-}
-
-int32_t CMapTable::CMapFormat2::bytesConsumed(int32_t character) {
- uint32_t c = toBE32(character);
- int32_t high_byte = (c >> 8) & 0xff;
- int32_t offset = subHeaderOffset(high_byte);
- return (offset == 0) ? 1 : 2;
-}
-
-int32_t CMapTable::CMapFormat2::glyphId(int32_t character) {
+int32_t CMapTable::CMapFormat2::GlyphId(int32_t character) {
if (character > 0xffff) {
return CMapTable::NOTDEF;
}
- uint32_t c = toBE32(character);
+ uint32_t c = ToBE32(character);
byte_t high_byte = (c >> 8) & 0xff;
byte_t low_byte = c & 0xff;
- int32_t offset = subHeaderOffset(high_byte);
+ int32_t offset = SubHeaderOffset(high_byte);
if (offset == 0) {
low_byte = high_byte;
high_byte = 0;
}
- int32_t first_code = firstCode(high_byte);
- int32_t entry_count = entryCount(high_byte);
+ int32_t first_code = FirstCode(high_byte);
+ int32_t entry_count = EntryCount(high_byte);
if (low_byte < first_code || low_byte >= first_code + entry_count) {
return CMapTable::NOTDEF;
}
- int32_t id_range_offset = idRangeOffset(high_byte);
+ int32_t id_range_offset = IdRangeOffset(high_byte);
// position of idRangeOffset + value of idRangeOffset + index for low byte
// = firstcode
int32_t p_location = (offset + Offset::kFormat2SubHeader_idRangeOffset) +
id_range_offset +
(low_byte - first_code) * DataSize::kUSHORT;
- int p = data_->readUShort(p_location);
+ int p = data_->ReadUShort(p_location);
if (p == 0) {
return CMapTable::NOTDEF;
}
@@ -321,20 +288,66 @@
if (offset == 0) {
return p;
}
- int id_delta = idDelta(high_byte);
+ int id_delta = IdDelta(high_byte);
return (p + id_delta) % 65536;
}
-int32_t CMapTable::CMapFormat2::language() {
- return 0;
+int32_t CMapTable::CMapFormat2::BytesConsumed(int32_t character) {
+ uint32_t c = ToBE32(character);
+ int32_t high_byte = (c >> 8) & 0xff;
+ int32_t offset = SubHeaderOffset(high_byte);
+ return (offset == 0) ? 1 : 2;
}
+CMapTable::CMapFormat2::CMapFormat2(ReadableFontData* data,
+ const CMapId& cmap_id)
+ : CMap(data, CMapFormat::kFormat2, cmap_id) {
+}
+
+int32_t CMapTable::CMapFormat2::SubHeaderOffset(int32_t sub_header_index) {
+ return data_->ReadUShort(Offset::kFormat2SubHeaderKeys +
+ sub_header_index * DataSize::kUSHORT);
+}
+
+int32_t CMapTable::CMapFormat2::FirstCode(int32_t sub_header_index) {
+ int32_t sub_header_offset = SubHeaderOffset(sub_header_index);
+ return data_->ReadUShort(sub_header_offset +
+ Offset::kFormat2SubHeaderKeys +
+ Offset::kFormat2SubHeader_firstCode);
+}
+
+int32_t CMapTable::CMapFormat2::EntryCount(int32_t sub_header_index) {
+ int32_t sub_header_offset = SubHeaderOffset(sub_header_index);
+ return data_->ReadUShort(sub_header_offset +
+ Offset::kFormat2SubHeaderKeys +
+ Offset::kFormat2SubHeader_entryCount);
+}
+
+int32_t CMapTable::CMapFormat2::IdRangeOffset(int32_t sub_header_index) {
+ int32_t sub_header_offset = SubHeaderOffset(sub_header_index);
+ return data_->ReadUShort(sub_header_offset +
+ Offset::kFormat2SubHeaderKeys +
+ Offset::kFormat2SubHeader_idRangeOffset);
+}
+
+int32_t CMapTable::CMapFormat2::IdDelta(int32_t sub_header_index) {
+ int32_t sub_header_offset = SubHeaderOffset(sub_header_index);
+ return data_->ReadUShort(sub_header_offset +
+ Offset::kFormat2SubHeaderKeys +
+ Offset::kFormat2SubHeader_idDelta);
+}
+
+/******************************************************************************
+ * CMapTable::CMapFormat2::Builder
+ ******************************************************************************/
CMapTable::CMapFormat2::Builder::Builder(
- FontDataTableBuilderContainer* container, WritableFontData* data,
- int32_t offset, const CMapId& cmap_id)
+ FontDataTableBuilderContainer* container,
+ WritableFontData* data,
+ int32_t offset,
+ const CMapId& cmap_id)
: CMapTable::CMap::Builder(container,
data ? down_cast<WritableFontData*>(
- data->slice(offset, data->readUShort(
+ data->Slice(offset, data->ReadUShort(
offset + Offset::kFormat0Length)))
: reinterpret_cast<WritableFontData*>(NULL),
CMapFormat::kFormat2, cmap_id) {
@@ -342,23 +355,26 @@
}
CMapTable::CMapFormat2::Builder::Builder(
- FontDataTableBuilderContainer* container, ReadableFontData* data,
- int32_t offset, const CMapId& cmap_id)
+ FontDataTableBuilderContainer* container,
+ ReadableFontData* data,
+ int32_t offset,
+ const CMapId& cmap_id)
: CMapTable::CMap::Builder(container,
data ? down_cast<ReadableFontData*>(
- data->slice(offset, data->readUShort(
+ data->Slice(offset, data->ReadUShort(
offset + Offset::kFormat0Length)))
: reinterpret_cast<ReadableFontData*>(NULL),
CMapFormat::kFormat2, cmap_id) {
// TODO(arthurhsu): FIXIT: heavy lifting and leak, need fix.
}
-CMapTable::CMapFormat2::Builder::~Builder() {}
+CMapTable::CMapFormat2::Builder::~Builder() {
+}
-CALLER_ATTACH FontDataTable* CMapTable::CMapFormat2::Builder::subBuildTable(
- ReadableFontData* data) {
- FontDataTablePtr table = new CMapFormat2(data, cmapId());
- return table.detach();
+CALLER_ATTACH FontDataTable*
+ CMapTable::CMapFormat2::Builder::SubBuildTable(ReadableFontData* data) {
+ FontDataTablePtr table = new CMapFormat2(data, cmap_id());
+ return table.Detach();
}
/******************************************************************************
@@ -367,16 +383,16 @@
CMapTable::CMapIterator::CMapIterator(CMapTable* table, CMapFilter* filter)
: table_index_(0), filter_(filter), table_(table) {}
-bool CMapTable::CMapIterator::hasNext() {
+bool CMapTable::CMapIterator::HasNext() {
if (!filter_) {
- if (table_index_ < table_->numCMaps()) {
+ if (table_index_ < table_->NumCMaps()) {
return true;
}
return false;
}
- for (; table_index_ < table_->numCMaps(); ++table_index_) {
- if (filter_->accept(table_->cmapId(table_index_))) {
+ for (; table_index_ < table_->NumCMaps(); ++table_index_) {
+ if (filter_->accept(table_->GetCMapId(table_index_))) {
return true;
}
}
@@ -387,105 +403,109 @@
* CMapTable::Builder class
******************************************************************************/
CMapTable::Builder::Builder(FontDataTableBuilderContainer* font_builder,
- Header* header, WritableFontData* data)
+ Header* header,
+ WritableFontData* data)
: Table::ArrayElementTableBuilder(font_builder, header, data) {
}
CMapTable::Builder::Builder(FontDataTableBuilderContainer* font_builder,
- Header* header, ReadableFontData* data)
+ Header* header,
+ ReadableFontData* data)
: Table::ArrayElementTableBuilder(font_builder, header, data) {
}
-int32_t CMapTable::Builder::subSerialize(WritableFontData* new_data) {
- int32_t size = new_data->writeUShort(CMapTable::Offset::kVersion,
+CMapTable::Builder::~Builder() {
+}
+
+int32_t CMapTable::Builder::SubSerialize(WritableFontData* new_data) {
+ int32_t size = new_data->WriteUShort(CMapTable::Offset::kVersion,
version_);
- size += new_data->writeUShort(CMapTable::Offset::kNumTables,
+ size += new_data->WriteUShort(CMapTable::Offset::kNumTables,
cmap_builders_.size());
int32_t index_offset = size;
size += cmap_builders_.size() * CMapTable::Offset::kEncodingRecordSize;
for (CMapBuilderMap::iterator it = cmap_builders_.begin(),
- e = cmap_builders_.end(); it != e; ++it) {
+ e = cmap_builders_.end(); it != e; ++it) {
CMapBuilderPtr b = it->second;
// header entry
- index_offset += new_data->writeUShort(index_offset, b->platformId());
- index_offset += new_data->writeUShort(index_offset, b->encodingId());
- index_offset += new_data->writeULong(index_offset, size);
+ index_offset += new_data->WriteUShort(index_offset, b->platform_id());
+ index_offset += new_data->WriteUShort(index_offset, b->encoding_id());
+ index_offset += new_data->WriteULong(index_offset, size);
// cmap
FontDataPtr slice;
- slice.attach(new_data->slice(size));
- size +=
- b->subSerialize(down_cast<WritableFontData*>(slice.p_));
+ slice.Attach(new_data->Slice(size));
+ size += b->SubSerialize(down_cast<WritableFontData*>(slice.p_));
}
return size;
}
-bool CMapTable::Builder::subReadyToSerialize() {
+bool CMapTable::Builder::SubReadyToSerialize() {
if (cmap_builders_.empty())
return false;
// check each table
for (CMapBuilderMap::iterator it = cmap_builders_.begin(),
- e = cmap_builders_.end(); it != e; ++it) {
- if (!it->second->subReadyToSerialize())
+ e = cmap_builders_.end(); it != e; ++it) {
+ if (!it->second->SubReadyToSerialize())
return false;
}
return true;
}
-int32_t CMapTable::Builder::subDataSizeToSerialize() {
+int32_t CMapTable::Builder::SubDataSizeToSerialize() {
if (cmap_builders_.empty())
return 0;
bool variable = false;
int32_t size = CMapTable::Offset::kEncodingRecordStart +
- cmap_builders_.size() * CMapTable::Offset::kEncodingRecordSize;
+ cmap_builders_.size() * CMapTable::Offset::kEncodingRecordSize;
// calculate size of each table
for (CMapBuilderMap::iterator it = cmap_builders_.begin(),
- e = cmap_builders_.end(); it != e; ++it) {
- int32_t cmap_size = it->second->subDataSizeToSerialize();
+ e = cmap_builders_.end(); it != e; ++it) {
+ int32_t cmap_size = it->second->SubDataSizeToSerialize();
size += abs(cmap_size);
variable |= cmap_size <= 0;
}
return variable ? -size : size;
}
-void CMapTable::Builder::subDataSet() {
+void CMapTable::Builder::SubDataSet() {
cmap_builders_.clear();
- Table::Builder::setModelChanged(false);
+ Table::Builder::set_model_changed(false);
}
-CALLER_ATTACH FontDataTable* CMapTable::Builder::subBuildTable(
- ReadableFontData* data) {
+CALLER_ATTACH FontDataTable*
+ CMapTable::Builder::SubBuildTable(ReadableFontData* data) {
FontDataTablePtr table = new CMapTable(header(), data);
- return table.detach();
+ return table.Detach();
}
-CALLER_ATTACH CMapTable::CMap::Builder* CMapTable::Builder::cmapBuilder(
+CALLER_ATTACH CMapTable::CMap::Builder* CMapTable::Builder::CMapBuilder(
FontDataTableBuilderContainer* container, ReadableFontData* data,
int32_t index) {
- if (index < 0 || index > numCMaps(data))
+ if (index < 0 || index > NumCMaps(data))
return NULL;
int32_t record_offset = Offset::kEncodingRecordOffset + index *
Offset::kEncodingRecordSize;
- int32_t platform_id = data->readUShort(Offset::kEncodingRecordPlatformId +
- record_offset);
- int32_t encoding_id = data->readUShort(Offset::kEncodingRecordEncodingId +
- record_offset);
+ int32_t platform_id =
+ data->ReadUShort(Offset::kEncodingRecordPlatformId + record_offset);
+ int32_t encoding_id =
+ data->ReadUShort(Offset::kEncodingRecordEncodingId + record_offset);
CMapId cmap_id(platform_id, encoding_id);
- int32_t offset = data->readULongAsInt(Offset::kEncodingRecordOffset +
- record_offset);
- return CMap::Builder::getBuilder(container, data, offset, cmap_id);
+ int32_t offset =
+ data->ReadULongAsInt(Offset::kEncodingRecordOffset + record_offset);
+ return CMap::Builder::GetBuilder(container, data, offset, cmap_id);
}
-int32_t CMapTable::Builder::numCMaps(ReadableFontData* data) {
+int32_t CMapTable::Builder::NumCMaps(ReadableFontData* data) {
if (data == NULL) {
return 0;
}
- return data->readUShort(Offset::kNumTables);
+ return data->ReadUShort(Offset::kNumTables);
}
} // namespace sfntly
diff --git a/sfntly/cmap_table.h b/sfntly/cmap_table.h
index a102b82..cdbcad8 100644
--- a/sfntly/cmap_table.h
+++ b/sfntly/cmap_table.h
@@ -44,6 +44,268 @@
// A CMap table
class CMapTable : public Table, public RefCounted<CMapTable> {
+public:
+ // CMapTable::CMapId
+ class CMapId {
+ public:
+ CMapId(int32_t platform_id, int32_t encoding_id);
+ CMapId(const CMapId& obj);
+
+ int32_t platform_id() { return platform_id_; }
+ int32_t encoding_id() { return encoding_id_; }
+
+ bool operator==(const CMapId& obj);
+ const CMapId& operator=(const CMapId& obj);
+ int HashCode() const;
+
+ friend class CMapIdComparator;
+
+ private:
+ int32_t platform_id_;
+ int32_t 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);
+ };
+
+ // 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(CMapId cmap_id) = 0;
+ // Make gcc -Wnon-virtual-dtor happy.
+ virtual ~CMapFilter() {}
+ };
+
+ // 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 implements {@code Iterable<Integer>} 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(FontDataTableBuilderContainer* container,
+ ReadableFontData* data,
+ int32_t offset,
+ 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(); }
+
+ protected:
+ Builder(FontDataTableBuilderContainer* container,
+ ReadableFontData* data,
+ int32_t format,
+ const CMapId& cmap_id);
+ Builder(FontDataTableBuilderContainer* container,
+ 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_;
+
+ friend class CMapTable::Builder;
+ };
+
+ CMap(ReadableFontData* data, int32_t format, const CMapId& cmap_id);
+ virtual ~CMap();
+ 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::Builder> CMapBuilderPtr;
+ typedef std::map<CMapId, CMapBuilderPtr, CMapIdComparator> CMapBuilderMap;
+
+ // A cmap format 0 sub table
+ class CMapFormat0 : public CMap, public RefCounted<CMapFormat0> {
+ public:
+ // CMapTable::CMapFormat0::Builder
+ class Builder : public CMap::Builder,
+ public RefCounted<Builder> {
+ public:
+ Builder(FontDataTableBuilderContainer* container,
+ ReadableFontData* data,
+ int32_t offset,
+ const CMapId& cmap_id);
+ Builder(FontDataTableBuilderContainer* container,
+ WritableFontData* data,
+ int32_t offset,
+ const CMapId& cmap_id);
+ virtual ~Builder();
+
+ protected:
+ virtual CALLER_ATTACH FontDataTable*
+ SubBuildTable(ReadableFontData* data);
+ };
+
+ virtual ~CMapFormat0();
+ virtual int32_t Language();
+ virtual int32_t GlyphId(int32_t character);
+
+ 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(FontDataTableBuilderContainer* container,
+ ReadableFontData* data,
+ int32_t offset,
+ const CMapId& cmap_id);
+ Builder(FontDataTableBuilderContainer* container,
+ WritableFontData* data,
+ int32_t offset,
+ const CMapId& cmap_id);
+ virtual ~Builder();
+
+ protected:
+ virtual CALLER_ATTACH FontDataTable*
+ SubBuildTable(ReadableFontData* data);
+ };
+
+ virtual ~CMapFormat2();
+ 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);
+
+ 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);
+ };
+
+ // CMapTable::Builder
+ class Builder : public Table::ArrayElementTableBuilder,
+ public RefCounted<Builder> {
+ public:
+ // Constructor scope altered to public because C++ does not allow base
+ // class to instantiate derived class with protected constructors.
+ Builder(FontDataTableBuilderContainer* font_builder,
+ Header* header,
+ WritableFontData* data);
+ Builder(FontDataTableBuilderContainer* font_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);
+
+ protected:
+ static CALLER_ATTACH CMap::Builder*
+ CMapBuilder(FontDataTableBuilderContainer* container,
+ ReadableFontData* data,
+ int32_t index);
+
+ private:
+ static int32_t NumCMaps(ReadableFontData* data);
+
+ int32_t version_;
+ CMapBuilderMap cmap_builders_;
+ };
+
+ virtual ~CMapTable();
+
+ // 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);
+
private:
static const int32_t NOTDEF;
@@ -158,238 +420,12 @@
};
};
- public:
- // CMapTable::CMapId
- class CMapId {
- public:
- CMapId(int32_t platform_id, int32_t encoding_id);
- CMapId(const CMapId& obj);
- int32_t platformId();
- int32_t encodingId();
- bool operator==(const CMapId& obj);
- const CMapId& operator=(const CMapId& obj);
- int hashCode() const;
-
- friend class CMapIdComparator;
-
- private:
- int32_t platform_id_;
- int32_t 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);
- };
-
- // 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(CMapId cmap_id) = 0;
- // Make gcc -Wnon-virtual-dtor happy.
- virtual ~CMapFilter() {}
- };
-
- // 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 implements {@code Iterable<Integer>} 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:
- CMap(ReadableFontData* data, int32_t format, const CMapId& cmap_id);
- virtual ~CMap();
- virtual int32_t format();
- virtual CMapId cmapId();
- virtual int32_t platformId();
- virtual int32_t encodingId();
-
- // 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;
-
- public:
- // CMapTable::CMap::Builder
- class Builder : public SubTable::Builder {
- public:
- friend class CMapTable::Builder;
-
- protected:
- Builder(FontDataTableBuilderContainer* container, ReadableFontData* data,
- int32_t format, const CMapId& cmap_id);
- Builder(FontDataTableBuilderContainer* container, WritableFontData* data,
- int32_t format, const CMapId& cmap_id);
-
- public:
- virtual ~Builder();
- CALLER_ATTACH static Builder*
- getBuilder(FontDataTableBuilderContainer* container,
- ReadableFontData* data, int32_t offset,
- const CMapId& cmap_id);
-
- // Note: yes, an object is returned on stack since it's small enough.
- virtual CMapId cmapId();
- virtual int32_t platformId();
- virtual int32_t encodingId();
-
- protected:
- virtual int32_t subSerialize(WritableFontData* new_data);
- virtual bool subReadyToSerialize();
- virtual int32_t subDataSizeToSerialize();
- virtual void subDataSet();
-
- private:
- int32_t format_;
- CMapId cmap_id_;
- };
-
- private:
- int32_t format_;
- CMapId cmap_id_;
- };
- 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> {
- protected:
- CMapFormat0(ReadableFontData* data, const CMapId& cmap_id);
-
- public:
- virtual ~CMapFormat0();
- virtual int32_t language();
- virtual int32_t glyphId(int32_t character);
-
- // CMapTable::CMapFormat0::Builder
- class Builder : public CMap::Builder,
- public RefCounted<Builder> {
- public:
- Builder(FontDataTableBuilderContainer* container, ReadableFontData* data,
- int32_t offset, const CMapId& cmap_id);
- Builder(FontDataTableBuilderContainer* container, WritableFontData* data,
- int32_t offset, const CMapId& cmap_id);
- virtual ~Builder();
- protected:
- virtual CALLER_ATTACH FontDataTable*
- subBuildTable(ReadableFontData* data);
- };
- };
-
- // 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> {
- protected:
- CMapFormat2(ReadableFontData* data, const CMapId& cmap_id);
-
- public:
- virtual ~CMapFormat2();
- 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);
-
- private:
- 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);
-
- // CMapTable::CMapFormat2::Builder
- class Builder : public CMap::Builder,
- public RefCounted<Builder> {
- public:
- Builder(FontDataTableBuilderContainer* container, ReadableFontData* data,
- int32_t offset, const CMapId& cmap_id);
- Builder(FontDataTableBuilderContainer* container, WritableFontData* data,
- int32_t offset, const CMapId& cmap_id);
- virtual ~Builder();
- protected:
- virtual CALLER_ATTACH FontDataTable*
- subBuildTable(ReadableFontData* data);
- };
- };
-
- // CMapTable::Builder
- class Builder : public Table::ArrayElementTableBuilder,
- public RefCounted<Builder> {
- public:
- // Constructor scope altered to public because C++ does not allow base
- // class to instantiate derived class with protected constructors.
- Builder(FontDataTableBuilderContainer* font_builder, Header* header,
- WritableFontData* data);
- Builder(FontDataTableBuilderContainer* font_builder, Header* header,
- ReadableFontData* data);
-
- virtual int32_t subSerialize(WritableFontData* new_data);
- virtual bool subReadyToSerialize();
- virtual int32_t subDataSizeToSerialize();
- virtual void subDataSet();
- virtual CALLER_ATTACH FontDataTable* subBuildTable(ReadableFontData* data);
-
- protected:
- static CALLER_ATTACH CMap::Builder* cmapBuilder(
- FontDataTableBuilderContainer* container, ReadableFontData* data,
- int32_t index);
-
- private:
- static int32_t numCMaps(ReadableFontData* data);
-
- private:
- int32_t version_;
- CMapBuilderMap cmap_builders_;
- };
-
- private:
class CMapIterator {
public:
// If filter is NULL, filter through all tables.
CMapIterator(CMapTable* table, CMapFilter* filter);
- bool hasNext();
- CMap* next();
+ bool HasNext();
+ CMap* Next();
private:
int32_t table_index_;
@@ -397,33 +433,11 @@
CMapTable* table_;
};
- private:
CMapTable(Header* header, ReadableFontData* data);
- public:
- virtual ~CMapTable();
-
- // 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.
- virtual CMapId cmapId(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);
-
- private:
// 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.
- int32_t offsetForEncodingRecord(int32_t index);
+ int32_t OffsetForEncodingRecord(int32_t index);
};
typedef std::vector<CMapTable::CMapId> CMapIdList;
typedef Ptr<CMapTable> CMapTablePtr;
diff --git a/sfntly/data/byte_array.cc b/sfntly/data/byte_array.cc
index b8c3717..5502185 100644
--- a/sfntly/data/byte_array.cc
+++ b/sfntly/data/byte_array.cc
@@ -14,52 +14,38 @@
* limitations under the License.
*/
+#include "sfntly/data/byte_array.h"
+
#include <algorithm>
-#include "sfntly/data/byte_array.h"
#include "sfntly/port/exception_type.h"
namespace sfntly {
const int32_t ByteArray::COPY_BUFFER_SIZE = 8192;
-void ByteArray::init(int32_t filled_length, int32_t storage_length,
- bool growable) {
- storage_length_ = storage_length;
- growable_ = growable;
- setFilledLength(filled_length);
-}
-
-ByteArray::ByteArray(int32_t filled_length, int32_t storage_length,
- bool growable) {
- init(filled_length, storage_length, growable);
-}
-
-ByteArray::ByteArray(int32_t filled_length, int32_t storage_length) {
- init(filled_length, storage_length, false);
-}
-
ByteArray::~ByteArray() {}
-int32_t ByteArray::length() { return filled_length_; }
-int32_t ByteArray::size() { return storage_length_; }
-bool ByteArray::growable() { return growable_; }
+int32_t ByteArray::Length() { return filled_length_; }
+int32_t ByteArray::Size() { return storage_length_; }
-int32_t ByteArray::setFilledLength(int32_t filled_length) {
+int32_t ByteArray::SetFilledLength(int32_t filled_length) {
filled_length_ = std::min<int32_t>(filled_length, storage_length_);
return filled_length_;
}
-byte_t ByteArray::get(int32_t index) {
- return internalGet(index);
+byte_t ByteArray::Get(int32_t index) {
+ return InternalGet(index);
}
-int32_t ByteArray::get(int32_t index, ByteVector* b) {
+int32_t ByteArray::Get(int32_t index, ByteVector* b) {
assert(b);
- return get(index, b, 0, b->size());
+ return Get(index, b, 0, b->size());
}
-int32_t ByteArray::get(int32_t index, ByteVector* b, int32_t offset,
+int32_t ByteArray::Get(int32_t index,
+ ByteVector* b,
+ int32_t offset,
int32_t length) {
assert(b);
if (index < 0 || index >= filled_length_) {
@@ -69,47 +55,49 @@
if (actual_length < 0) {
return -1;
}
- return internalGet(index, b, offset, actual_length);
+ return InternalGet(index, b, offset, actual_length);
}
-bool ByteArray::put(int32_t index, byte_t b) {
- if (index < 0 || index >= size()) {
+bool ByteArray::Put(int32_t index, byte_t b) {
+ if (index < 0 || index >= Size()) {
return false;
}
- bool result = internalPut(index, b);
+ bool result = InternalPut(index, b);
filled_length_ = std::max<int32_t>(filled_length_, index + 1);
return result;
}
-int32_t ByteArray::put(int index, ByteVector* b) {
+int32_t ByteArray::Put(int index, ByteVector* b) {
assert(b);
- return put(index, b, 0, b->size());
+ return Put(index, b, 0, b->size());
}
-int32_t ByteArray::put(int32_t index, ByteVector* b, int32_t offset,
+int32_t ByteArray::Put(int32_t index,
+ ByteVector* b,
+ int32_t offset,
int32_t length) {
assert(b);
- if (index < 0 || index >= size()) {
+ if (index < 0 || index >= Size()) {
return 0;
}
- int32_t actual_length = std::min<int32_t>(length, size() - index);
- int32_t bytes_written = internalPut(index, b, offset, actual_length);
+ int32_t actual_length = std::min<int32_t>(length, Size() - index);
+ int32_t bytes_written = InternalPut(index, b, offset, actual_length);
filled_length_ = std::max<int32_t>(filled_length_, index + bytes_written);
return bytes_written;
}
-int32_t ByteArray::copyTo(ByteArray* array) {
- return copyTo(array, 0, length());
+int32_t ByteArray::CopyTo(ByteArray* array) {
+ return CopyTo(array, 0, Length());
}
-int32_t ByteArray::copyTo(ByteArray* array, int32_t offset, int32_t length) {
- return copyTo(0, array, offset, length);
+int32_t ByteArray::CopyTo(ByteArray* array, int32_t offset, int32_t length) {
+ return CopyTo(0, array, offset, length);
}
-int32_t ByteArray::copyTo(int32_t dst_offset, ByteArray* array,
+int32_t ByteArray::CopyTo(int32_t dst_offset, ByteArray* array,
int32_t src_offset, int32_t length) {
assert(array);
- if (array->size() < dst_offset + length) { // insufficient space
+ if (array->Size() < dst_offset + length) { // insufficient space
return -1;
}
@@ -118,8 +106,8 @@
int32_t index = 0;
int32_t remaining_length = length;
int32_t buffer_length = std::min<int32_t>(COPY_BUFFER_SIZE, length);
- while ((bytes_read = get(index + src_offset, &b, 0, buffer_length)) > 0) {
- int bytes_written = array->put(index + dst_offset, &b, 0, bytes_read);
+ while ((bytes_read = Get(index + src_offset, &b, 0, buffer_length)) > 0) {
+ int bytes_written = array->Put(index + dst_offset, &b, 0, bytes_read);
if (bytes_written != bytes_read) {
#if defined (SFNTLY_NO_EXCEPTION)
return 0;
@@ -134,31 +122,30 @@
return index;
}
-int32_t ByteArray::copyTo(OutputStream* os) {
- return copyTo(os, 0, length());
+int32_t ByteArray::CopyTo(OutputStream* os) {
+ return CopyTo(os, 0, Length());
}
-int32_t ByteArray::copyTo(OutputStream* os, int32_t offset, int32_t length) {
+int32_t ByteArray::CopyTo(OutputStream* os, int32_t offset, int32_t length) {
ByteVector b(COPY_BUFFER_SIZE);
int32_t bytes_read = 0;
int32_t index = 0;
int32_t buffer_length = std::min<int32_t>(COPY_BUFFER_SIZE, length);
- while ((bytes_read = get(index + offset, &b, 0, buffer_length)) > 0) {
- os->write(&b, 0, bytes_read);
+ while ((bytes_read = Get(index + offset, &b, 0, buffer_length)) > 0) {
+ os->Write(&b, 0, bytes_read);
index += bytes_read;
buffer_length = std::min<int32_t>(b.size(), length - index);
}
return index;
}
-bool ByteArray::copyFrom(InputStream* is, int32_t length) {
+bool ByteArray::CopyFrom(InputStream* is, int32_t length) {
ByteVector b(COPY_BUFFER_SIZE);
int32_t bytes_read = 0;
int32_t index = 0;
int32_t buffer_length = std::min<int32_t>(COPY_BUFFER_SIZE, length);
- while ((bytes_read =
- is->read(&b, 0, buffer_length)) > 0) {
- if (put(index, &b, 0, bytes_read) != bytes_read) {
+ while ((bytes_read = is->Read(&b, 0, buffer_length)) > 0) {
+ if (Put(index, &b, 0, bytes_read) != bytes_read) {
#if defined (SFNTLY_NO_EXCEPTION)
return 0;
#else
@@ -172,14 +159,13 @@
return true;
}
-bool ByteArray::copyFrom(InputStream* is) {
+bool ByteArray::CopyFrom(InputStream* is) {
ByteVector b(COPY_BUFFER_SIZE);
int32_t bytes_read = 0;
int32_t index = 0;
int32_t buffer_length = COPY_BUFFER_SIZE;
- while ((bytes_read =
- is->read(&b, 0, buffer_length)) > 0) {
- if (put(index, &b, 0, bytes_read) != bytes_read) {
+ while ((bytes_read = is->Read(&b, 0, buffer_length)) > 0) {
+ if (Put(index, &b, 0, bytes_read) != bytes_read) {
#if defined (SFNTLY_NO_EXCEPTION)
return 0;
#else
@@ -191,4 +177,22 @@
return true;
}
+ByteArray::ByteArray(int32_t filled_length,
+ int32_t storage_length,
+ bool growable) {
+ Init(filled_length, storage_length, growable);
+}
+
+ByteArray::ByteArray(int32_t filled_length, int32_t storage_length) {
+ Init(filled_length, storage_length, false);
+}
+
+void ByteArray::Init(int32_t filled_length,
+ int32_t storage_length,
+ bool growable) {
+ storage_length_ = storage_length;
+ growable_ = growable;
+ SetFilledLength(filled_length);
+}
+
} // namespace sfntly
diff --git a/sfntly/data/byte_array.h b/sfntly/data/byte_array.h
index edb4633..9ac56c0 100644
--- a/sfntly/data/byte_array.h
+++ b/sfntly/data/byte_array.h
@@ -29,38 +29,27 @@
// C++ port of this class assumes that the data are stored in a linear region
// like std::vector.
class ByteArray : virtual public RefCount {
- protected:
- // filledLength the length that is "filled" and readable counting from offset
- // storageLength the maximum storage size of the underlying data
- // growable is the storage growable - storageLength is the max growable size
- ByteArray(int32_t filled_length, int32_t storage_length, bool growable);
- ByteArray(int32_t filled_length, int32_t storage_length);
- void init(int32_t filled_length, int32_t storage_length, bool growable);
-
- static const int32_t COPY_BUFFER_SIZE;
-
public:
virtual ~ByteArray();
// Get the current filled and readable length of the array.
- int32_t length();
+ int32_t Length();
// Get the maximum size of the array. This is the maximum number of bytes that
// the array can hold and all of it may not be filled with data or even fully
// allocated yet.
- int32_t size();
+ int32_t Size();
- bool growable();
- int32_t setFilledLength(int32_t filled_length);
+ bool growable() { return growable_; }
+ int32_t SetFilledLength(int32_t filled_length);
- public:
// Get the byte from the given index.
- virtual byte_t get(int32_t index);
+ virtual byte_t Get(int32_t index);
// Get the bytes from the given index and fill the buffer with them. As many
// bytes as will fit into the buffer are read unless that would go past the
// end of the array.
- virtual int32_t get(int32_t index, ByteVector* b);
+ virtual int32_t Get(int32_t index, ByteVector* b);
// Get the bytes from the given index and fill the buffer with them starting
// at the offset given. As many bytes as the specified length are read unless
@@ -70,17 +59,19 @@
// @param offset the location in the buffer to start putting the bytes
// @param length the number of bytes to put into the buffer
// @return the number of bytes put into the buffer
- virtual int32_t get(int32_t index, ByteVector* b, int32_t offset,
+ virtual int32_t Get(int32_t index,
+ ByteVector* b,
+ int32_t offset,
int32_t length);
// Put the specified byte into the array at the given index unless that would
// be beyond the length of the array and it isn't growable.
- virtual bool put(int32_t index, byte_t b);
+ virtual bool Put(int32_t index, byte_t b);
// Put the specified bytes into the array at the given index. The entire
// buffer is put into the array unless that would extend beyond the length and
// the array isn't growable.
- virtual int32_t put(int32_t index, ByteVector* b);
+ virtual int32_t Put(int32_t index, ByteVector* b);
// Put the specified bytes into the array at the given index. All of the bytes
// specified are put into the array unless that would extend beyond the length
@@ -91,19 +82,21 @@
// @param offset the offset in the bytes to start copying from
// @param length the number of bytes to copy into the array
// @return the number of bytes actually written
- virtual int32_t put(int32_t index, ByteVector* b, int32_t offset,
+ virtual int32_t Put(int32_t index,
+ ByteVector* b,
+ int32_t offset,
int32_t length);
// Fully copy this ByteArray to another ByteArray to the extent that the
// destination array has storage for the data copied.
- virtual int32_t copyTo(ByteArray* array);
+ virtual int32_t CopyTo(ByteArray* array);
// Copy a segment of this ByteArray to another ByteArray.
// @param array the destination
// @param offset the offset in this ByteArray to start copying from
// @param length the maximum length in bytes to copy
// @return the number of bytes copied
- virtual int32_t copyTo(ByteArray* array, int32_t offset, int32_t length);
+ virtual int32_t CopyTo(ByteArray* array, int32_t offset, int32_t length);
// Copy this ByteArray to another ByteArray.
// @param dstOffset the offset in the destination array to start copying to
@@ -111,25 +104,40 @@
// @param srcOffset the offset in this ByteArray to start copying from
// @param length the maximum length in bytes to copy
// @return the number of bytes copied
- virtual int32_t copyTo(int32_t dst_offset, ByteArray* array,
- int32_t src_offset, int32_t length);
+ virtual int32_t CopyTo(int32_t dst_offset,
+ ByteArray* array,
+ int32_t src_offset,
+ int32_t length);
- virtual int32_t copyTo(OutputStream* os);
- virtual int32_t copyTo(OutputStream* os, int32_t offset, int32_t length);
- virtual bool copyFrom(InputStream* is, int32_t length);
- virtual bool copyFrom(InputStream* is);
+ virtual int32_t CopyTo(OutputStream* os);
+ virtual int32_t CopyTo(OutputStream* os, int32_t offset, int32_t length);
+ virtual bool CopyFrom(InputStream* is, int32_t length);
+ virtual bool CopyFrom(InputStream* is);
protected:
- virtual bool internalPut(int32_t index, byte_t b) = 0;
- virtual int32_t internalPut(int32_t index, ByteVector* b, int32_t offset,
- int32_t length) = 0;
- virtual byte_t internalGet(int32_t index) = 0;
- virtual int32_t internalGet(int32_t index, ByteVector* b, int32_t offset,
- int32_t length) = 0;
- virtual void close() = 0;
+ // filledLength the length that is "filled" and readable counting from offset.
+ // storageLength the maximum storage size of the underlying data.
+ // growable is the storage growable - storageLength is the max growable size.
+ ByteArray(int32_t filled_length, int32_t storage_length, bool growable);
+ ByteArray(int32_t filled_length, int32_t storage_length);
+ void Init(int32_t filled_length, int32_t storage_length, bool growable);
- // C++ port only, raw pointer to the first element of storage
- virtual byte_t* begin() = 0;
+ virtual bool InternalPut(int32_t index, byte_t b) = 0;
+ virtual int32_t InternalPut(int32_t index,
+ ByteVector* b,
+ int32_t offset,
+ int32_t length) = 0;
+ virtual byte_t InternalGet(int32_t index) = 0;
+ virtual int32_t InternalGet(int32_t index,
+ ByteVector* b,
+ int32_t offset,
+ int32_t length) = 0;
+ virtual void Close() = 0;
+
+ // C++ port only, raw pointer to the first element of storage.
+ virtual byte_t* Begin() = 0;
+
+ static const int32_t COPY_BUFFER_SIZE;
private:
int32_t filled_length_;
diff --git a/sfntly/data/font_data.cc b/sfntly/data/font_data.cc
index fdba5f8..437a810 100644
--- a/sfntly/data/font_data.cc
+++ b/sfntly/data/font_data.cc
@@ -22,30 +22,12 @@
namespace sfntly {
-FontData::~FontData() {}
-
-void FontData::init(ByteArray* ba) {
- array_ = ba;
- bound_offset_ = 0;
- bound_length_ = INT_MAX;
+int32_t FontData::Size() const {
+ return std::min<int32_t>(array_->Size() - bound_offset_, bound_length_);
}
-FontData::FontData(ByteArray* ba) {
- init(ba);
-}
-
-FontData::FontData(FontData* data, int32_t offset, int32_t length) {
- init(data->array_);
- bound(data->bound_offset_ + offset, length);
-}
-
-FontData::FontData(FontData* data, int32_t offset) {
- init(data->array_);
- bound(offset);
-}
-
-bool FontData::bound(int32_t offset, int32_t length) {
- if (offset + length > size() || offset < 0 || length < 0)
+bool FontData::Bound(int32_t offset, int32_t length) {
+ if (offset + length > Size() || offset < 0 || length < 0)
return false;
bound_offset_ += offset;
@@ -53,27 +35,45 @@
return true;
}
-bool FontData::bound(int32_t offset) {
-if (offset > size() || offset < 0)
+bool FontData::Bound(int32_t offset) {
+if (offset > Size() || offset < 0)
return false;
bound_offset_ += offset;
return true;
}
-int32_t FontData::length() const {
- return std::min<int32_t>(array_->length() - bound_offset_, bound_length_);
+int32_t FontData::Length() const {
+ return std::min<int32_t>(array_->Length() - bound_offset_, bound_length_);
}
-int32_t FontData::size() const {
- return std::min<int32_t>(array_->size() - bound_offset_, bound_length_);
+FontData::FontData(ByteArray* ba) {
+ Init(ba);
}
-int32_t FontData::boundOffset(int32_t offset) {
+FontData::FontData(FontData* data, int32_t offset, int32_t length) {
+ Init(data->array_);
+ Bound(data->bound_offset_ + offset, length);
+}
+
+FontData::FontData(FontData* data, int32_t offset) {
+ Init(data->array_);
+ Bound(offset);
+}
+
+FontData::~FontData() {}
+
+void FontData::Init(ByteArray* ba) {
+ array_ = ba;
+ bound_offset_ = 0;
+ bound_length_ = INT_MAX;
+}
+
+int32_t FontData::BoundOffset(int32_t offset) {
return offset + bound_offset_;
}
-int32_t FontData::boundLength(int32_t offset, int32_t length) {
+int32_t FontData::BoundLength(int32_t offset, int32_t length) {
return std::min<int32_t>(length, bound_length_ - offset);
}
diff --git a/sfntly/data/font_data.h b/sfntly/data/font_data.h
index 6bcdb73..ab5cf54 100644
--- a/sfntly/data/font_data.h
+++ b/sfntly/data/font_data.h
@@ -18,6 +18,7 @@
#define TYPOGRAPHY_FONT_SFNTLY_SRC_SFNTLY_DATA_FONT_DATA_H_
#include <vector>
+
#include "sfntly/port/type.h"
#include "sfntly/data/byte_array.h"
#include "sfntly/port/refcount.h"
@@ -51,13 +52,13 @@
// that the font data can hold and all of it may not be filled with data or
// even fully allocated yet.
// @return the size of this array
- virtual int32_t size() const;
+ virtual int32_t Size() const;
// Sets limits on the size of the FontData. The font data is
// @param offset the start of the new bounds
// @param length the number of bytes in the bounded array
// @return true if the bounding range was successful; false otherwise
- virtual bool bound(int32_t offset, int32_t length);
+ virtual bool Bound(int32_t offset, int32_t length);
// Sets limits on the size of the FontData. This is a offset bound only so if
// the FontData is writable and growable then there is no limit to that growth
@@ -65,28 +66,25 @@
// @param offset the start of the new bounds which must be within the current
// size of the FontData
// @return true if the bounding range was successful; false otherwise
- virtual bool bound(int32_t offset);
+ virtual bool Bound(int32_t offset);
// Makes a slice of this FontData. The returned slice will share the data with
// the original FontData.
// @param offset the start of the slice
// @param length the number of bytes in the slice
// @return a slice of the original FontData
- virtual CALLER_ATTACH FontData* slice(int32_t offset, int32_t length) = 0;
+ virtual CALLER_ATTACH FontData* Slice(int32_t offset, int32_t length) = 0;
// Makes a bottom bound only slice of this array. The returned slice will
// share the data with the original FontData.
// @param offset the start of the slice
// @return a slice of the original FontData
- virtual CALLER_ATTACH FontData* slice(int32_t offset) = 0;
+ virtual CALLER_ATTACH FontData* Slice(int32_t offset) = 0;
// Get the length of the data.
- virtual int32_t length() const;
-
+ virtual int32_t Length() const;
protected:
- virtual ~FontData();
-
// Constructor.
// @param ba the byte array to use for the backing data
explicit FontData(ByteArray* ba);
@@ -101,12 +99,13 @@
// @param data the data to wrap
// @param offset the offset to start the wrap from
FontData(FontData* data, int32_t offset);
+ virtual ~FontData();
- void init(ByteArray* ba);
- int32_t boundOffset(int32_t offset);
- int32_t boundLength(int32_t offset, int32_t length);
+ void Init(ByteArray* ba);
+ int32_t BoundOffset(int32_t offset);
+ int32_t BoundLength(int32_t offset, int32_t length);
- protected:
+ // TODO(arthurhsu): style guide violation: refactor this protected member
ByteArrayPtr array_;
private:
diff --git a/sfntly/data/font_input_stream.cc b/sfntly/data/font_input_stream.cc
index b9eccdb..a1fbe44 100644
--- a/sfntly/data/font_input_stream.cc
+++ b/sfntly/data/font_input_stream.cc
@@ -14,10 +14,10 @@
* limitations under the License.
*/
-#include <algorithm>
-
#include "sfntly/data/font_input_stream.h"
+#include <algorithm>
+
namespace sfntly {
FontInputStream::FontInputStream(InputStream* is)
@@ -32,50 +32,50 @@
// Do not close here, underlying InputStream will close themselves.
}
-int32_t FontInputStream::available() {
+int32_t FontInputStream::Available() {
if (stream_) {
- return stream_->available();
+ return stream_->Available();
}
return 0;
}
-void FontInputStream::close() {
+void FontInputStream::Close() {
if (stream_) {
- stream_->close();
+ stream_->Close();
}
}
-void FontInputStream::mark(int32_t readlimit) {
+void FontInputStream::Mark(int32_t readlimit) {
if (stream_) {
- stream_->mark(readlimit);
+ stream_->Mark(readlimit);
}
}
-bool FontInputStream::markSupported() {
+bool FontInputStream::MarkSupported() {
if (stream_) {
- return stream_->markSupported();
+ return stream_->MarkSupported();
}
return false;
}
-void FontInputStream::reset() {
+void FontInputStream::Reset() {
if (stream_) {
- stream_->reset();
+ stream_->Reset();
}
}
-int32_t FontInputStream::read() {
+int32_t FontInputStream::Read() {
if (!stream_ || (bounded_ && position_ >= length_)) {
return -1;
}
- int32_t b = stream_->read();
+ int32_t b = stream_->Read();
if (b >= 0) {
position_++;
}
return b;
}
-int32_t FontInputStream::read(ByteVector* b, int32_t offset, int32_t length) {
+int32_t FontInputStream::Read(ByteVector* b, int32_t offset, int32_t length) {
if (!stream_ || offset < 0 || length < 0 ||
(bounded_ && position_ >= length_)) {
return -1;
@@ -83,59 +83,55 @@
int32_t bytes_to_read =
bounded_ ? std::min<int32_t>(length, (int32_t)(length_ - position_)) :
length;
- int32_t bytes_read = stream_->read(b, offset, bytes_to_read);
+ int32_t bytes_read = stream_->Read(b, offset, bytes_to_read);
position_ += bytes_read;
return bytes_read;
}
-int32_t FontInputStream::read(ByteVector* b) {
- return read(b, 0, b->size());
+int32_t FontInputStream::Read(ByteVector* b) {
+ return Read(b, 0, b->size());
}
-int64_t FontInputStream::position() {
- return position_;
+int32_t FontInputStream::ReadChar() {
+ return Read();
}
-int32_t FontInputStream::readChar() {
- return read();
+int32_t FontInputStream::ReadUShort() {
+ return 0xffff & (Read() << 8 | Read());
}
-int32_t FontInputStream::readUShort() {
- return 0xffff & (read() << 8 | read());
+int32_t FontInputStream::ReadShort() {
+ return ((Read() << 8 | Read()) << 16) >> 16;
}
-int32_t FontInputStream::readShort() {
- return ((read() << 8 | read()) << 16) >> 16;
+int32_t FontInputStream::ReadUInt24() {
+ return 0xffffff & (Read() << 16 | Read() << 8 | Read());
}
-int32_t FontInputStream::readUInt24() {
- return 0xffffff & (read() << 16 | read() << 8 | read());
+int64_t FontInputStream::ReadULong() {
+ return 0xffffffffL & ReadLong();
}
-int64_t FontInputStream::readULong() {
- return 0xffffffffL & readLong();
-}
-
-int32_t FontInputStream::readULongAsInt() {
- int64_t ulong = readULong();
+int32_t FontInputStream::ReadULongAsInt() {
+ int64_t ulong = ReadULong();
return ((int32_t)ulong) & ~0x80000000;
}
-int32_t FontInputStream::readLong() {
- return read() << 24 | read() << 16 | read() << 8 | read();
+int32_t FontInputStream::ReadLong() {
+ return Read() << 24 | Read() << 16 | Read() << 8 | Read();
}
-int32_t FontInputStream::readFixed() {
- return readLong();
+int32_t FontInputStream::ReadFixed() {
+ return ReadLong();
}
-int64_t FontInputStream::readDateTimeAsLong() {
- return (int64_t)readULong() << 32 | readULong();
+int64_t FontInputStream::ReadDateTimeAsLong() {
+ return (int64_t)ReadULong() << 32 | ReadULong();
}
-int64_t FontInputStream::skip(int64_t n) {
+int64_t FontInputStream::Skip(int64_t n) {
if (stream_) {
- int64_t skipped = stream_->skip(n);
+ int64_t skipped = stream_->Skip(n);
position_ += skipped;
return skipped;
}
diff --git a/sfntly/data/font_input_stream.h b/sfntly/data/font_input_stream.h
index ed8d364..7404825 100644
--- a/sfntly/data/font_input_stream.h
+++ b/sfntly/data/font_input_stream.h
@@ -33,33 +33,33 @@
FontInputStream(InputStream* is, size_t length);
virtual ~FontInputStream();
- virtual int32_t available();
- virtual void close();
- virtual void mark(int32_t readlimit);
- virtual bool markSupported();
- virtual void reset();
+ virtual int32_t Available();
+ virtual void Close();
+ virtual void Mark(int32_t readlimit);
+ virtual bool MarkSupported();
+ virtual void Reset();
- virtual int32_t read();
- virtual int32_t read(ByteVector* buffer);
- virtual int32_t read(ByteVector* buffer, int32_t offset, int32_t length);
+ virtual int32_t Read();
+ virtual int32_t Read(ByteVector* buffer);
+ virtual int32_t Read(ByteVector* buffer, int32_t offset, int32_t length);
- virtual int64_t position();
+ virtual int64_t position() { return position_; }
- virtual int32_t readChar();
- virtual int32_t readUShort();
- virtual int32_t readShort();
- virtual int32_t readUInt24();
- virtual int64_t readULong();
- virtual int32_t readULongAsInt();
- virtual int32_t readLong();
- virtual int32_t readFixed();
- virtual int64_t readDateTimeAsLong();
- virtual int64_t skip(int64_t n); // n can be negative
+ virtual int32_t ReadChar();
+ virtual int32_t ReadUShort();
+ virtual int32_t ReadShort();
+ virtual int32_t ReadUInt24();
+ virtual int64_t ReadULong();
+ virtual int32_t ReadULongAsInt();
+ virtual int32_t ReadLong();
+ virtual int32_t ReadFixed();
+ virtual int64_t ReadDateTimeAsLong();
+ virtual int64_t Skip(int64_t n); // n can be negative.
private:
InputStream* stream_;
int64_t position_;
- int64_t length_; // bound on length of data to read
+ int64_t length_; // Bound on length of data to read.
bool bounded_;
};
diff --git a/sfntly/data/font_output_stream.cc b/sfntly/data/font_output_stream.cc
index f0f4744..a88a29e 100644
--- a/sfntly/data/font_output_stream.cc
+++ b/sfntly/data/font_output_stream.cc
@@ -14,95 +14,91 @@
* limitations under the License.
*/
-#include <algorithm>
-
#include "sfntly/data/font_output_stream.h"
-#include "sfntly/port/endian.h"
+
+#include <algorithm>
namespace sfntly {
FontOutputStream::FontOutputStream(OutputStream* os)
- : stream_(os), position_(0) {
+ : stream_(os),
+ position_(0) {
}
FontOutputStream::~FontOutputStream() {
// Do not close, underlying stream shall clean up themselves.
}
-size_t FontOutputStream::position() {
- return position_;
-}
-
-void FontOutputStream::write(byte_t b) {
+void FontOutputStream::Write(byte_t b) {
if (stream_) {
- stream_->write(b);
+ stream_->Write(b);
position_++;
}
}
-void FontOutputStream::write(ByteVector* b) {
+void FontOutputStream::Write(ByteVector* b) {
if (b) {
- write(b, 0, b->size());
+ Write(b, 0, b->size());
position_ += b->size();
}
}
-void FontOutputStream::write(ByteVector* b, int32_t offset, int32_t length) {
+void FontOutputStream::Write(ByteVector* b, int32_t offset, int32_t length) {
if (stream_ && b) {
- stream_->write(b, offset, length);
+ stream_->Write(b, offset, length);
position_ += length;
}
}
-void FontOutputStream::writeChar(byte_t c) {
- write(c);
+void FontOutputStream::WriteChar(byte_t c) {
+ Write(c);
}
-void FontOutputStream::writeUShort(int32_t us) {
- write((byte_t)((us >> 8) & 0xff));
- write((byte_t)(us & 0xff));
+void FontOutputStream::WriteUShort(int32_t us) {
+ Write((byte_t)((us >> 8) & 0xff));
+ Write((byte_t)(us & 0xff));
}
-void FontOutputStream::writeShort(int32_t s) {
- writeUShort(s);
+void FontOutputStream::WriteShort(int32_t s) {
+ WriteUShort(s);
}
-void FontOutputStream::writeUInt24(int32_t ui) {
- write((byte_t)(ui >> 16) & 0xff);
- write((byte_t)(ui >> 8) & 0xff);
- write((byte_t)ui & 0xff);
+void FontOutputStream::WriteUInt24(int32_t ui) {
+ Write((byte_t)(ui >> 16) & 0xff);
+ Write((byte_t)(ui >> 8) & 0xff);
+ Write((byte_t)ui & 0xff);
}
-void FontOutputStream::writeULong(int64_t ul) {
- write((byte_t)((ul >> 24) & 0xff));
- write((byte_t)((ul >> 16) & 0xff));
- write((byte_t)((ul >> 8) & 0xff));
- write((byte_t)(ul & 0xff));
+void FontOutputStream::WriteULong(int64_t ul) {
+ Write((byte_t)((ul >> 24) & 0xff));
+ Write((byte_t)((ul >> 16) & 0xff));
+ Write((byte_t)((ul >> 8) & 0xff));
+ Write((byte_t)(ul & 0xff));
}
-void FontOutputStream::writeLong(int64_t l) {
- writeULong(l);
+void FontOutputStream::WriteLong(int64_t l) {
+ WriteULong(l);
}
-void FontOutputStream::writeFixed(int32_t f) {
- writeULong(f);
+void FontOutputStream::WriteFixed(int32_t f) {
+ WriteULong(f);
}
-void FontOutputStream::writeDateTime(int64_t date) {
- writeULong((date >> 32) & 0xffffffff);
- writeULong(date & 0xffffffff);
+void FontOutputStream::WriteDateTime(int64_t date) {
+ WriteULong((date >> 32) & 0xffffffff);
+ WriteULong(date & 0xffffffff);
}
-void FontOutputStream::flush() {
+void FontOutputStream::Flush() {
if (stream_) {
- stream_->flush();
+ stream_->Flush();
}
}
-void FontOutputStream::close() {
+void FontOutputStream::Close() {
if (stream_) {
- stream_->flush();
- stream_->close();
+ stream_->Flush();
+ stream_->Close();
position_ = 0;
}
}
diff --git a/sfntly/data/font_output_stream.h b/sfntly/data/font_output_stream.h
index 4bb923d..6938b66 100644
--- a/sfntly/data/font_output_stream.h
+++ b/sfntly/data/font_output_stream.h
@@ -32,22 +32,22 @@
explicit FontOutputStream(OutputStream* os);
virtual ~FontOutputStream();
- virtual size_t position();
+ virtual size_t position() { return position_; }
- virtual void write(byte_t b);
- virtual void write(ByteVector* b);
- virtual void write(ByteVector* b, int32_t offset, int32_t len);
- virtual void writeChar(byte_t c);
- virtual void writeUShort(int32_t us);
- virtual void writeShort(int32_t s);
- virtual void writeUInt24(int32_t ui);
- virtual void writeULong(int64_t ul);
- virtual void writeLong(int64_t l);
- virtual void writeFixed(int32_t l);
- virtual void writeDateTime(int64_t date);
+ virtual void Write(byte_t b);
+ virtual void Write(ByteVector* b);
+ virtual void Write(ByteVector* b, int32_t offset, int32_t len);
+ virtual void WriteChar(byte_t c);
+ virtual void WriteUShort(int32_t us);
+ virtual void WriteShort(int32_t s);
+ virtual void WriteUInt24(int32_t ui);
+ virtual void WriteULong(int64_t ul);
+ virtual void WriteLong(int64_t l);
+ virtual void WriteFixed(int32_t l);
+ virtual void WriteDateTime(int64_t date);
- virtual void flush();
- virtual void close();
+ virtual void Flush();
+ virtual void Close();
private:
OutputStream* stream_;
diff --git a/sfntly/data/growable_memory_byte_array.cc b/sfntly/data/growable_memory_byte_array.cc
index 0821321..9e1a043 100644
--- a/sfntly/data/growable_memory_byte_array.cc
+++ b/sfntly/data/growable_memory_byte_array.cc
@@ -14,11 +14,12 @@
* limitations under the License.
*/
-#include <limits.h>
-#include <algorithm>
-
#include "sfntly/data/growable_memory_byte_array.h"
+#include <limits.h>
+
+#include <algorithm>
+
namespace sfntly {
GrowableMemoryByteArray::GrowableMemoryByteArray()
@@ -27,40 +28,46 @@
GrowableMemoryByteArray::~GrowableMemoryByteArray() {}
-bool GrowableMemoryByteArray::internalPut(int32_t index, byte_t b) {
+bool GrowableMemoryByteArray::InternalPut(int32_t index, byte_t b) {
if ((size_t)index >= b_.capacity()) {
- b_.resize((size_t)(index + 1) << 2); // grow exponentially
+ b_.resize((size_t)(index + 1) << 2); // Grow exponentially.
}
b_[index] = b;
return true;
}
-int32_t GrowableMemoryByteArray::internalPut(int32_t index, ByteVector* b,
- int32_t offset, int32_t length) {
+int32_t GrowableMemoryByteArray::InternalPut(int32_t index,
+ ByteVector* b,
+ int32_t offset,
+ int32_t length) {
if ((size_t)index + length >= b_.capacity()) {
b_.resize((size_t)(index + length + 1) << 2);
}
- std::copy(b->begin() + offset, b->begin() + (offset + length),
+ std::copy(b->begin() + offset,
+ b->begin() + (offset + length),
b_.begin() + index);
return length;
}
-byte_t GrowableMemoryByteArray::internalGet(int32_t index) {
+byte_t GrowableMemoryByteArray::InternalGet(int32_t index) {
return b_[index];
}
-int32_t GrowableMemoryByteArray::internalGet(int32_t index, ByteVector* b,
- int32_t offset, int32_t length) {
- std::copy(b_.begin() + index, b_.begin() + (index + length),
+int32_t GrowableMemoryByteArray::InternalGet(int32_t index,
+ ByteVector* b,
+ int32_t offset,
+ int32_t length) {
+ std::copy(b_.begin() + index,
+ b_.begin() + (index + length),
b->begin() + offset);
return length;
}
-void GrowableMemoryByteArray::close() {
+void GrowableMemoryByteArray::Close() {
b_.clear();
}
-byte_t* GrowableMemoryByteArray::begin() {
+byte_t* GrowableMemoryByteArray::Begin() {
return &(b_[0]);
}
diff --git a/sfntly/data/growable_memory_byte_array.h b/sfntly/data/growable_memory_byte_array.h
index 3c9d4f0..dc59f62 100644
--- a/sfntly/data/growable_memory_byte_array.h
+++ b/sfntly/data/growable_memory_byte_array.h
@@ -30,14 +30,18 @@
virtual ~GrowableMemoryByteArray();
protected:
- virtual bool internalPut(int32_t index, byte_t b);
- virtual int32_t internalPut(int32_t index, ByteVector* b, int32_t offset,
+ virtual bool InternalPut(int32_t index, byte_t b);
+ virtual int32_t InternalPut(int32_t index,
+ ByteVector* b,
+ int32_t offset,
int32_t length);
- virtual byte_t internalGet(int32_t index);
- virtual int32_t internalGet(int32_t index, ByteVector* b, int32_t offset,
+ virtual byte_t InternalGet(int32_t index);
+ virtual int32_t InternalGet(int32_t index,
+ ByteVector* b,
+ int32_t offset,
int32_t length);
- virtual void close();
- virtual byte_t* begin();
+ virtual void Close();
+ virtual byte_t* Begin();
private:
ByteVector b_;
diff --git a/sfntly/data/memory_byte_array.cc b/sfntly/data/memory_byte_array.cc
index 528979a..0138b21 100644
--- a/sfntly/data/memory_byte_array.cc
+++ b/sfntly/data/memory_byte_array.cc
@@ -14,13 +14,13 @@
* limitations under the License.
*/
-#include <string.h>
-
#include "sfntly/data/memory_byte_array.h"
+#include <string.h>
+
namespace sfntly {
-// Note: this constructor can fail under low-memory situation
+// Note: this constructor can fail under low-memory situation.
MemoryByteArray::MemoryByteArray(int32_t length)
: ByteArray(0, length), b_(NULL), allocated_(true) {
}
@@ -29,56 +29,61 @@
: ByteArray(buffer_length, buffer_length), b_(b), allocated_(false) {
}
-MemoryByteArray::MemoryByteArray(byte_t* b, int32_t buffer_length,
+MemoryByteArray::MemoryByteArray(byte_t* b,
+ int32_t buffer_length,
int32_t filled_length)
: ByteArray(filled_length, buffer_length), b_(b), allocated_(false) {
}
MemoryByteArray::~MemoryByteArray() {
- close();
+ Close();
}
-void MemoryByteArray::init() {
+void MemoryByteArray::Init() {
if (allocated_ && b_ == NULL) {
- b_ = new byte_t[size()];
- memset(b_, 0, size());
+ b_ = new byte_t[Size()];
+ memset(b_, 0, Size());
}
}
-bool MemoryByteArray::internalPut(int32_t index, byte_t b) {
- init();
+bool MemoryByteArray::InternalPut(int32_t index, byte_t b) {
+ Init();
b_[index] = b;
return true;
}
-int32_t MemoryByteArray::internalPut(int32_t index, ByteVector* b,
- int32_t offset, int32_t length) {
- init();
+int32_t MemoryByteArray::InternalPut(int32_t index,
+ ByteVector* b,
+ int32_t offset,
+ int32_t length) {
+ Init();
memcpy(b_ + index, &((*b)[offset]), length);
return length;
}
-byte_t MemoryByteArray::internalGet(int32_t index) {
- init();
+byte_t MemoryByteArray::InternalGet(int32_t index) {
+ Init();
return b_[index];
}
-int32_t MemoryByteArray::internalGet(int32_t index, ByteVector* b,
- int32_t offset, int32_t length) {
- init();
+int32_t MemoryByteArray::InternalGet(int32_t index,
+ ByteVector* b,
+ int32_t offset,
+ int32_t length) {
+ Init();
memcpy(&((*b)[offset]), b_ + index, length);
return length;
}
-void MemoryByteArray::close() {
+void MemoryByteArray::Close() {
if (allocated_ && b_) {
delete[] b_;
}
b_ = NULL;
}
-byte_t* MemoryByteArray::begin() {
- init();
+byte_t* MemoryByteArray::Begin() {
+ Init();
return b_;
}
diff --git a/sfntly/data/memory_byte_array.h b/sfntly/data/memory_byte_array.h
index 34b26a6..171dcc7 100644
--- a/sfntly/data/memory_byte_array.h
+++ b/sfntly/data/memory_byte_array.h
@@ -29,17 +29,21 @@
virtual ~MemoryByteArray();
protected:
- virtual bool internalPut(int32_t index, byte_t b);
- virtual int32_t internalPut(int32_t index, ByteVector* b, int32_t offset,
+ virtual bool InternalPut(int32_t index, byte_t b);
+ virtual int32_t InternalPut(int32_t index,
+ ByteVector* b,
+ int32_t offset,
int32_t length);
- virtual byte_t internalGet(int32_t index);
- virtual int32_t internalGet(int32_t index, ByteVector* b, int32_t offset,
+ virtual byte_t InternalGet(int32_t index);
+ virtual int32_t InternalGet(int32_t index,
+ ByteVector* b,
+ int32_t offset,
int32_t length);
- virtual void close();
- virtual byte_t* begin();
+ virtual void Close();
+ virtual byte_t* Begin();
private:
- void init(); // C++ port only, used to allocate memory outside constructor.
+ void Init(); // C++ port only, used to allocate memory outside constructor.
byte_t* b_;
bool allocated_;
diff --git a/sfntly/data/readable_font_data.cc b/sfntly/data/readable_font_data.cc
index fa7279e..5f8478d 100644
--- a/sfntly/data/readable_font_data.cc
+++ b/sfntly/data/readable_font_data.cc
@@ -20,27 +20,148 @@
namespace sfntly {
+ReadableFontData::ReadableFontData(ByteArray* array)
+ : FontData(array),
+ checksum_set_(false),
+ checksum_(0) {
+}
+
ReadableFontData::~ReadableFontData() {}
-ReadableFontData::ReadableFontData(ByteArray* array)
- : FontData(array), checksum_set_(false), checksum_(0) {
+int64_t ReadableFontData::Checksum() {
+ // TODO(arthurhsu): IMPLEMENT: atomicity
+ if (!checksum_set_) {
+ ComputeChecksum();
+ }
+ return checksum_;
+}
+
+void ReadableFontData::SetCheckSumRanges(const IntegerList& ranges) {
+ checksum_range_ = ranges;
+ checksum_set_ = false; // UNIMPLEMENTED: atomicity
+}
+
+int32_t ReadableFontData::ReadUByte(int32_t index) {
+ return 0xff & array_->Get(BoundOffset(index));
+}
+
+int32_t ReadableFontData::ReadByte(int32_t index) {
+ return (array_->Get(BoundOffset(index)) << 24) >> 24;
+}
+
+int32_t ReadableFontData::ReadBytes(int32_t index,
+ ByteVector* b,
+ int32_t offset,
+ int32_t length) {
+ return array_->Get(BoundOffset(index), b, offset, BoundLength(index, length));
+}
+
+int32_t ReadableFontData::ReadChar(int32_t index) {
+ return ReadUByte(index);
+}
+
+int32_t ReadableFontData::ReadUShort(int32_t index) {
+ return 0xffff & (ReadUByte(index) << 8 | ReadUByte(index + 1));
+}
+
+int32_t ReadableFontData::ReadShort(int32_t index) {
+ return ((ReadByte(index) << 8 | ReadUByte(index + 1)) << 16) >> 16;
+}
+
+int32_t ReadableFontData::ReadUInt24(int32_t index) {
+ return 0xffffff & (ReadUByte(index) << 16 |
+ ReadUByte(index + 1) << 8 |
+ ReadUByte(index + 2));
+}
+
+int64_t ReadableFontData::ReadULong(int32_t index) {
+ return 0xffffffffL & (ReadUByte(index) << 24 |
+ ReadUByte(index + 1) << 16 |
+ ReadUByte(index + 2) << 8 |
+ ReadUByte(index + 3));
+}
+
+int32_t ReadableFontData::ReadULongAsInt(int32_t index) {
+ int64_t ulong = ReadULong(index);
+#if !defined (SFNTLY_NO_EXCEPTION)
+ if ((ulong & 0x80000000) == 0x80000000) {
+ throw ArithmeticException("Long value too large to fit into an integer.");
+ }
+#endif
+ return ((int32_t)ulong) & ~0x80000000;
+}
+
+int32_t ReadableFontData::ReadLong(int32_t index) {
+ return ReadByte(index) << 24 |
+ ReadUByte(index + 1) << 16 |
+ ReadUByte(index + 2) << 8 |
+ ReadUByte(index + 3);
+}
+
+int32_t ReadableFontData::ReadFixed(int32_t index) {
+ return ReadLong(index);
+}
+
+int64_t ReadableFontData::ReadDateTimeAsLong(int32_t index) {
+ return (int64_t)ReadULong(index) << 32 | ReadULong(index + 4);
+}
+
+int32_t ReadableFontData::ReadFWord(int32_t index) {
+ return ReadShort(index);
+}
+
+int32_t ReadableFontData::ReadFUFWord(int32_t index) {
+ return ReadUShort(index);
+}
+
+int32_t ReadableFontData::CopyTo(OutputStream* os) {
+ return array_->CopyTo(os, BoundOffset(0), Length());
+}
+
+int32_t ReadableFontData::CopyTo(WritableFontData* wfd) {
+ return array_->CopyTo(wfd->BoundOffset(0),
+ wfd->array_,
+ BoundOffset(0),
+ Length());
+}
+
+int32_t ReadableFontData::CopyTo(ByteArray* ba) {
+ return array_->CopyTo(ba, BoundOffset(0), Length());
+}
+
+CALLER_ATTACH FontData* ReadableFontData::Slice(int32_t offset,
+ int32_t length) {
+ if (offset < 0 || offset + length > Size()) {
+ return NULL;
+ }
+ FontDataPtr slice = new ReadableFontData(this, offset, length);
+ // Note: exception not ported because the condition is always false in C++.
+ // if (slice == null) { throw new IndexOutOfBoundsException( ...
+ return slice.Detach();
+}
+
+CALLER_ATTACH FontData* ReadableFontData::Slice(int32_t offset) {
+ if (offset < 0 || offset > Size()) {
+ return NULL;
+ }
+ FontDataPtr slice = new ReadableFontData(this, offset);
+ // Note: exception not ported because the condition is always false in C++.
+ // if (slice == null) { throw new IndexOutOfBoundsException( ...
+ return slice.Detach();
}
ReadableFontData::ReadableFontData(ReadableFontData* data, int32_t offset)
- : FontData(data, offset), checksum_set_(false), checksum_(0) {
+ : FontData(data, offset),
+ checksum_set_(false),
+ checksum_(0) {
}
-ReadableFontData::ReadableFontData(ReadableFontData* data, int32_t offset,
+ReadableFontData::ReadableFontData(ReadableFontData* data,
+ int32_t offset,
int32_t length)
- : FontData(data, offset, length), checksum_set_(false), checksum_(0) {
-}
-
-int64_t ReadableFontData::checksum() {
- // TODO(arthurhsu): IMPLEMENT: atomicity
- if (!checksum_set_) {
- computeChecksum();
- }
- return checksum_;
+ : FontData(data, offset, length),
+ checksum_set_(false),
+ checksum_(0) {
}
/* OpenType checksum
@@ -54,19 +175,19 @@
return Sum;
}
*/
-void ReadableFontData::computeChecksum() {
+void ReadableFontData::ComputeChecksum() {
// TODO(arthurhsu): IMPLEMENT: synchronization/atomicity
int64_t sum = 0;
if (checksum_range_.empty()) {
- sum = computeCheckSum(0, length());
+ sum = ComputeCheckSum(0, Length());
} else {
for (uint32_t low_bound_index = 0; low_bound_index < checksum_range_.size();
low_bound_index += 2) {
int32_t low_bound = checksum_range_[low_bound_index];
int32_t high_bound = (low_bound_index == checksum_range_.size() - 1) ?
- length() :
+ Length() :
checksum_range_[low_bound_index + 1];
- sum += computeCheckSum(low_bound, high_bound);
+ sum += ComputeCheckSum(low_bound, high_bound);
}
}
@@ -74,126 +195,21 @@
checksum_set_ = true;
}
-int64_t ReadableFontData::computeCheckSum(int32_t low_bound,
+int64_t ReadableFontData::ComputeCheckSum(int32_t low_bound,
int32_t high_bound) {
int64_t sum = 0;
for (int32_t i = low_bound; i < high_bound; i += 4) {
- int32_t b3 = readUByte(i);
+ int32_t b3 = ReadUByte(i);
b3 = (b3 == -1) ? 0 : b3;
- int32_t b2 = readUByte(i + 1);
+ int32_t b2 = ReadUByte(i + 1);
b2 = (b2 == -1) ? 0 : b2;
- int32_t b1 = readUByte(i + 2);
+ int32_t b1 = ReadUByte(i + 2);
b1 = (b1 == -1) ? 0 : b1;
- int32_t b0 = readUByte(i + 3);
+ int32_t b0 = ReadUByte(i + 3);
b0 = (b0 == -1) ? 0 : b0;
sum += (b3 << 24) | (b2 << 16) | (b1 << 8) | b0;
}
return sum;
}
-void ReadableFontData::setCheckSumRanges(const IntegerList& ranges) {
- checksum_range_ = ranges;
- checksum_set_ = false; // UNIMPLEMENTED: atomicity
-}
-
-int32_t ReadableFontData::readUByte(int32_t index) {
- return 0xff & array_->get(boundOffset(index));
-}
-
-int32_t ReadableFontData::readByte(int32_t index) {
- return (array_->get(boundOffset(index)) << 24) >> 24;
-}
-
-int32_t ReadableFontData::readBytes(int32_t index, ByteVector* b,
- int32_t offset, int32_t length) {
- return array_->get(boundOffset(index), b, offset, boundLength(index, length));
-}
-
-int32_t ReadableFontData::readChar(int32_t index) {
- return readUByte(index);
-}
-
-int32_t ReadableFontData::readUShort(int32_t index) {
- return 0xffff & (readUByte(index) << 8 | readUByte(index + 1));
-}
-
-int32_t ReadableFontData::readShort(int32_t index) {
- return ((readByte(index) << 8 | readUByte(index + 1)) << 16) >> 16;
-}
-
-int32_t ReadableFontData::readUInt24(int32_t index) {
- return 0xffffff & (readUByte(index) << 16 |
- readUByte(index + 1) << 8 | readUByte(index + 2));
-}
-
-int64_t ReadableFontData::readULong(int32_t index) {
- return 0xffffffffL & (readUByte(index) << 24 | readUByte(index + 1) << 16 |
- readUByte(index + 2) << 8 | readUByte(index + 3));
-}
-
-int32_t ReadableFontData::readULongAsInt(int32_t index) {
- int64_t ulong = readULong(index);
-#if !defined (SFNTLY_NO_EXCEPTION)
- if ((ulong & 0x80000000) == 0x80000000) {
- throw ArithmeticException("Long value too large to fit into an integer.");
- }
-#endif
- return ((int32_t)ulong) & ~0x80000000;
-}
-
-int32_t ReadableFontData::readLong(int32_t index) {
- return readByte(index) << 24 | readUByte(index + 1) << 16 |
- readUByte(index + 2) << 8 | readUByte(index + 3);
-}
-
-int32_t ReadableFontData::readFixed(int32_t index) {
- return readLong(index);
-}
-
-int64_t ReadableFontData::readDateTimeAsLong(int32_t index) {
- return (int64_t)readULong(index) << 32 | readULong(index + 4);
-}
-
-int32_t ReadableFontData::readFWord(int32_t index) {
- return readShort(index);
-}
-
-int32_t ReadableFontData::readFUFWord(int32_t index) {
- return readUShort(index);
-}
-
-int32_t ReadableFontData::copyTo(OutputStream* os) {
- return array_->copyTo(os, boundOffset(0), length());
-}
-
-int32_t ReadableFontData::copyTo(WritableFontData* wfd) {
- return array_->copyTo(wfd->boundOffset(0), wfd->array_, boundOffset(0),
- length());
-}
-
-int32_t ReadableFontData::copyTo(ByteArray* ba) {
- return array_->copyTo(ba, boundOffset(0), length());
-}
-
-CALLER_ATTACH FontData* ReadableFontData::slice(int32_t offset,
- int32_t length) {
- if (offset < 0 || offset + length > size()) {
- return NULL;
- }
- FontDataPtr slice = new ReadableFontData(this, offset, length);
- // Note: exception not ported because the condition is always false in C++.
- // if (slice == null) { throw new IndexOutOfBoundsException( ...
- return slice.detach();
-}
-
-CALLER_ATTACH FontData* ReadableFontData::slice(int32_t offset) {
- if (offset < 0 || offset > size()) {
- return NULL;
- }
- FontDataPtr slice = new ReadableFontData(this, offset);
- // Note: exception not ported because the condition is always false in C++.
- // if (slice == null) { throw new IndexOutOfBoundsException( ...
- return slice.detach();
-}
-
} // namespace sfntly
diff --git a/sfntly/data/readable_font_data.h b/sfntly/data/readable_font_data.h
index be466de..b1ca846 100644
--- a/sfntly/data/readable_font_data.h
+++ b/sfntly/data/readable_font_data.h
@@ -30,6 +30,69 @@
explicit ReadableFontData(ByteArray* array);
virtual ~ReadableFontData();
+ // Get a computed checksum for the data. This checksum uses the OpenType spec
+ // calculation. Every ULong value (32 bit unsigned) in the data is summed and
+ // the resulting value is truncated to 32 bits. If the data length in bytes is
+ // not an integral multiple of 4 then any remaining bytes are treated as the
+ // start of a 4 byte sequence whose remaining bytes are zero.
+ // @return the checksum
+ int64_t Checksum();
+
+ // Sets the bounds to use for computing the checksum. These bounds are in
+ // begin and end pairs. If an odd number is given then the final range is
+ // assumed to extend to the end of the data. The lengths of each range must be
+ // a multiple of 4.
+ // @param ranges the range bounds to use for the checksum
+ void SetCheckSumRanges(const IntegerList& ranges);
+
+ virtual int32_t ReadUByte(int32_t index);
+ virtual int32_t ReadByte(int32_t index);
+ virtual int32_t ReadBytes(int32_t index, ByteVector* b, int32_t offset,
+ int32_t length);
+ virtual int32_t ReadChar(int32_t index);
+ virtual int32_t ReadUShort(int32_t index);
+ virtual int32_t ReadShort(int32_t index);
+ virtual int32_t ReadUInt24(int32_t index);
+ virtual int64_t ReadULong(int32_t index);
+ virtual int32_t ReadULongAsInt(int32_t index);
+ virtual int32_t ReadLong(int32_t index);
+ virtual int32_t ReadFixed(int32_t index);
+ virtual int64_t ReadDateTimeAsLong(int32_t index);
+
+ virtual int32_t ReadFWord(int32_t index);
+ virtual int32_t ReadFUFWord(int32_t index);
+
+ virtual int32_t CopyTo(OutputStream* os);
+ virtual int32_t CopyTo(WritableFontData* wfd);
+ virtual int32_t CopyTo(ByteArray* ba);
+
+ // TODO(arthurhsu): IMPLEMENT
+ /*
+ virtual int32_t ReadFUnit(int32_t index);
+ virtual int64_t ReadF2Dot14(int32_t index);
+ virtual int64_t ReadLongDateTime(int32_t index);
+ virtual int32_t SearchUShort(int32_t start, int32_t length, int32_t key);
+ virtual int32_t SearchUShort(int32_t start_index, int32_t start_offset,
+ int32_t count_index, int32_t count_offset,
+ int32_t length, int32_t key);
+ virtual int32_t SearchULong(int32_t start_index, int32_t start_offset,
+ int32_t end_index, int32_t end_offset,
+ int32_t length, int32_t key);
+ */
+
+ // Makes a slice of this FontData. The returned slice will share the data with
+ // the original FontData.
+ // @param offset the start of the slice
+ // @param length the number of bytes in the slice
+ // @return a slice of the original FontData
+ virtual CALLER_ATTACH FontData* Slice(int32_t offset, int32_t length);
+
+ // Makes a bottom bound only slice of this array. The returned slice will
+ // share the data with the original FontData.
+ // @param offset the start of the slice
+ // @return a slice of the original FontData
+ virtual CALLER_ATTACH FontData* Slice(int32_t offset);
+
protected:
// Constructor. Creates a bounded wrapper of another ReadableFontData from the
// given offset until the end of the original ReadableFontData.
@@ -44,76 +107,10 @@
ReadableFontData(ReadableFontData* data, int32_t offset, int32_t length);
private:
- void computeChecksum();
- int64_t computeCheckSum(int32_t low_bound, int32_t high_bound);
+ void ComputeChecksum();
+ int64_t ComputeCheckSum(int32_t low_bound, int32_t high_bound);
- public:
- // Get a computed checksum for the data. This checksum uses the OpenType spec
- // calculation. Every ULong value (32 bit unsigned) in the data is summed and
- // the resulting value is truncated to 32 bits. If the data length in bytes is
- // not an integral multiple of 4 then any remaining bytes are treated as the
- // start of a 4 byte sequence whose remaining bytes are zero.
- // @return the checksum
- int64_t checksum();
-
- // Sets the bounds to use for computing the checksum. These bounds are in
- // begin and end pairs. If an odd number is given then the final range is
- // assumed to extend to the end of the data. The lengths of each range must be
- // a multiple of 4.
- // @param ranges the range bounds to use for the checksum
- void setCheckSumRanges(const IntegerList& ranges);
-
- public:
- virtual int32_t readUByte(int32_t index);
- virtual int32_t readByte(int32_t index);
- virtual int32_t readBytes(int32_t index, ByteVector* b, int32_t offset,
- int32_t length);
- virtual int32_t readChar(int32_t index);
- virtual int32_t readUShort(int32_t index);
- virtual int32_t readShort(int32_t index);
- virtual int32_t readUInt24(int32_t index);
- virtual int64_t readULong(int32_t index);
- virtual int32_t readULongAsInt(int32_t index);
- virtual int32_t readLong(int32_t index);
- virtual int32_t readFixed(int32_t index);
- virtual int64_t readDateTimeAsLong(int32_t index);
-
- virtual int32_t readFWord(int32_t index);
- virtual int32_t readFUFWord(int32_t index);
-
- virtual int32_t copyTo(OutputStream* os);
- virtual int32_t copyTo(WritableFontData* wfd);
- virtual int32_t copyTo(ByteArray* ba);
-
- // TODO(arthurhsu): IMPLEMENT
- /*
- virtual int32_t readFUnit(int32_t index);
- virtual int64_t readF2Dot14(int32_t index);
- virtual int64_t readLongDateTime(int32_t index);
- virtual int32_t searchUShort(int32_t start, int32_t length, int32_t key);
- virtual int32_t searchUShort(int32_t start_index, int32_t start_offset,
- int32_t count_index, int32_t count_offset,
- int32_t length, int32_t key);
- virtual int32_t searchULong(int32_t start_index, int32_t start_offset,
- int32_t end_index, int32_t end_offset,
- int32_t length, int32_t key);
- */
-
- // Makes a slice of this FontData. The returned slice will share the data with
- // the original FontData.
- // @param offset the start of the slice
- // @param length the number of bytes in the slice
- // @return a slice of the original FontData
- virtual CALLER_ATTACH FontData* slice(int32_t offset, int32_t length);
-
- // Makes a bottom bound only slice of this array. The returned slice will
- // share the data with the original FontData.
- // @param offset the start of the slice
- // @return a slice of the original FontData
- virtual CALLER_ATTACH FontData* slice(int32_t offset);
-
- private:
- bool checksum_set_; // TODO(arthurhsu): IMPLEMENT: must be set atomically
+ bool checksum_set_; // TODO(arthurhsu): IMPLEMENT: must be set atomically.
int64_t checksum_;
IntegerList checksum_range_;
};
diff --git a/sfntly/data/writable_font_data.cc b/sfntly/data/writable_font_data.cc
index 8588acb..586acc1 100644
--- a/sfntly/data/writable_font_data.cc
+++ b/sfntly/data/writable_font_data.cc
@@ -18,111 +18,116 @@
namespace sfntly {
+WritableFontData::WritableFontData(ByteArray* ba) : ReadableFontData(ba) {
+}
+
WritableFontData::~WritableFontData() {}
-WritableFontData::WritableFontData(ByteArray* ba) : ReadableFontData(ba) {
+int32_t WritableFontData::WriteByte(int32_t index, byte_t b) {
+ array_->Put(BoundOffset(index), b);
+ return 1;
+}
+
+int32_t WritableFontData::WriteBytes(int32_t offset,
+ ByteVector* b,
+ int32_t index,
+ int32_t length) {
+ return array_->Put(BoundOffset(offset),
+ b,
+ index,
+ BoundLength(offset, length));
+}
+
+int32_t WritableFontData::WriteBytes(int32_t index, ByteVector* b) {
+ return WriteBytes(index, b, 0, b->size());
+}
+
+int32_t WritableFontData::WriteChar(int32_t index, byte_t c) {
+ return WriteByte(index, c);
+}
+
+int32_t WritableFontData::WriteUShort(int32_t index, int32_t us) {
+ WriteByte(index, (byte_t)((us >> 8) & 0xff));
+ WriteByte(index + 1, (byte_t)(us & 0xff));
+ return 2;
+}
+
+int32_t WritableFontData::WriteUShortLE(int32_t index, int32_t us) {
+ WriteByte(index, (byte_t)(us & 0xff));
+ WriteByte(index + 1, (byte_t)((us >> 8) & 0xff));
+ return 2;
+}
+
+int32_t WritableFontData::WriteShort(int32_t index, int32_t s) {
+ return WriteUShort(index, s);
+}
+
+int32_t WritableFontData::WriteUInt24(int32_t index, int32_t ui) {
+ WriteByte(index, (byte_t)((ui >> 16) & 0xff));
+ WriteByte(index + 1, (byte_t)((ui >> 8) & 0xff));
+ WriteByte(index + 2, (byte_t)(ui & 0xff));
+ return 3;
+}
+
+int32_t WritableFontData::WriteULong(int32_t index, int64_t ul) {
+ WriteByte(index, (byte_t)((ul >> 24) & 0xff));
+ WriteByte(index + 1, (byte_t)((ul >> 16) & 0xff));
+ WriteByte(index + 2, (byte_t)((ul >> 8) & 0xff));
+ WriteByte(index + 3, (byte_t)(ul & 0xff));
+ return 4;
+}
+
+int32_t WritableFontData::WriteULongLE(int32_t index, int64_t ul) {
+ WriteByte(index, (byte_t)(ul & 0xff));
+ WriteByte(index + 1, (byte_t)((ul >> 8) & 0xff));
+ WriteByte(index + 2, (byte_t)((ul >> 16) & 0xff));
+ WriteByte(index + 3, (byte_t)((ul >> 24) & 0xff));
+ return 4;
+}
+
+int32_t WritableFontData::WriteLong(int32_t index, int64_t l) {
+ return WriteULong(index, l);
+}
+
+int32_t WritableFontData::WriteFixed(int32_t index, int32_t l) {
+ return WriteLong(index, l);
+}
+
+int32_t WritableFontData::WriteDateTime(int32_t index, int64_t date) {
+ WriteULong(index, (date >> 32) & 0xffffffff);
+ WriteULong(index + 4, date & 0xffffffff);
+ return 8;
+}
+
+CALLER_ATTACH FontData* WritableFontData::Slice(int32_t offset,
+ int32_t length) {
+ if (offset < 0 || offset + length > Size()) {
+ return NULL;
+ }
+ FontDataPtr slice = new WritableFontData(this, offset, length);
+ // Note: exception not ported because the condition is always false in C++.
+ // if (slice == null) { throw new IndexOutOfBoundsException( ...
+ return slice.Detach();
+}
+
+CALLER_ATTACH FontData* WritableFontData::Slice(int32_t offset) {
+ if (offset > Size()) {
+ return NULL;
+ }
+ FontDataPtr slice = new WritableFontData(this, offset);
+ // Note: exception not ported because the condition is always false in C++.
+ // if (slice == null) { throw new IndexOutOfBoundsException( ...
+ return slice.Detach();
}
WritableFontData::WritableFontData(WritableFontData* data, int32_t offset)
: ReadableFontData(data, offset) {
}
-WritableFontData::WritableFontData(WritableFontData* data, int32_t offset,
+WritableFontData::WritableFontData(WritableFontData* data,
+ int32_t offset,
int32_t length)
: ReadableFontData(data, offset, length) {
}
-int32_t WritableFontData::writeByte(int32_t index, byte_t b) {
- array_->put(boundOffset(index), b);
- return 1;
-}
-
-int32_t WritableFontData::writeBytes(int32_t offset, ByteVector* b,
- int32_t index, int32_t length) {
- return array_->put(boundOffset(offset), b, index,
- boundLength(offset, length));
-}
-
-int32_t WritableFontData::writeBytes(int32_t index, ByteVector* b) {
- return writeBytes(index, b, 0, b->size());
-}
-
-int32_t WritableFontData::writeChar(int32_t index, byte_t c) {
- return writeByte(index, c);
-}
-
-int32_t WritableFontData::writeUShort(int32_t index, int32_t us) {
- writeByte(index, (byte_t)((us >> 8) & 0xff));
- writeByte(index + 1, (byte_t)(us & 0xff));
- return 2;
-}
-
-int32_t WritableFontData::writeUShortLE(int32_t index, int32_t us) {
- writeByte(index, (byte_t)(us & 0xff));
- writeByte(index + 1, (byte_t)((us >> 8) & 0xff));
- return 2;
-}
-
-int32_t WritableFontData::writeShort(int32_t index, int32_t s) {
- return writeUShort(index, s);
-}
-
-int32_t WritableFontData::writeUInt24(int32_t index, int32_t ui) {
- writeByte(index, (byte_t)((ui >> 16) & 0xff));
- writeByte(index + 1, (byte_t)((ui >> 8) & 0xff));
- writeByte(index + 2, (byte_t)(ui & 0xff));
- return 3;
-}
-
-int32_t WritableFontData::writeULong(int32_t index, int64_t ul) {
- writeByte(index, (byte_t)((ul >> 24) & 0xff));
- writeByte(index + 1, (byte_t)((ul >> 16) & 0xff));
- writeByte(index + 2, (byte_t)((ul >> 8) & 0xff));
- writeByte(index + 3, (byte_t)(ul & 0xff));
- return 4;
-}
-
-int32_t WritableFontData::writeULongLE(int32_t index, int64_t ul) {
- writeByte(index, (byte_t)(ul & 0xff));
- writeByte(index + 1, (byte_t)((ul >> 8) & 0xff));
- writeByte(index + 2, (byte_t)((ul >> 16) & 0xff));
- writeByte(index + 3, (byte_t)((ul >> 24) & 0xff));
- return 4;
-}
-
-int32_t WritableFontData::writeLong(int32_t index, int64_t l) {
- return writeULong(index, l);
-}
-
-int32_t WritableFontData::writeFixed(int32_t index, int32_t l) {
- return writeLong(index, l);
-}
-
-int32_t WritableFontData::writeDateTime(int32_t index, int64_t date) {
- writeULong(index, (date >> 32) & 0xffffffff);
- writeULong(index + 4, date & 0xffffffff);
- return 8;
-}
-
-CALLER_ATTACH FontData* WritableFontData::slice(int32_t offset,
- int32_t length) {
- if (offset < 0 || offset + length > size()) {
- return NULL;
- }
- FontDataPtr slice = new WritableFontData(this, offset, length);
- // Note: exception not ported because the condition is always false in C++.
- // if (slice == null) { throw new IndexOutOfBoundsException( ...
- return slice.detach();
-}
-
-CALLER_ATTACH FontData* WritableFontData::slice(int32_t offset) {
- if (offset > size()) {
- return NULL;
- }
- FontDataPtr slice = new WritableFontData(this, offset);
- // Note: exception not ported because the condition is always false in C++.
- // if (slice == null) { throw new IndexOutOfBoundsException( ...
- return slice.detach();
-}
-
} // namespace sfntly
diff --git a/sfntly/data/writable_font_data.h b/sfntly/data/writable_font_data.h
index 9542cd0..98c9204 100644
--- a/sfntly/data/writable_font_data.h
+++ b/sfntly/data/writable_font_data.h
@@ -26,38 +26,39 @@
explicit WritableFontData(ByteArray* ba);
virtual ~WritableFontData();
- private:
- WritableFontData(WritableFontData* data, int32_t offset);
- WritableFontData(WritableFontData* data, int32_t offset, int32_t length);
-
- public:
- virtual int32_t writeByte(int32_t index, byte_t b);
- virtual int32_t writeBytes(int32_t offset, ByteVector* b, int32_t index,
+ virtual int32_t WriteByte(int32_t index, byte_t b);
+ virtual int32_t WriteBytes(int32_t offset,
+ ByteVector* b,
+ int32_t index,
int32_t length);
- virtual int32_t writeBytes(int32_t index, ByteVector* b);
- virtual int32_t writeChar(int32_t index, byte_t c);
- virtual int32_t writeUShort(int32_t index, int32_t us);
- virtual int32_t writeUShortLE(int32_t index, int32_t us);
- virtual int32_t writeShort(int32_t index, int32_t s);
- virtual int32_t writeUInt24(int32_t index, int32_t ui);
- virtual int32_t writeULong(int32_t index, int64_t ul);
- virtual int32_t writeULongLE(int32_t index, int64_t ul);
- virtual int32_t writeLong(int32_t index, int64_t l);
- virtual int32_t writeFixed(int32_t index, int32_t l);
- virtual int32_t writeDateTime(int32_t index, int64_t date);
+ virtual int32_t WriteBytes(int32_t index, ByteVector* b);
+ virtual int32_t WriteChar(int32_t index, byte_t c);
+ virtual int32_t WriteUShort(int32_t index, int32_t us);
+ virtual int32_t WriteUShortLE(int32_t index, int32_t us);
+ virtual int32_t WriteShort(int32_t index, int32_t s);
+ virtual int32_t WriteUInt24(int32_t index, int32_t ui);
+ virtual int32_t WriteULong(int32_t index, int64_t ul);
+ virtual int32_t WriteULongLE(int32_t index, int64_t ul);
+ virtual int32_t WriteLong(int32_t index, int64_t l);
+ virtual int32_t WriteFixed(int32_t index, int32_t l);
+ virtual int32_t WriteDateTime(int32_t index, int64_t date);
// Makes a slice of this FontData. The returned slice will share the data with
// the original FontData.
// @param offset the start of the slice
// @param length the number of bytes in the slice
// @return a slice of the original FontData
- virtual CALLER_ATTACH FontData* slice(int32_t offset, int32_t length);
+ virtual CALLER_ATTACH FontData* Slice(int32_t offset, int32_t length);
// Makes a bottom bound only slice of this array. The returned slice will
// share the data with the original FontData.
// @param offset the start of the slice
// @return a slice of the original FontData
- virtual CALLER_ATTACH FontData* slice(int32_t offset);
+ virtual CALLER_ATTACH FontData* Slice(int32_t offset);
+
+ private:
+ WritableFontData(WritableFontData* data, int32_t offset);
+ WritableFontData(WritableFontData* data, int32_t offset, int32_t length);
};
typedef Ptr<WritableFontData> WritableFontDataPtr;
diff --git a/sfntly/font.cc b/sfntly/font.cc
index bd5614f..fefa17e 100644
--- a/sfntly/font.cc
+++ b/sfntly/font.cc
@@ -14,95 +14,85 @@
* limitations under the License.
*/
+#include "sfntly/font.h"
+
#include <functional>
#include <algorithm>
#include <map>
#include <typeinfo>
-#include "sfntly/font.h"
+#include "sfntly/data/font_input_stream.h"
#include "sfntly/font_factory.h"
-#include "sfntly/tag.h"
#include "sfntly/math/fixed1616.h"
#include "sfntly/math/font_math.h"
-#include "sfntly/data/font_input_stream.h"
#include "sfntly/font_header_table.h"
#include "sfntly/horizontal_header_table.h"
#include "sfntly/horizontal_metrics_table.h"
-#include "sfntly/maximum_profile_table.h"
#include "sfntly/loca_table.h"
+#include "sfntly/maximum_profile_table.h"
#include "sfntly/port/exception_type.h"
+#include "sfntly/tag.h"
namespace sfntly {
-const int32_t SFNTVERSION_1 = Fixed1616::fixed(1, 0);
+const int32_t SFNTVERSION_1 = Fixed1616::Fixed(1, 0);
/******************************************************************************
* Font class
******************************************************************************/
Font::~Font() {}
+bool Font::HasTable(int32_t tag) {
+ TableMap::const_iterator result = tables_.find(tag);
+ TableMap::const_iterator end = tables_.end();
+ return (result != end);
+}
+
+Table* Font::GetTable(int32_t tag) {
+ if (!HasTable(tag)) {
+ return NULL;
+ }
+ return tables_[tag];
+}
+
+TableMap* Font::Tables() {
+ return &tables_;
+}
+
+void Font::Serialize(OutputStream* os, IntegerList* table_ordering) {
+ assert(table_ordering);
+ IntegerList final_table_ordering;
+ TableOrdering(table_ordering, &final_table_ordering);
+ TableHeaderList table_records;
+ BuildTableHeadersForSerialization(&final_table_ordering, &table_records);
+
+ FontOutputStream fos(os);
+ SerializeHeader(&fos, &table_records);
+ SerializeTables(&fos, &table_records);
+}
+
+CALLER_ATTACH WritableFontData* Font::GetNewData(int32_t size) {
+ return factory_->GetNewData(size);
+}
+
Font::Font(FontFactory* factory, int32_t sfnt_version, ByteVector* digest,
TableMap* tables)
- : factory_(factory), sfnt_version_(sfnt_version) {
+ : factory_(factory),
+ sfnt_version_(sfnt_version) {
// non-trivial assignments that makes debugging hard if placed in
// initialization list
digest_ = *digest;
tables_ = *tables;
}
-int32_t Font::version() {
- return sfnt_version_;
-}
-
-ByteVector* Font::digest() {
- return &digest_;
-}
-
-int64_t Font::checksum() {
- return checksum_;
-}
-
-int32_t Font::numTables() {
- return (int32_t)tables_.size();
-}
-
-bool Font::hasTable(int32_t tag) {
- TableMap::const_iterator result = tables_.find(tag);
- TableMap::const_iterator end = tables_.end();
- return (result != end);
-}
-
-Table* Font::table(int32_t tag) {
- if (!hasTable(tag)) {
- return NULL;
- }
- return tables_[tag];
-}
-
-TableMap* Font::tables() {
- return &tables_;
-}
-
-void Font::serialize(OutputStream* os, IntegerList* table_ordering) {
- assert(table_ordering);
- IntegerList final_table_ordering;
- tableOrdering(table_ordering, &final_table_ordering);
- TableHeaderList table_records;
- buildTableHeadersForSerialization(&final_table_ordering, &table_records);
-
- FontOutputStream fos(os);
- serializeHeader(&fos, &table_records);
- serializeTables(&fos, &table_records);
-}
-
-void Font::buildTableHeadersForSerialization(IntegerList* table_ordering,
+void Font::BuildTableHeadersForSerialization(IntegerList* table_ordering,
TableHeaderList* table_headers) {
assert(table_headers);
assert(table_ordering);
IntegerList final_table_ordering;
- tableOrdering(table_ordering, &final_table_ordering);
- int32_t table_offset = Offset::kTableRecordBegin + numTables() *
+ TableOrdering(table_ordering, &final_table_ordering);
+ int32_t table_offset = Offset::kTableRecordBegin + num_tables() *
Offset::kTableRecordSize;
for (IntegerList::iterator tag = final_table_ordering.begin(),
tag_end = final_table_ordering.end();
@@ -110,42 +100,42 @@
TablePtr table = tables_[*tag];
if (table != NULL) {
TableHeaderPtr header =
- new Table::Header(*tag, table->calculatedChecksum(), table_offset,
- table->length());
+ new Table::Header(*tag, table->CalculatedChecksum(), table_offset,
+ table->Length());
table_headers->push_back(header);
- table_offset += (table->length() + 3) & ~3;
+ table_offset += (table->Length() + 3) & ~3;
}
}
}
-void Font::serializeHeader(FontOutputStream* fos,
+void Font::SerializeHeader(FontOutputStream* fos,
TableHeaderList* table_headers) {
- fos->writeFixed(sfnt_version_);
- fos->writeUShort(table_headers->size());
- int32_t log2_of_max_power_of_2 = FontMath::log2(table_headers->size());
+ fos->WriteFixed(sfnt_version_);
+ fos->WriteUShort(table_headers->size());
+ int32_t log2_of_max_power_of_2 = FontMath::Log2(table_headers->size());
int32_t search_range = 2 << (log2_of_max_power_of_2 - 1 + 4);
- fos->writeUShort(search_range);
- fos->writeUShort(log2_of_max_power_of_2);
- fos->writeUShort((table_headers->size() * 16) - search_range);
+ fos->WriteUShort(search_range);
+ fos->WriteUShort(log2_of_max_power_of_2);
+ fos->WriteUShort((table_headers->size() * 16) - search_range);
for (TableHeaderList::iterator record = table_headers->begin(),
record_end = table_headers->end();
record != record_end; ++record) {
- fos->writeULong((*record)->tag());
- fos->writeULong((int32_t)((*record)->checksum()));
- fos->writeULong((*record)->offset());
- fos->writeULong((*record)->length());
+ fos->WriteULong((*record)->tag());
+ fos->WriteULong((int32_t)((*record)->checksum()));
+ fos->WriteULong((*record)->offset());
+ fos->WriteULong((*record)->length());
}
}
-void Font::serializeTables(FontOutputStream* fos,
+void Font::SerializeTables(FontOutputStream* fos,
TableHeaderList* table_headers) {
ByteVector SERIALIZATION_FILLER(3);
std::fill(SERIALIZATION_FILLER.begin(), SERIALIZATION_FILLER.end(), 0);
for (TableHeaderList::iterator record = table_headers->begin(),
end_of_headers = table_headers->end();
record != end_of_headers; ++record) {
- TablePtr target_table = table((*record)->tag());
+ TablePtr target_table = GetTable((*record)->tag());
if (target_table == NULL) {
#if defined (SFNTLY_NO_EXCEPTION)
return;
@@ -153,22 +143,22 @@
throw IOException("Table out of sync with font header.");
#endif
}
- int32_t table_size = target_table->serialize(fos);
+ int32_t table_size = target_table->Serialize(fos);
if (table_size != (*record)->length()) {
assert(false);
}
int32_t filler_size = ((table_size + 3) & ~3) - table_size;
- fos->write(&SERIALIZATION_FILLER, 0, filler_size);
+ fos->Write(&SERIALIZATION_FILLER, 0, filler_size);
}
}
-void Font::tableOrdering(IntegerList* default_table_ordering,
+void Font::TableOrdering(IntegerList* default_table_ordering,
IntegerList* table_ordering) {
assert(default_table_ordering);
assert(table_ordering);
table_ordering->clear();
if (default_table_ordering->empty()) {
- defaultTableOrdering(default_table_ordering);
+ DefaultTableOrdering(default_table_ordering);
}
typedef std::map<int32_t, bool> Int2Bool;
@@ -181,7 +171,7 @@
for (IntegerList::iterator tag = default_table_ordering->begin(),
tag_end = default_table_ordering->end();
tag != tag_end; ++tag) {
- if (hasTable(*tag)) {
+ if (HasTable(*tag)) {
table_ordering->push_back(*tag);
tables_in_font[*tag] = true;
}
@@ -194,10 +184,10 @@
}
}
-void Font::defaultTableOrdering(IntegerList* default_table_ordering) {
+void Font::DefaultTableOrdering(IntegerList* default_table_ordering) {
assert(default_table_ordering);
default_table_ordering->clear();
- if (hasTable(Tag::CFF)) {
+ if (HasTable(Tag::CFF)) {
default_table_ordering->resize(CFF_TABLE_ORDERING_SIZE);
std::copy(CFF_TABLE_ORDERING, CFF_TABLE_ORDERING + CFF_TABLE_ORDERING_SIZE,
default_table_ordering->begin());
@@ -209,62 +199,32 @@
default_table_ordering->begin());
}
-CALLER_ATTACH WritableFontData* Font::getNewData(int32_t size) {
- return factory_->getNewData(size);
-}
-
/******************************************************************************
* Font::Builder class
******************************************************************************/
Font::Builder::~Builder() {}
-Font::Builder::Builder(FontFactory* factory)
- : factory_(factory), sfnt_version_(SFNTVERSION_1) {
-}
-
-void Font::Builder::loadFont(InputStream* is) {
- // Note: we do not throw exception here for is. This is more of an assertion.
- assert(is);
- FontInputStream font_is(is);
- TableHeaderSortedSet records;
- readHeader(&font_is, &records);
- loadTableData(&records, &font_is, &data_blocks_);
- buildAllTableBuilders(&data_blocks_, &table_builders_);
- font_is.close();
-}
-
-void Font::Builder::loadFont(ByteArray* ba,
- int32_t offset_to_offset_table) {
- // Note: we do not throw exception here for is. This is more of an assertion.
- assert(ba);
- WritableFontDataPtr fd = new WritableFontData(ba);
- TableHeaderSortedSet records;
- readHeader(fd, offset_to_offset_table, &records);
- loadTableData(&records, fd, &data_blocks_);
- buildAllTableBuilders(&data_blocks_, &table_builders_);
-}
-
-CALLER_ATTACH Font::Builder* Font::Builder::getOTFBuilder(
+CALLER_ATTACH Font::Builder* Font::Builder::GetOTFBuilder(
FontFactory* factory, InputStream* is) {
FontBuilderPtr builder = new Builder(factory);
- builder->loadFont(is);
- return builder.detach();
+ builder->LoadFont(is);
+ return builder.Detach();
}
-CALLER_ATTACH Font::Builder* Font::Builder::getOTFBuilder(
+CALLER_ATTACH Font::Builder* Font::Builder::GetOTFBuilder(
FontFactory* factory, ByteArray* ba, int32_t offset_to_offset_table) {
FontBuilderPtr builder = new Builder(factory);
- builder->loadFont(ba, offset_to_offset_table);
- return builder.detach();
+ builder->LoadFont(ba, offset_to_offset_table);
+ return builder.Detach();
}
-CALLER_ATTACH Font::Builder* Font::Builder::getOTFBuilder(
+CALLER_ATTACH Font::Builder* Font::Builder::GetOTFBuilder(
FontFactory* factory) {
FontBuilderPtr builder = new Builder(factory);
- return builder.detach();
+ return builder.Detach();
}
-bool Font::Builder::readyToBuild() {
+bool Font::Builder::ReadyToBuild() {
// just read in data with no manipulation
if (table_builders_.empty() && !data_blocks_.empty()) {
return true;
@@ -275,73 +235,69 @@
table_builder_end = table_builders_.end();
table_builder != table_builder_end;
++table_builder) {
- if (!table_builder->second->readyToBuild())
+ if (!table_builder->second->ReadyToBuild())
return false;
}
return true;
}
-CALLER_ATTACH Font* Font::Builder::build() {
+CALLER_ATTACH Font* Font::Builder::Build() {
TableMap tables;
if (!table_builders_.empty()) {
- buildTablesFromBuilders(&table_builders_, &tables);
+ BuildTablesFromBuilders(&table_builders_, &tables);
}
FontPtr font = new Font(factory_, sfnt_version_, &digest_, &tables);
table_builders_.clear();
data_blocks_.clear();
- return font.detach();
+ return font.Detach();
}
-CALLER_ATTACH WritableFontData* Font::Builder::getNewData(int32_t capacity) {
- return factory_->getNewData(capacity);
+CALLER_ATTACH WritableFontData* Font::Builder::GetNewData(int32_t capacity) {
+ return factory_->GetNewData(capacity);
}
-CALLER_ATTACH WritableFontData* Font::Builder::getNewGrowableData(
+CALLER_ATTACH WritableFontData* Font::Builder::GetNewGrowableData(
ReadableFontData* src_data) {
- return factory_->getNewGrowableData(src_data);
+ return factory_->GetNewGrowableData(src_data);
}
-void Font::Builder::setDigest(ByteVector* digest) {
+void Font::Builder::SetDigest(ByteVector* digest) {
digest_.clear();
digest_ = *digest;
}
-void Font::Builder::cleanTableBuilders() {
+void Font::Builder::CleanTableBuilders() {
table_builders_.clear();
}
-bool Font::Builder::hasTableBuilder(int32_t tag) {
+bool Font::Builder::HasTableBuilder(int32_t tag) {
return (table_builders_.find(tag) != table_builders_.end());
}
-Table::Builder* Font::Builder::getTableBuilder(int32_t tag) {
- if (hasTableBuilder(tag))
+Table::Builder* Font::Builder::GetTableBuilder(int32_t tag) {
+ if (HasTableBuilder(tag))
return table_builders_[tag];
return NULL;
}
-CALLER_ATTACH Table::Builder* Font::Builder::newTableBuilder(int32_t tag) {
+CALLER_ATTACH Table::Builder* Font::Builder::NewTableBuilder(int32_t tag) {
TableHeaderPtr header = new Table::Header(tag);
- TableBuilderPtr builder = Table::Builder::getBuilder(this, header, NULL);
+ TableBuilderPtr builder = Table::Builder::GetBuilder(this, header, NULL);
table_builders_.insert(TableBuilderEntry(header->tag(), builder));
return builder;
}
-CALLER_ATTACH Table::Builder* Font::Builder::newTableBuilder(
- int32_t tag, ReadableFontData* src_data) {
+CALLER_ATTACH Table::Builder*
+ Font::Builder::NewTableBuilder(int32_t tag, ReadableFontData* src_data) {
WritableFontDataPtr data;
- data.attach(getNewGrowableData(src_data));
+ data.Attach(GetNewGrowableData(src_data));
TableHeaderPtr header = new Table::Header(tag);
- TableBuilderPtr builder = Table::Builder::getBuilder(this, header, data);
+ TableBuilderPtr builder = Table::Builder::GetBuilder(this, header, data);
table_builders_.insert(TableBuilderEntry(tag, builder));
return builder;
}
-TableBuilderMap* Font::Builder::tableBuilders() {
- return &table_builders_;
-}
-
-void Font::Builder::tableBuilderTags(IntegerSet* key_set) {
+void Font::Builder::TableBuilderTags(IntegerSet* key_set) {
assert(key_set);
key_set->clear();
for (TableBuilderMap::iterator i = table_builders_.begin(),
@@ -350,53 +306,76 @@
}
}
-void Font::Builder::removeTableBuilder(int32_t tag) {
+void Font::Builder::RemoveTableBuilder(int32_t tag) {
TableBuilderMap::iterator target = table_builders_.find(tag);
if (target != table_builders_.end()) {
table_builders_.erase(target);
}
}
-int32_t Font::Builder::numberOfTableBuilders() {
- return (int32_t)table_builders_.size();
+Font::Builder::Builder(FontFactory* factory)
+ : factory_(factory), sfnt_version_(SFNTVERSION_1) {
}
-int32_t Font::Builder::sfntWrapperSize() {
+void Font::Builder::LoadFont(InputStream* is) {
+ // Note: we do not throw exception here for is. This is more of an assertion.
+ assert(is);
+ FontInputStream font_is(is);
+ TableHeaderSortedSet records;
+ ReadHeader(&font_is, &records);
+ LoadTableData(&records, &font_is, &data_blocks_);
+ BuildAllTableBuilders(&data_blocks_, &table_builders_);
+ font_is.Close();
+}
+
+void Font::Builder::LoadFont(ByteArray* ba,
+ int32_t offset_to_offset_table) {
+ // Note: we do not throw exception here for is. This is more of an assertion.
+ assert(ba);
+ WritableFontDataPtr fd = new WritableFontData(ba);
+ TableHeaderSortedSet records;
+ ReadHeader(fd, offset_to_offset_table, &records);
+ LoadTableData(&records, fd, &data_blocks_);
+ BuildAllTableBuilders(&data_blocks_, &table_builders_);
+}
+
+int32_t Font::Builder::SfntWrapperSize() {
return Offset::kSfntHeaderSize +
(Offset::kTableRecordSize * table_builders_.size());
}
-void Font::Builder::buildAllTableBuilders(DataBlockMap* table_data,
+void Font::Builder::BuildAllTableBuilders(DataBlockMap* table_data,
TableBuilderMap* builder_map) {
for (DataBlockMap::iterator record = table_data->begin(),
record_end = table_data->end();
record != record_end; ++record) {
TableBuilderPtr builder;
- builder.attach(getTableBuilder(record->first.p_, record->second.p_));
+ builder.Attach(GetTableBuilder(record->first.p_, record->second.p_));
builder_map->insert(TableBuilderEntry(record->first->tag(), builder));
}
- interRelateBuilders(&table_builders_);
+ InterRelateBuilders(&table_builders_);
}
-CALLER_ATTACH Table::Builder* Font::Builder::getTableBuilder(
- Table::Header* header, WritableFontData* data) {
- return Table::Builder::getBuilder(this, header, data);
+CALLER_ATTACH Table::Builder*
+ Font::Builder::GetTableBuilder(Table::Header* header,
+ WritableFontData* data) {
+ return Table::Builder::GetBuilder(this, header, data);
}
-void Font::Builder::buildTablesFromBuilders(TableBuilderMap* builder_map,
+void Font::Builder::BuildTablesFromBuilders(TableBuilderMap* builder_map,
TableMap* table_map) {
- interRelateBuilders(builder_map);
+ InterRelateBuilders(builder_map);
// Now build all the tables.
for (TableBuilderMap::iterator builder = builder_map->begin(),
builder_end = builder_map->end();
builder != builder_end; ++builder) {
TablePtr table;
- if (builder->second->readyToBuild()) {
+ if (builder->second->ReadyToBuild()) {
#if !defined (SFNTLY_NO_EXCEPTION)
try {
#endif
- table.attach(down_cast<Table*>(builder->second->build()));
+ table.Attach(down_cast<Table*>(builder->second->Build()));
#if !defined (SFNTLY_NO_EXCEPTION)
} catch(IOException& e) {
std::string builder_string = "Unable to build table - ";
@@ -419,7 +398,7 @@
}
}
-void Font::Builder::interRelateBuilders(TableBuilderMap* builder_map) {
+void Font::Builder::InterRelateBuilders(TableBuilderMap* builder_map) {
FontHeaderTableBuilderPtr header_table_builder =
down_cast<FontHeaderTable::Builder*>((*builder_map)[Tag::head].p_);
HorizontalHeaderTableBuilderPtr horizontal_header_builder =
@@ -435,87 +414,89 @@
// set the inter table data required to build certain tables
if (horizontal_metrics_builder != NULL) {
if (max_profile_builder != NULL) {
- horizontal_metrics_builder->setNumGlyphs(
- max_profile_builder->numGlyphs());
+ horizontal_metrics_builder->SetNumGlyphs(
+ max_profile_builder->NumGlyphs());
}
if (horizontal_header_builder != NULL) {
- horizontal_metrics_builder->setNumberOfHMetrics(
- horizontal_header_builder->numberOfHMetrics());
+ horizontal_metrics_builder->SetNumberOfHMetrics(
+ horizontal_header_builder->NumberOfHMetrics());
}
}
if (loca_table_builder != NULL) {
if (max_profile_builder != NULL) {
- loca_table_builder->setNumGlyphs(max_profile_builder->numGlyphs());
+ loca_table_builder->SetNumGlyphs(max_profile_builder->NumGlyphs());
}
if (header_table_builder != NULL) {
- loca_table_builder->setFormatVersion(
- header_table_builder->indexToLocFormat());
+ loca_table_builder->SetFormatVersion(
+ header_table_builder->IndexToLocFormat());
}
}
}
-void Font::Builder::readHeader(FontInputStream* is,
+void Font::Builder::ReadHeader(FontInputStream* is,
TableHeaderSortedSet* records) {
assert(records);
- sfnt_version_ = is->readFixed();
- num_tables_ = is->readUShort();
- search_range_ = is->readUShort();
- entry_selector_ = is->readUShort();
- range_shift_ = is->readUShort();
+ sfnt_version_ = is->ReadFixed();
+ num_tables_ = is->ReadUShort();
+ search_range_ = is->ReadUShort();
+ entry_selector_ = is->ReadUShort();
+ range_shift_ = is->ReadUShort();
for (int32_t table_number = 0; table_number < num_tables_; ++table_number) {
// Need to use temporary vars here. C++ evaluates function parameters from
// right to left and thus breaks the order of input stream.
- int32_t tag = is->readULongAsInt();
- int64_t checksum = is->readULong();
- int32_t offset = is->readULongAsInt();
- int32_t length = is->readULongAsInt();
+ int32_t tag = is->ReadULongAsInt();
+ int64_t checksum = is->ReadULong();
+ int32_t offset = is->ReadULongAsInt();
+ int32_t length = is->ReadULongAsInt();
TableHeaderPtr table = new Table::Header(tag, checksum, offset, length);
records->insert(table);
}
}
-void Font::Builder::loadTableData(TableHeaderSortedSet* headers,
+void Font::Builder::ReadHeader(ReadableFontData* fd,
+ int32_t offset,
+ TableHeaderSortedSet* records) {
+ assert(records);
+ sfnt_version_ = fd->ReadFixed(offset + Offset::kSfntVersion);
+ num_tables_ = fd->ReadUShort(offset + Offset::kNumTables);
+ search_range_ = fd->ReadUShort(offset + Offset::kSearchRange);
+ entry_selector_ = fd->ReadUShort(offset + Offset::kEntrySelector);
+ range_shift_ = fd->ReadUShort(offset + Offset::kRangeShift);
+
+ int32_t table_offset = offset + Offset::kTableRecordBegin;
+ for (int32_t table_number = 0;
+ table_number < num_tables_;
+ table_number++, table_offset += Offset::kTableRecordSize) {
+ int32_t tag = fd->ReadULongAsInt(table_offset + Offset::kTableTag);
+ int64_t checksum = fd->ReadULong(table_offset + Offset::kTableCheckSum);
+ int32_t offset = fd->ReadULongAsInt(table_offset + Offset::kTableOffset);
+ int32_t length = fd->ReadULongAsInt(table_offset + Offset::kTableLength);
+ TableHeaderPtr table = new Table::Header(tag, checksum, offset, length);
+ records->insert(table);
+ }
+}
+
+void Font::Builder::LoadTableData(TableHeaderSortedSet* headers,
FontInputStream* is,
DataBlockMap* table_data) {
assert(table_data);
for (TableHeaderSortedSet::iterator
table_header = headers->begin(), table_end = headers->end();
table_header != table_end; ++table_header) {
- is->skip((*table_header)->offset() - is->position());
+ is->Skip((*table_header)->offset() - is->position());
FontInputStream table_is(is, (*table_header)->length());
int32_t roundup_length = ((*table_header)->length() + 3) & ~3;
- ByteArrayPtr array = factory_->getNewArray(roundup_length);
- array->copyFrom(&table_is, (*table_header)->length());
+ ByteArrayPtr array;
+ array.Attach(factory_->GetNewArray(roundup_length));
+ array->CopyFrom(&table_is, (*table_header)->length());
WritableFontDataPtr data = new WritableFontData(array);
table_data->insert(DataBlockEntry(*table_header, data));
}
}
-void Font::Builder::readHeader(ReadableFontData* fd, int32_t offset,
- TableHeaderSortedSet* records) {
- assert(records);
- sfnt_version_ = fd->readFixed(offset + Offset::kSfntVersion);
- num_tables_ = fd->readUShort(offset + Offset::kNumTables);
- search_range_ = fd->readUShort(offset + Offset::kSearchRange);
- entry_selector_ = fd->readUShort(offset + Offset::kEntrySelector);
- range_shift_ = fd->readUShort(offset + Offset::kRangeShift);
-
- int32_t table_offset = offset + Offset::kTableRecordBegin;
- for (int32_t table_number = 0;
- table_number < num_tables_;
- table_number++, table_offset += Offset::kTableRecordSize) {
- int32_t tag = fd->readULongAsInt(table_offset + Offset::kTableTag);
- int64_t checksum = fd->readULong(table_offset + Offset::kTableCheckSum);
- int32_t offset = fd->readULongAsInt(table_offset + Offset::kTableOffset);
- int32_t length = fd->readULongAsInt(table_offset + Offset::kTableLength);
- TableHeaderPtr table = new Table::Header(tag, checksum, offset, length);
- records->insert(table);
- }
-}
-
-void Font::Builder::loadTableData(TableHeaderSortedSet* headers,
+void Font::Builder::LoadTableData(TableHeaderSortedSet* headers,
WritableFontData* fd,
DataBlockMap* table_data) {
for (TableHeaderSortedSet::iterator
@@ -523,7 +504,7 @@
table_header != table_end; ++table_header) {
int32_t roundup_length = ((*table_header)->length() + 3) & ~3;
FontDataPtr sliced_data;
- sliced_data.attach(fd->slice((*table_header)->offset(), roundup_length));
+ sliced_data.Attach(fd->Slice((*table_header)->offset(), roundup_length));
WritableFontDataPtr data = down_cast<WritableFontData*>(sliced_data.p_);
table_data->insert(DataBlockEntry(*table_header, data));
}
diff --git a/sfntly/font.h b/sfntly/font.h
index cbd9607..5ce7f17 100644
--- a/sfntly/font.h
+++ b/sfntly/font.h
@@ -122,13 +122,132 @@
class FontFactory;
class Font : public RefCounted<Font> {
+ public:
+ class Builder : public FontDataTableBuilderContainer,
+ public RefCounted<Builder> {
+ public:
+ virtual ~Builder();
+
+ static CALLER_ATTACH Builder*
+ GetOTFBuilder(FontFactory* factory, InputStream* is);
+ static CALLER_ATTACH Builder*
+ GetOTFBuilder(FontFactory* factory,
+ ByteArray* ba,
+ int32_t offset_to_offset_table);
+ static CALLER_ATTACH Builder* GetOTFBuilder(FontFactory* factory);
+ virtual bool ReadyToBuild();
+ virtual CALLER_ATTACH Font* Build();
+ virtual CALLER_ATTACH WritableFontData* GetNewData(int32_t capacity);
+ virtual CALLER_ATTACH WritableFontData*
+ GetNewGrowableData(ReadableFontData* data);
+ virtual void SetDigest(ByteVector* digest);
+ virtual void CleanTableBuilders();
+ virtual bool HasTableBuilder(int32_t tag);
+ virtual Table::Builder* GetTableBuilder(int32_t tag);
+
+ // Creates a new table builder for the table type given by the table id tag.
+ // This new table has been added to the font and will replace any existing
+ // builder for that table.
+ // @return new empty table of the type specified by tag; if tag is not known
+ // then a generic OpenTypeTable is returned
+ virtual CALLER_ATTACH Table::Builder* NewTableBuilder(int32_t tag);
+ virtual CALLER_ATTACH Table::Builder*
+ NewTableBuilder(int32_t tag, ReadableFontData* src_data);
+ virtual TableBuilderMap* table_builders() { return &table_builders_; }
+ virtual void TableBuilderTags(IntegerSet* key_set);
+ // Note: different from Java: we don't return object in removeTableBuilder
+ virtual void RemoveTableBuilder(int32_t tag);
+ virtual int32_t number_of_table_builders() {
+ return (int32_t)table_builders_.size();
+ }
+
+ private:
+ explicit Builder(FontFactory* factory);
+ virtual void LoadFont(InputStream* is);
+ virtual void LoadFont(ByteArray* buffer, int32_t offset_to_offset_table);
+ int32_t SfntWrapperSize();
+ void BuildAllTableBuilders(DataBlockMap* table_data,
+ TableBuilderMap* builder_map);
+ CALLER_ATTACH Table::Builder*
+ GetTableBuilder(Table::Header* header, WritableFontData* data);
+ void BuildTablesFromBuilders(TableBuilderMap* builder_map,
+ TableMap* tables);
+ static void InterRelateBuilders(TableBuilderMap* builder_map);
+ void ReadHeader(FontInputStream* is, TableHeaderSortedSet* records);
+ void ReadHeader(ReadableFontData* fd,
+ int32_t offset,
+ TableHeaderSortedSet* records);
+ void LoadTableData(TableHeaderSortedSet* headers,
+ FontInputStream* is,
+ DataBlockMap* table_data);
+ void LoadTableData(TableHeaderSortedSet* headers,
+ WritableFontData* fd,
+ DataBlockMap* table_data);
+
+ TableBuilderMap table_builders_;
+ FontFactory* factory_; // dumb pointer, avoid circular refcounting
+ int32_t sfnt_version_;
+ int32_t num_tables_;
+ int32_t search_range_;
+ int32_t entry_selector_;
+ int32_t range_shift_;
+ DataBlockMap data_blocks_;
+ ByteVector digest_;
+ };
+
+ virtual ~Font();
+
+ // Gets the sfnt version set in the sfnt wrapper of the font.
+ int32_t version() { return sfnt_version_; }
+
+ // Gets a copy of the fonts digest that was created when the font was read. If
+ // no digest was set at creation time then the return result will be null.
+ ByteVector* digest() { return &digest_; }
+
+ // Get the checksum for this font.
+ int64_t checksum() { return checksum_; }
+
+ // Get the number of tables in this font.
+ int32_t num_tables() { return (int32_t)tables_.size(); }
+
+ // Whether the font has a particular table.
+ bool HasTable(int32_t tag);
+
+ // UNIMPLEMENTED: public Iterator<? extends Table> iterator
+
+ // Get the table in this font with the specified id.
+ // @param tag the identifier of the table
+ // @return the table specified if it exists; null otherwise
+ // C++ port: rename table() to GetTable()
+ Table* GetTable(int32_t tag);
+
+ // Get a map of the tables in this font accessed by table tag.
+ // @return an unmodifiable view of the tables in this font
+ TableMap* Tables();
+
+ // Serialize the font to the output stream.
+ // @param os the destination for the font serialization
+ // @param tableOrdering the table ordering to apply
+ void Serialize(OutputStream* os, IntegerList* table_ordering);
+
+ // Get a new data object. The size is a request for a data object and the
+ // returned data object will support at least that amount. A value greater
+ // than zero for the size is a request for a fixed size data object. A
+ // negative or zero value for the size is a request for a variable sized data
+ // object with the absolute value of the size being an estimate of the space
+ // required.
+ // @param size greater than zero is a request for a fixed size data object of
+ // the given size; less than or equal to zero is a request for a
+ // variable size data object with the absolute size as an estimate
+ CALLER_ATTACH WritableFontData* GetNewData(int32_t size);
+
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 {
- // Offsets within the main directory
+ // Offsets within the main directory
kSfntVersion = 0,
kNumTables = 4,
kSearchRange = 6,
@@ -137,7 +256,7 @@
kTableRecordBegin = 12,
kSfntHeaderSize = 12,
- // Offsets within a specific table record
+ // Offsets within a specific table record
kTableTag = 0,
kTableCheckSum = 4,
kTableOffset = 8,
@@ -150,139 +269,17 @@
// static const int32_t CFF_TABLE_ORDERING[];
// static const int32_t TRUE_TYPE_TABLE_ORDERING[];
- public:
- virtual ~Font();
-
- private:
Font(FontFactory* factory, int32_t sfnt_version, ByteVector* digest,
TableMap* tables);
- public:
- // Gets the sfnt version set in the sfnt wrapper of the font.
- virtual int32_t version();
+ void BuildTableHeadersForSerialization(IntegerList* table_ordering,
+ TableHeaderList* table_headers);
+ void SerializeHeader(FontOutputStream* fos, TableHeaderList* table_headers);
+ void SerializeTables(FontOutputStream* fos, TableHeaderList* table_headers);
+ void TableOrdering(IntegerList* default_table_ordering,
+ IntegerList* table_ordering);
+ void DefaultTableOrdering(IntegerList* default_table_ordering);
- // Gets a copy of the fonts digest that was created when the font was read. If
- // no digest was set at creation time then the return result will be null.
- virtual ByteVector* digest();
-
- // Get the checksum for this font.
- virtual int64_t checksum();
-
- // Get the number of tables in this font.
- virtual int32_t numTables();
-
- // Whether the font has a particular table.
- virtual bool hasTable(int32_t tag);
-
- // UNIMPLEMENTED: public Iterator<? extends Table> iterator
-
- // Get the table in this font with the specified id.
- // @param tag the identifier of the table
- // @return the table specified if it exists; null otherwise
- virtual Table* table(int32_t tag);
-
- // Get a map of the tables in this font accessed by table tag.
- // @return an unmodifiable view of the tables in this font
- virtual TableMap* tables();
-
- // Serialize the font to the output stream.
- // @param os the destination for the font serialization
- // @param tableOrdering the table ordering to apply
- virtual void serialize(OutputStream* os, IntegerList* table_ordering);
-
- private:
- void buildTableHeadersForSerialization(IntegerList* table_ordering,
- TableHeaderList* table_headers);
- void serializeHeader(FontOutputStream* fos, TableHeaderList* table_headers);
- void serializeTables(FontOutputStream* fos, TableHeaderList* table_headers);
- void tableOrdering(IntegerList* default_table_ordering,
- IntegerList* table_ordering);
- void defaultTableOrdering(IntegerList* default_table_ordering);
-
- public:
- class Builder : public FontDataTableBuilderContainer,
- public RefCounted<Builder> {
- public:
- virtual ~Builder();
-
- private:
- explicit Builder(FontFactory* factory);
- virtual void loadFont(InputStream* is);
- virtual void loadFont(ByteArray* buffer, int32_t offset_to_offset_table);
-
- public:
- static CALLER_ATTACH Builder*
- getOTFBuilder(FontFactory* factory, InputStream* is);
- static CALLER_ATTACH Builder*
- getOTFBuilder(FontFactory* factory, ByteArray* ba,
- int32_t offset_to_offset_table);
- static CALLER_ATTACH Builder* getOTFBuilder(FontFactory* factory);
- virtual bool readyToBuild();
- virtual CALLER_ATTACH Font* build();
- virtual CALLER_ATTACH WritableFontData* getNewData(int32_t capacity);
- virtual CALLER_ATTACH WritableFontData*
- getNewGrowableData(ReadableFontData* data);
- virtual void setDigest(ByteVector* digest);
- virtual void cleanTableBuilders();
- virtual bool hasTableBuilder(int32_t tag);
- virtual Table::Builder* getTableBuilder(int32_t tag);
-
- // Creates a new table builder for the table type given by the table id tag.
- // This new table has been added to the font and will replace any existing
- // builder for that table.
- // @return new empty table of the type specified by tag; if tag is not known
- // then a generic OpenTypeTable is returned
- virtual CALLER_ATTACH Table::Builder* newTableBuilder(int32_t tag);
- virtual CALLER_ATTACH Table::Builder*
- newTableBuilder(int32_t tag, ReadableFontData* src_data);
- virtual TableBuilderMap* tableBuilders();
- virtual void tableBuilderTags(IntegerSet* key_set);
- // Note: different from Java: we don't return object in removeTableBuilder
- virtual void removeTableBuilder(int32_t tag);
- virtual int32_t numberOfTableBuilders();
-
- private:
- int32_t sfntWrapperSize();
- void buildAllTableBuilders(DataBlockMap* table_data,
- TableBuilderMap* builder_map);
- CALLER_ATTACH Table::Builder*
- getTableBuilder(Table::Header* header, WritableFontData* data);
- void buildTablesFromBuilders(TableBuilderMap* builder_map,
- TableMap* tables);
- static void interRelateBuilders(TableBuilderMap* builder_map);
- void readHeader(FontInputStream* is, TableHeaderSortedSet* records);
- void loadTableData(TableHeaderSortedSet* headers, FontInputStream* is,
- DataBlockMap* table_data);
- void readHeader(ReadableFontData* fd, int32_t offset,
- TableHeaderSortedSet* records);
- void loadTableData(TableHeaderSortedSet* headers, WritableFontData* fd,
- DataBlockMap* table_data);
-
- private:
- TableBuilderMap table_builders_;
- FontFactory* factory_; // dumb pointer, avoid circular refcounting
- int32_t sfnt_version_;
- int32_t num_tables_;
- int32_t search_range_;
- int32_t entry_selector_;
- int32_t range_shift_;
- DataBlockMap data_blocks_;
- ByteVector digest_;
- };
-
- public:
- // Get a new data object. The size is a request for a data object and the
- // returned data object will support at least that amount. A value greater
- // than zero for the size is a request for a fixed size data object. A
- // negative or zero value for the size is a request for a variable sized data
- // object with the absolute value of the size being an estimate of the space
- // required.
- // @param size greater than zero is a request for a fixed size data object of
- // the given size; less than or equal to zero is a request for a
- // variable size data object with the absolute size as an estimate
- CALLER_ATTACH WritableFontData* getNewData(int32_t size);
-
- private:
FontFactory* factory_; // dumb pointer, avoid circular ref-counting
int32_t sfnt_version_;
ByteVector digest_;
diff --git a/sfntly/font_data_table.cc b/sfntly/font_data_table.cc
index 9896b24..1f9d1cc 100644
--- a/sfntly/font_data_table.cc
+++ b/sfntly/font_data_table.cc
@@ -15,6 +15,7 @@
*/
#include "sfntly/font_data_table.h"
+
#include "sfntly/data/font_output_stream.h"
namespace sfntly {
@@ -29,158 +30,142 @@
FontDataTable::~FontDataTable() {}
-ReadableFontData* FontDataTable::readFontData() {
+ReadableFontData* FontDataTable::ReadFontData() {
return data_;
}
-int32_t FontDataTable::length() {
- return data_->length();
+int32_t FontDataTable::Length() {
+ return data_->Length();
}
-int32_t FontDataTable::padding() {
+int32_t FontDataTable::Padding() {
return -1;
}
-int32_t FontDataTable::dataLength() {
- int32_t paddings = padding();
- return (paddings == -1) ? length() : length() - paddings;
+int32_t FontDataTable::DataLength() {
+ int32_t paddings = Padding();
+ return (paddings == -1) ? Length() : Length() - paddings;
}
-int32_t FontDataTable::serialize(OutputStream* os) {
- return data_->copyTo(os);
+int32_t FontDataTable::Serialize(OutputStream* os) {
+ return data_->CopyTo(os);
}
/******************************************************************************
* FontDataTable::Builder class
******************************************************************************/
-void FontDataTable::Builder::init(FontDataTableBuilderContainer* container) {
- container_ = container;
- model_changed_ = false;
- data_changed_ = false;
+CALLER_ATTACH WritableFontData* FontDataTable::Builder::Data() {
+ WritableFontDataPtr new_data;
+ if (model_changed_) {
+ if (!SubReadyToSerialize()) {
+ return NULL;
+ }
+ int32_t size = SubDataSizeToSerialize();
+ new_data.Attach(container_->GetNewData(size));
+ SubSerialize(new_data);
+ } else {
+ ReadableFontDataPtr data = InternalReadData();
+ new_data.Attach(container_->GetNewData(data != NULL ? data->Length() : 0));
+ data->CopyTo(new_data);
+ }
+ return new_data.Detach();
+}
+
+void FontDataTable::Builder::SetData(ReadableFontData* data) {
+ InternalSetData(data, true);
+}
+
+
+CALLER_ATTACH FontDataTable* FontDataTable::Builder::Build() {
+ ReadableFontDataPtr data = InternalReadData();
+ if (model_changed_) {
+ // Let subclass serialize from model.
+ if (!SubReadyToSerialize()) {
+ return NULL;
+ }
+ int32_t size = SubDataSizeToSerialize();
+ WritableFontDataPtr new_data;
+ new_data.Attach(container_->GetNewData(size));
+ SubSerialize(new_data);
+ data = new_data;
+ }
+ FontDataTablePtr table = SubBuildTable(data);
+ NotifyPostTableBuild(table);
+ return table;
+}
+
+bool FontDataTable::Builder::ReadyToBuild() {
+ return true;
+}
+
+ReadableFontData* FontDataTable::Builder::InternalReadData() {
+ return (r_data_ != NULL) ? r_data_.p_ :
+ static_cast<ReadableFontData*>(w_data_.p_);
+}
+
+WritableFontData* FontDataTable::Builder::InternalWriteData() {
+ if (w_data_ == NULL) {
+ WritableFontDataPtr new_data;
+ new_data.Attach(container_->GetNewData(r_data_->Length()));
+ r_data_->CopyTo(new_data);
+ InternalSetData(new_data, false);
+ }
+ return w_data_.p_;
+}
+
+CALLER_ATTACH WritableFontData*
+ FontDataTable::Builder::InternalNewData(int32_t size) {
+ return container_->GetNewData(size);
}
FontDataTable::Builder::Builder(FontDataTableBuilderContainer* container) {
- init(container);
+ Init(container);
}
FontDataTable::Builder::Builder(FontDataTableBuilderContainer* container,
WritableFontData* data) {
- init(container);
+ Init(container);
w_data_ = data;
}
FontDataTable::Builder::Builder(FontDataTableBuilderContainer* container,
ReadableFontData* data) {
- init(container);
+ Init(container);
r_data_ = data;
}
FontDataTable::Builder::~Builder() {
}
-WritableFontData* FontDataTable::Builder::data() {
- WritableFontDataPtr new_data;
- if (model_changed_) {
- if (!subReadyToSerialize()) {
- return NULL;
- }
- int32_t size = subDataSizeToSerialize();
- new_data.attach(container_->getNewData(size));
- subSerialize(new_data);
- } else {
- ReadableFontDataPtr data = internalReadData();
- new_data.attach(container_->getNewData(data != NULL ? data->length() : 0));
- data->copyTo(new_data);
- }
- return new_data.detach();
+void FontDataTable::Builder::Init(FontDataTableBuilderContainer* container) {
+ container_ = container;
+ model_changed_ = false;
+ data_changed_ = false;
}
-void FontDataTable::Builder::setData(ReadableFontData* data) {
- internalSetData(data, true);
+void FontDataTable::Builder::NotifyPostTableBuild(FontDataTable* table) {
+ // Default: NOP.
+ UNREFERENCED_PARAMETER(table);
}
-void FontDataTable::Builder::internalSetData(WritableFontData* data,
+void FontDataTable::Builder::InternalSetData(WritableFontData* data,
bool data_changed) {
w_data_ = data;
r_data_ = NULL;
if (data_changed) {
data_changed_ = true;
- subDataSet();
+ SubDataSet();
}
}
-void FontDataTable::Builder::internalSetData(ReadableFontData* data,
+void FontDataTable::Builder::InternalSetData(ReadableFontData* data,
bool data_changed) {
w_data_ = NULL;
r_data_ = data;
if (data_changed) {
data_changed_ = true;
- subDataSet();
+ SubDataSet();
}
}
-CALLER_ATTACH FontDataTable* FontDataTable::Builder::build() {
- ReadableFontDataPtr data = internalReadData();
- if (model_changed_) {
- // Let subclass serialize from model.
- if (!subReadyToSerialize()) {
- return NULL;
- }
- int32_t size = subDataSizeToSerialize();
- WritableFontDataPtr new_data;
- new_data.attach(container_->getNewData(size));
- subSerialize(new_data);
- data = new_data;
- }
- FontDataTablePtr table = subBuildTable(data);
- notifyPostTableBuild(table);
- return table;
-}
-
-bool FontDataTable::Builder::readyToBuild() {
- return true;
-}
-
-ReadableFontData* FontDataTable::Builder::internalReadData() {
- return (r_data_ != NULL) ? r_data_.p_ :
- static_cast<ReadableFontData*>(w_data_.p_);
-}
-
-WritableFontData* FontDataTable::Builder::internalWriteData() {
- if (w_data_ == NULL) {
- WritableFontDataPtr new_data;
- new_data.attach(container_->getNewData(r_data_->length()));
- r_data_->copyTo(new_data);
- internalSetData(new_data, false);
- }
- return w_data_.p_;
-}
-
-WritableFontData* FontDataTable::Builder::internalNewData(int32_t size) {
- return container_->getNewData(size);
-}
-
-bool FontDataTable::Builder::dataChanged() {
- return data_changed_;
-}
-
-bool FontDataTable::Builder::modelChanged() {
- return model_changed_;
-}
-
-bool FontDataTable::Builder::setModelChanged() {
- return setModelChanged(true);
-}
-
-bool FontDataTable::Builder::setModelChanged(bool changed) {
- bool old = model_changed_;
- model_changed_ = changed;
- return old;
-}
-
-void FontDataTable::Builder::notifyPostTableBuild(FontDataTable* table) {
- // default: NOP
- UNREFERENCED_PARAMETER(table);
-}
-
} // namespace sfntly
diff --git a/sfntly/font_data_table.h b/sfntly/font_data_table.h
index 28bec15..9b3b467 100644
--- a/sfntly/font_data_table.h
+++ b/sfntly/font_data_table.h
@@ -25,75 +25,58 @@
class FontDataTable : virtual public RefCount {
public:
- explicit FontDataTable(ReadableFontData* data);
- virtual ~FontDataTable();
-
- // Get the readable font data for this table.
- ReadableFontData* readFontData();
-
- // Get the length of the data for this table in bytes. This is the full
- // allocated length of the data and may or may not include any padding.
- virtual int32_t length();
-
- // Get the number of bytes of padding used in the table. The padding bytes are
- // used to align the table length to a 4 byte boundary.
- virtual int32_t padding();
-
- // Return the number of bytes of non-padded data in the table. If the padding
- // is unknown or unknowable then the total number of bytes of data in the
- // tables is returned.
- virtual int32_t dataLength();
-
- virtual int32_t serialize(OutputStream* os);
-
- public:
// Note: original version is abstract Builder<T extends FontDataTable>
// C++ template is not designed that way so plain class is chosen.
class Builder : virtual public RefCount {
- protected:
- explicit Builder(FontDataTableBuilderContainer* container);
- Builder(FontDataTableBuilderContainer* container, WritableFontData* data);
- Builder(FontDataTableBuilderContainer* container, ReadableFontData* data);
- virtual ~Builder();
-
- void init(FontDataTableBuilderContainer* container);
-
public:
// Get a snapshot copy of the internal data of the builder.
// This causes any internal data structures to be serialized to a new data
// object. This data object belongs to the caller and must be properly
// disposed of. No changes are made to the builder and any changes to the
// data directly do not affect the internal state. To do that a subsequent
- // call must be made to {@link #setData(WritableFontData)}.
+ // call must be made to {@link #SetData(WritableFontData)}.
// @return a copy of the internal data of the builder
- WritableFontData* data();
- virtual void setData(ReadableFontData* data);
+ CALLER_ATTACH WritableFontData* Data();
+ virtual void SetData(ReadableFontData* data);
- private:
- void internalSetData(WritableFontData* data, bool data_changed);
- void internalSetData(ReadableFontData* data, bool data_changed);
+ // Note: changed from protected to avoid accessibility error in C++
+ virtual CALLER_ATTACH FontDataTable* Build();
+ virtual bool ReadyToBuild();
- public: // Note: changed from protected to avoid accessibility error in C++
- virtual FontDataTable* build();
- virtual bool readyToBuild();
- virtual ReadableFontData* internalReadData();
- virtual WritableFontData* internalWriteData();
- virtual WritableFontData* internalNewData(int32_t size);
- virtual bool dataChanged();
- virtual bool modelChanged();
- virtual bool setModelChanged();
- virtual bool setModelChanged(bool changed);
+ ReadableFontData* InternalReadData();
+ WritableFontData* InternalWriteData();
+ CALLER_ATTACH WritableFontData* InternalNewData(int32_t size);
- protected: // subclass API
- virtual void notifyPostTableBuild(FontDataTable* table);
- virtual int32_t subSerialize(WritableFontData* new_data) = 0;
- virtual bool subReadyToSerialize() = 0;
- virtual int32_t subDataSizeToSerialize() = 0;
- virtual void subDataSet() = 0;
+ bool data_changed() { return data_changed_; }
+ bool modelChanged() { return model_changed_; }
+ bool set_model_changed() { return set_model_changed(true); }
+ bool set_model_changed(bool changed) {
+ bool old = model_changed_;
+ model_changed_ = changed;
+ return old;
+ }
+
+ protected:
+ explicit Builder(FontDataTableBuilderContainer* container);
+ Builder(FontDataTableBuilderContainer* container, WritableFontData* data);
+ Builder(FontDataTableBuilderContainer* container, ReadableFontData* data);
+ virtual ~Builder();
+
+ void Init(FontDataTableBuilderContainer* container);
+
+ // subclass API
+ virtual void NotifyPostTableBuild(FontDataTable* table);
+ virtual int32_t SubSerialize(WritableFontData* new_data) = 0;
+ virtual bool SubReadyToSerialize() = 0;
+ virtual int32_t SubDataSizeToSerialize() = 0;
+ virtual void SubDataSet() = 0;
virtual CALLER_ATTACH FontDataTable*
- subBuildTable(ReadableFontData* data) = 0;
+ SubBuildTable(ReadableFontData* data) = 0;
private:
+ void InternalSetData(WritableFontData* data, bool data_changed);
+ void InternalSetData(ReadableFontData* data, bool data_changed);
+
FontDataTableBuilderContainer* container_; // avoid circular ref-counting
WritableFontDataPtr w_data_;
ReadableFontDataPtr r_data_;
@@ -101,7 +84,29 @@
bool data_changed_;
};
+ explicit FontDataTable(ReadableFontData* data);
+ virtual ~FontDataTable();
+
+ // Get the readable font data for this table.
+ ReadableFontData* ReadFontData();
+
+ // Get the length of the data for this table in bytes. This is the full
+ // allocated length of the data and may or may not include any padding.
+ virtual int32_t Length();
+
+ // Get the number of bytes of padding used in the table. The padding bytes are
+ // used to align the table length to a 4 byte boundary.
+ virtual int32_t Padding();
+
+ // Return the number of bytes of non-padded data in the table. If the padding
+ // is unknown or unknowable then the total number of bytes of data in the
+ // tables is returned.
+ virtual int32_t DataLength();
+
+ virtual int32_t Serialize(OutputStream* os);
+
protected:
+ // TODO(arthurhsu): style guide violation: protected member, need refactoring
ReadableFontDataPtr data_;
};
typedef Ptr<FontDataTable> FontDataTablePtr;
diff --git a/sfntly/font_data_table_builder_container.h b/sfntly/font_data_table_builder_container.h
index 7866a36..f3ccf61 100644
--- a/sfntly/font_data_table_builder_container.h
+++ b/sfntly/font_data_table_builder_container.h
@@ -23,7 +23,7 @@
class FontDataTableBuilderContainer {
public:
- virtual WritableFontData* getNewData(int32_t size) = 0;
+ virtual WritableFontData* GetNewData(int32_t size) = 0;
// Make gcc -Wnon-virtual-dtor happy.
virtual ~FontDataTableBuilderContainer() {}
};
diff --git a/sfntly/font_factory.cc b/sfntly/font_factory.cc
index b741f0a..d5b2397 100644
--- a/sfntly/font_factory.cc
+++ b/sfntly/font_factory.cc
@@ -14,229 +14,233 @@
* limitations under the License.
*/
+#include "sfntly/font_factory.h"
+
#include <string.h>
-#include "sfntly/font_factory.h"
#include "sfntly/tag.h"
#include "sfntly/data/memory_byte_array.h"
#include "sfntly/data/growable_memory_byte_array.h"
namespace sfntly {
-FontFactory::FontFactory() : fingerprint_(false) {
-}
-
FontFactory::~FontFactory() {
}
-CALLER_ATTACH FontFactory* FontFactory::getInstance() {
+CALLER_ATTACH FontFactory* FontFactory::GetInstance() {
FontFactoryPtr instance = new FontFactory();
- return instance.detach();
+ return instance.Detach();
}
-void FontFactory::fingerprintFont(bool fingerprint) {
+void FontFactory::FingerprintFont(bool fingerprint) {
fingerprint_ = fingerprint;
}
-bool FontFactory::fingerprintFont() {
+bool FontFactory::FingerprintFont() {
return fingerprint_;
}
-void FontFactory::loadFonts(InputStream* is, FontArray* output) {
+void FontFactory::LoadFonts(InputStream* is, FontArray* output) {
assert(output);
PushbackInputStream* pbis = down_cast<PushbackInputStream*>(is);
- if (isCollection(pbis)) {
- loadCollection(pbis, output);
+ if (IsCollection(pbis)) {
+ LoadCollection(pbis, output);
return;
}
- FontPtr font = loadSingleOTF(pbis);
+ FontPtr font = LoadSingleOTF(pbis);
if (font) {
output->push_back(font);
}
}
-void FontFactory::loadFontsForBuilding(InputStream* is,
+void FontFactory::LoadFonts(ByteArray* ba, FontArray* output) {
+ if (IsCollection(ba)) {
+ LoadCollection(ba, output);
+ return;
+ }
+ FontPtr font;
+ font.Attach(LoadSingleOTF(ba));
+ if (font) {
+ output->push_back(font);
+ }
+}
+
+void FontFactory::LoadFontsForBuilding(InputStream* is,
FontBuilderArray* output) {
PushbackInputStream* pbis = down_cast<PushbackInputStream*>(is);
- if (isCollection(pbis)) {
- loadCollectionForBuilding(pbis, output);
+ if (IsCollection(pbis)) {
+ LoadCollectionForBuilding(pbis, output);
return;
}
FontBuilderPtr builder;
- builder.attach(loadSingleOTFForBuilding(pbis));
+ builder.Attach(LoadSingleOTFForBuilding(pbis));
if (builder) {
output->push_back(builder);
}
}
-Font* FontFactory::loadSingleOTF(InputStream* is) {
+void FontFactory::LoadFontsForBuilding(ByteArray* ba,
+ FontBuilderArray* output) {
+ if (IsCollection(ba)) {
+ LoadCollectionForBuilding(ba, output);
+ return;
+ }
FontBuilderPtr builder;
- builder.attach(loadSingleOTFForBuilding(is));
- return builder->build();
+ builder.Attach(LoadSingleOTFForBuilding(ba, 0));
+ if (builder) {
+ output->push_back(builder);
+ }
}
-void FontFactory::loadCollection(InputStream* is, FontArray* output) {
+CALLER_ATTACH WritableFontData* FontFactory::GetNewData(int32_t capacity) {
+ // UNIMPLMENTED: if (capacity > 0) { this.GetNewFixedData(capacity); }
+ // Seems a no-op.
+ return GetNewGrowableData(capacity);
+}
+
+CALLER_ATTACH WritableFontData* FontFactory::GetNewFixedData(int32_t capacity) {
+ ByteArrayPtr buffer;
+ buffer.Attach(GetNewArray(capacity));
+ WritableFontDataPtr new_fixed_data = new WritableFontData(buffer);
+ return new_fixed_data.Detach();
+}
+
+CALLER_ATTACH WritableFontData* FontFactory::GetNewGrowableData(
+ int32_t capacity) {
+ ByteArrayPtr buffer;
+ buffer.Attach(GetNewGrowableArray(capacity));
+ WritableFontDataPtr new_growable_data = new WritableFontData(buffer);
+ return new_growable_data.Detach();
+}
+
+CALLER_ATTACH WritableFontData* FontFactory::GetNewGrowableData(
+ ReadableFontData* src_data) {
+ WritableFontDataPtr data;
+ data.Attach(GetNewGrowableData(src_data->Length()));
+ src_data->CopyTo(data);
+ return data.Detach();
+}
+
+CALLER_ATTACH ByteArray* FontFactory::GetNewArray(int32_t length) {
+ ByteArrayPtr new_fixed_array = new MemoryByteArray(length);
+ return new_fixed_array.Detach();
+}
+
+CALLER_ATTACH ByteArray* FontFactory::GetNewGrowableArray(int32_t length) {
+ UNREFERENCED_PARAMETER(length);
+ ByteArrayPtr new_growable_array = new GrowableMemoryByteArray();
+ return new_growable_array.Detach();
+}
+
+void FontFactory::SerializeFont(Font* font, OutputStream* os) {
+ font->Serialize(os, &table_ordering_);
+}
+
+void FontFactory::SetSerializationTableOrdering(
+ const IntegerList& table_ordering) {
+ table_ordering_ = table_ordering;
+}
+
+CALLER_ATTACH Font::Builder* FontFactory::NewFontBuilder() {
+ return Font::Builder::GetOTFBuilder(this);
+}
+
+CALLER_ATTACH Font* FontFactory::LoadSingleOTF(InputStream* is) {
+ FontBuilderPtr builder;
+ builder.Attach(LoadSingleOTFForBuilding(is));
+ return builder->Build();
+}
+
+CALLER_ATTACH Font* FontFactory::LoadSingleOTF(ByteArray* ba) {
+ FontBuilderPtr builder;
+ builder.Attach(LoadSingleOTFForBuilding(ba, 0));
+ return builder->Build();
+}
+
+void FontFactory::LoadCollection(InputStream* is, FontArray* output) {
FontBuilderArray ba;
- loadCollectionForBuilding(is, &ba);
+ LoadCollectionForBuilding(is, &ba);
output->reserve(ba.size());
for (FontBuilderArray::iterator builder = ba.begin(), builders_end = ba.end();
builder != builders_end; ++builder) {
FontPtr font;
- font.attach((*builder)->build());
+ font.Attach((*builder)->Build());
output->push_back(font);
}
}
-Font::Builder* FontFactory::loadSingleOTFForBuilding(InputStream* is) {
- // UNIMPLEMENTED: SHA-1 hash checking via Java DigestStream
- Font::Builder* builder = Font::Builder::getOTFBuilder(this, is);
- // UNIMPLEMENTED: setDigest
- return builder;
-}
-
-void FontFactory::loadCollectionForBuilding(InputStream* is,
- FontBuilderArray* builders) {
- ByteArrayPtr ba = new GrowableMemoryByteArray();
- ba->copyFrom(is);
- loadCollectionForBuilding(ba, builders);
-}
-
-bool FontFactory::isCollection(PushbackInputStream* pbis) {
- ByteVector tag(4);
- pbis->read(&tag);
- pbis->unread(&tag);
- return Tag::ttcf == generate_tag(tag[0], tag[1], tag[2], tag[3]);
-}
-
-void FontFactory::loadFonts(ByteArray* ba, FontArray* output) {
- if (isCollection(ba)) {
- loadCollection(ba, output);
- return;
- }
- FontPtr font;
- font.attach(loadSingleOTF(ba));
- if (font) {
- output->push_back(font);
- }
-}
-
-void FontFactory::loadFontsForBuilding(ByteArray* ba,
- FontBuilderArray* output) {
- if (isCollection(ba)) {
- loadCollectionForBuilding(ba, output);
- return;
- }
- FontBuilderPtr builder;
- builder.attach(loadSingleOTFForBuilding(ba, 0));
- if (builder) {
- output->push_back(builder);
- }
-}
-
-Font* FontFactory::loadSingleOTF(ByteArray* ba) {
- FontBuilderPtr builder;
- builder.attach(loadSingleOTFForBuilding(ba, 0));
- return builder->build();
-}
-
-void FontFactory::loadCollection(ByteArray* ba, FontArray* output) {
+void FontFactory::LoadCollection(ByteArray* ba, FontArray* output) {
FontBuilderArray builders;
- loadCollectionForBuilding(ba, &builders);
- output->reserve(ba->size());
+ LoadCollectionForBuilding(ba, &builders);
+ output->reserve(ba->Size());
for (FontBuilderArray::iterator
- builder = builders.begin(), builders_end = builders.end();
+ builder = builders.begin(), builders_end = builders.end();
builder != builders_end; ++builder) {
FontPtr font;
- font.attach((*builder)->build());
+ font.Attach((*builder)->Build());
output->push_back(font);
}
}
-Font::Builder* FontFactory::loadSingleOTFForBuilding(ByteArray* ba,
- int32_t offset_to_offset_table) {
+CALLER_ATTACH Font::Builder*
+ FontFactory::LoadSingleOTFForBuilding(InputStream* is) {
// UNIMPLEMENTED: SHA-1 hash checking via Java DigestStream
- Font::Builder* builder =
- Font::Builder::getOTFBuilder(this, ba, offset_to_offset_table);
+ Font::Builder* builder = Font::Builder::GetOTFBuilder(this, is);
// UNIMPLEMENTED: setDigest
return builder;
}
-void FontFactory::loadCollectionForBuilding(ByteArray* ba,
+CALLER_ATTACH Font::Builder*
+ FontFactory::LoadSingleOTFForBuilding(ByteArray* ba,
+ int32_t offset_to_offset_table) {
+ // UNIMPLEMENTED: SHA-1 hash checking via Java DigestStream
+ Font::Builder* builder =
+ Font::Builder::GetOTFBuilder(this, ba, offset_to_offset_table);
+ // UNIMPLEMENTED: setDigest
+ return builder;
+}
+
+void FontFactory::LoadCollectionForBuilding(InputStream* is,
+ FontBuilderArray* builders) {
+ ByteArrayPtr ba = new GrowableMemoryByteArray();
+ ba->CopyFrom(is);
+ LoadCollectionForBuilding(ba, builders);
+}
+
+void FontFactory::LoadCollectionForBuilding(ByteArray* ba,
FontBuilderArray* builders) {
ReadableFontDataPtr rfd = new ReadableFontData(ba);
- int32_t ttc_tag = rfd->readULongAsInt(Offset::kTTCTag);
+ int32_t ttc_tag = rfd->ReadULongAsInt(Offset::kTTCTag);
UNREFERENCED_PARAMETER(ttc_tag);
- int32_t version = rfd->readFixed(Offset::kVersion);
+ int32_t version = rfd->ReadFixed(Offset::kVersion);
UNREFERENCED_PARAMETER(version);
- int32_t num_fonts = rfd->readULongAsInt(Offset::kNumFonts);
+ int32_t num_fonts = rfd->ReadULongAsInt(Offset::kNumFonts);
builders->reserve(num_fonts);
int32_t offset_table_offset = Offset::kOffsetTable;
for (int32_t font_number = 0; font_number < num_fonts;
font_number++, offset_table_offset += DataSize::kULONG) {
- int32_t offset = rfd->readULongAsInt(offset_table_offset);
+ int32_t offset = rfd->ReadULongAsInt(offset_table_offset);
FontBuilderPtr builder;
- builder.attach(loadSingleOTFForBuilding(ba, offset));
+ builder.Attach(LoadSingleOTFForBuilding(ba, offset));
builders->push_back(builder);
}
}
-bool FontFactory::isCollection(ByteArray* ba) {
+bool FontFactory::IsCollection(PushbackInputStream* pbis) {
+ ByteVector tag(4);
+ pbis->Read(&tag);
+ pbis->Unread(&tag);
+ return Tag::ttcf == GenerateTag(tag[0], tag[1], tag[2], tag[3]);
+}
+
+bool FontFactory::IsCollection(ByteArray* ba) {
return Tag::ttcf ==
- generate_tag(ba->get(0), ba->get(1), ba->get(2), ba->get(3));
+ GenerateTag(ba->Get(0), ba->Get(1), ba->Get(2), ba->Get(3));
}
-CALLER_ATTACH WritableFontData* FontFactory::getNewData(int32_t capacity) {
- // UNIMPLMENTED: if (capacity > 0) { this.getNewFixedData(capacity); }
- // seems a no-op
- return getNewGrowableData(capacity);
-}
-
-CALLER_ATTACH WritableFontData* FontFactory::getNewFixedData(int32_t capacity) {
- ByteArrayPtr buffer;
- buffer.attach(getNewArray(capacity));
- WritableFontDataPtr new_fixed_data = new WritableFontData(buffer);
- return new_fixed_data.detach();
-}
-
-CALLER_ATTACH WritableFontData* FontFactory::getNewGrowableData(
- int32_t capacity) {
- ByteArrayPtr buffer;
- buffer.attach(getNewGrowableArray(capacity));
- WritableFontDataPtr new_growable_data = new WritableFontData(buffer);
- return new_growable_data.detach();
-}
-
-CALLER_ATTACH WritableFontData* FontFactory::getNewGrowableData(
- ReadableFontData* src_data) {
- WritableFontDataPtr data;
- data.attach(getNewGrowableData(src_data->length()));
- src_data->copyTo(data);
- return data.detach();
-}
-
-CALLER_ATTACH ByteArray* FontFactory::getNewArray(int32_t length) {
- ByteArrayPtr new_fixed_array = new MemoryByteArray(length);
- return new_fixed_array.detach();
-}
-
-CALLER_ATTACH ByteArray* FontFactory::getNewGrowableArray(int32_t length) {
- UNREFERENCED_PARAMETER(length);
- ByteArrayPtr new_growable_array = new GrowableMemoryByteArray();
- return new_growable_array.detach();
-}
-
-void FontFactory::serializeFont(Font* font, OutputStream* os) {
- font->serialize(os, &table_ordering_);
-}
-
-void FontFactory::setSerializationTableOrdering(
- const IntegerList& table_ordering) {
- table_ordering_ = table_ordering;
-}
-
-CALLER_ATTACH Font::Builder* FontFactory::newFontBuilder() {
- return Font::Builder::getOTFBuilder(this);
+FontFactory::FontFactory()
+ : fingerprint_(false) {
}
} // namespace sfntly
diff --git a/sfntly/font_factory.h b/sfntly/font_factory.h
index 907ea66..7be0841 100644
--- a/sfntly/font_factory.h
+++ b/sfntly/font_factory.h
@@ -26,20 +26,92 @@
namespace sfntly {
class FontFactory : public RefCounted<FontFactory> {
+ public:
+ virtual ~FontFactory();
+
+ // Factory method for the construction of a font factory.
+ static CALLER_ATTACH FontFactory* GetInstance();
+
+ // Toggle whether fonts that are loaded are fingerprinted with a SHA-1 hash.
+ // If a font is fingerprinted then a SHA-1 hash is generated at load time and
+ // stored in the font. This is useful for uniquely identifying fonts. By
+ // default this is turned on.
+ // @param fingerprint whether fingerprinting should be turned on or off
+ // TODO(arthurhsu): IMPLEMENT: C++ port currently don't do any SHA-1
+ void FingerprintFont(bool fingerprint);
+ bool FingerprintFont();
+
+ // Load the font(s) from the input stream. The current settings on the factory
+ // are used during the loading process. One or more fonts are returned if the
+ // stream contains valid font data. Some font container formats may have more
+ // than one font and in this case multiple font objects will be returned. If
+ // the data in the stream cannot be parsed or is invalid an array of size zero
+ // will be returned.
+ void LoadFonts(InputStream* is, FontArray* output);
+
+ // ByteArray font loading
+ // Load the font(s) from the byte array. The current settings on the factory
+ // are used during the loading process. One or more fonts are returned if the
+ // stream contains valid font data. Some font container formats may have more
+ // than one font and in this case multiple font objects will be returned. If
+ // the data in the stream cannot be parsed or is invalid an array of size zero
+ // will be returned.
+ void LoadFonts(ByteArray* ba, FontArray* output);
+
+ // Load the font(s) from the input stream into font builders. The current
+ // settings on the factory are used during the loading process. One or more
+ // font builders are returned if the stream contains valid font data. Some
+ // font container formats may have more than one font and in this case
+ // multiple font builder objects will be returned. If the data in the stream
+ // cannot be parsed or is invalid an array of size zero will be returned.
+ void LoadFontsForBuilding(InputStream* is, FontBuilderArray* output);
+
+ // Load the font(s) from the byte array into font builders. The current
+ // settings on the factory are used during the loading process. One or more
+ // font builders are returned if the stream contains valid font data. Some
+ // font container formats may have more than one font and in this case
+ // multiple font builder objects will be returned. If the data in the stream
+ // cannot be parsed or is invalid an array of size zero will be returned.
+ void LoadFontsForBuilding(ByteArray* ba, FontBuilderArray* output);
+
+ CALLER_ATTACH WritableFontData* GetNewData(int32_t capacity);
+ CALLER_ATTACH WritableFontData* GetNewFixedData(int32_t capacity);
+ CALLER_ATTACH WritableFontData* GetNewGrowableData(int32_t capacity);
+ CALLER_ATTACH WritableFontData*
+ GetNewGrowableData(ReadableFontData* src_data);
+ CALLER_ATTACH ByteArray* GetNewArray(int32_t length);
+ CALLER_ATTACH ByteArray* GetNewGrowableArray(int32_t length);
+
+ // Font serialization
+ // Serialize the font to the output stream.
+ // NOTE: in this port we attempted not to implement I/O stream because dealing
+ // with cross-platform I/O stream itself is big enough as a project.
+ // Byte buffer it is.
+ void SerializeFont(Font* font, OutputStream* os);
+
+ // Set the table ordering to be used in serializing a font. The table ordering
+ // is an ordered list of table ids and tables will be serialized in the order
+ // given. Any tables whose id is not listed in the ordering will be placed in
+ // an unspecified order following those listed.
+ void SetSerializationTableOrdering(const IntegerList& table_ordering);
+
+ // Get an empty font builder for creating a new font from scratch.
+ CALLER_ATTACH Font::Builder* NewFontBuilder();
+
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 {
- // Offsets within the main directory
+ // Offsets within the main directory.
kTTCTag = 0,
kVersion = 4,
kNumFonts = 8,
kOffsetTable = 12,
- // TTC Version 2.0 extensions
- // offsets from end of OffsetTable
+ // TTC Version 2.0 extensions.
+ // Offsets from end of OffsetTable.
kulDsigTag = 0,
kulDsigLength = 4,
kulDsigOffset = 8
@@ -48,97 +120,22 @@
FontFactory();
- public: // class is final, no virtual functions unless from parent
- virtual ~FontFactory();
+ CALLER_ATTACH Font* LoadSingleOTF(InputStream* is);
+ CALLER_ATTACH Font* LoadSingleOTF(ByteArray* ba);
- // Factory method for the construction of a font factory.
- static CALLER_ATTACH FontFactory* getInstance();
+ void LoadCollection(InputStream* is, FontArray* output);
+ void LoadCollection(ByteArray* ba, FontArray* output);
- // Toggle whether fonts that are loaded are fingerprinted with a SHA-1 hash.
- // If a font is fingerprinted then a SHA-1 hash is generated at load time and
- // stored in the font. This is useful for uniquely identifying fonts. By
- // default this is turned on.
- // @param fingerprint whether fingerprinting should be turned on or off
- // TODO(arthurhsu): IMPLEMENT: C++ port currently don't do any SHA-1
- void fingerprintFont(bool fingerprint);
- bool fingerprintFont();
-
- // Load the font(s) from the input stream. The current settings on the factory
- // are used during the loading process. One or more fonts are returned if the
- // stream contains valid font data. Some font container formats may have more
- // than one font and in this case multiple font objects will be returned. If
- // the data in the stream cannot be parsed or is invalid an array of size zero
- // will be returned.
- void loadFonts(InputStream* is, FontArray* output);
-
- // Load the font(s) from the input stream into font builders. The current
- // settings on the factory are used during the loading process. One or more
- // font builders are returned if the stream contains valid font data. Some
- // font container formats may have more than one font and in this case
- // multiple font builder objects will be returned. If the data in the stream
- // cannot be parsed or is invalid an array of size zero will be returned.
- void loadFontsForBuilding(InputStream* is, FontBuilderArray* output);
-
- private:
- Font* loadSingleOTF(InputStream* is);
- void loadCollection(InputStream* is, FontArray* output);
- Font::Builder* loadSingleOTFForBuilding(InputStream* is);
- void loadCollectionForBuilding(InputStream* is, FontBuilderArray* builders);
- static bool isCollection(PushbackInputStream* pbis);
-
- public:
- // ByteArray font loading
- // Load the font(s) from the byte array. The current settings on the factory
- // are used during the loading process. One or more fonts are returned if the
- // stream contains valid font data. Some font container formats may have more
- // than one font and in this case multiple font objects will be returned. If
- // the data in the stream cannot be parsed or is invalid an array of size zero
- // will be returned.
- void loadFonts(ByteArray* ba, FontArray* output);
-
- // Load the font(s) from the byte array into font builders. The current
- // settings on the factory are used during the loading process. One or more
- // font builders are returned if the stream contains valid font data. Some
- // font container formats may have more than one font and in this case
- // multiple font builder objects will be returned. If the data in the stream
- // cannot be parsed or is invalid an array of size zero will be returned.
- void loadFontsForBuilding(ByteArray* ba, FontBuilderArray* output);
-
- private:
- CALLER_ATTACH Font* loadSingleOTF(ByteArray* ba);
- void loadCollection(ByteArray* ba, FontArray* output);
+ CALLER_ATTACH Font::Builder* LoadSingleOTFForBuilding(InputStream* is);
CALLER_ATTACH Font::Builder*
- loadSingleOTFForBuilding(ByteArray* ba, int32_t offset_to_offset_table);
- void loadCollectionForBuilding(ByteArray* ba, FontBuilderArray* builders);
- static bool isCollection(ByteArray* ba);
+ LoadSingleOTFForBuilding(ByteArray* ba, int32_t offset_to_offset_table);
- public:
- CALLER_ATTACH WritableFontData* getNewData(int32_t capacity);
- CALLER_ATTACH WritableFontData* getNewFixedData(int32_t capacity);
- CALLER_ATTACH WritableFontData* getNewGrowableData(int32_t capacity);
- CALLER_ATTACH WritableFontData*
- getNewGrowableData(ReadableFontData* src_data);
- CALLER_ATTACH ByteArray* getNewArray(int32_t length);
- CALLER_ATTACH ByteArray* getNewGrowableArray(int32_t length);
+ void LoadCollectionForBuilding(InputStream* is, FontBuilderArray* builders);
+ void LoadCollectionForBuilding(ByteArray* ba, FontBuilderArray* builders);
- public:
- // Font serialization
- // Serialize the font to the output stream.
- // NOTE: in this port we attempted not to implement I/O stream because dealing
- // with cross-platform I/O stream itself is big enough as a project.
- // Byte buffer it is.
- void serializeFont(Font* font, OutputStream* os);
+ static bool IsCollection(PushbackInputStream* pbis);
+ static bool IsCollection(ByteArray* ba);
- // Set the table ordering to be used in serializing a font. The table ordering
- // is an ordered list of table ids and tables will be serialized in the order
- // given. Any tables whose id is not listed in the ordering will be placed in
- // an unspecified order following those listed.
- void setSerializationTableOrdering(const IntegerList& table_ordering);
-
- // Get an empty font builder for creating a new font from scratch.
- CALLER_ATTACH Font::Builder* newFontBuilder();
-
- private:
bool fingerprint_;
IntegerList table_ordering_;
};
diff --git a/sfntly/font_header_table.cc b/sfntly/font_header_table.cc
index 7710c5a..f896001 100644
--- a/sfntly/font_header_table.cc
+++ b/sfntly/font_header_table.cc
@@ -20,83 +20,83 @@
/******************************************************************************
* FontHeaderTable class
******************************************************************************/
+FontHeaderTable::~FontHeaderTable() {}
+
+int32_t FontHeaderTable::TableVersion() {
+ return data_->ReadFixed(Offset::kTableVersion);
+}
+
+int32_t FontHeaderTable::FontRevision() {
+ return data_->ReadFixed(Offset::kFontRevision);
+}
+
+int64_t FontHeaderTable::ChecksumAdjustment() {
+ return data_->ReadULong(Offset::kCheckSumAdjustment);
+}
+
+int64_t FontHeaderTable::MagicNumber() {
+ return data_->ReadULong(Offset::kMagicNumber);
+}
+
+int32_t FontHeaderTable::FlagsAsInt() {
+ return data_->ReadUShort(Offset::kFlags);
+}
+
+int32_t FontHeaderTable::UnitsPerEm() {
+ return data_->ReadUShort(Offset::kUnitsPerEm);
+}
+
+int64_t FontHeaderTable::Created() {
+ return data_->ReadDateTimeAsLong(Offset::kCreated);
+}
+
+int64_t FontHeaderTable::Modified() {
+ return data_->ReadDateTimeAsLong(Offset::kModified);
+}
+
+int32_t FontHeaderTable::XMin() {
+ return data_->ReadUShort(Offset::kXMin);
+}
+
+int32_t FontHeaderTable::YMin() {
+ return data_->ReadUShort(Offset::kYMin);
+}
+
+int32_t FontHeaderTable::XMax() {
+ return data_->ReadUShort(Offset::kXMax);
+}
+
+int32_t FontHeaderTable::YMax() {
+ return data_->ReadUShort(Offset::kYMax);
+}
+
+int32_t FontHeaderTable::MacStyleAsInt() {
+ return data_->ReadUShort(Offset::kMacStyle);
+}
+
+int32_t FontHeaderTable::LowestRecPPEM() {
+ return data_->ReadUShort(Offset::kLowestRecPPEM);
+}
+
+int32_t FontHeaderTable::FontDirectionHint() {
+ return data_->ReadShort(Offset::kFontDirectionHint);
+}
+
+int32_t FontHeaderTable::IndexToLocFormat() {
+ return data_->ReadShort(Offset::kIndexToLocFormat);
+}
+
+int32_t FontHeaderTable::GlyphDataFormat() {
+ return data_->ReadShort(Offset::kGlyphDataFormat);
+}
+
FontHeaderTable::FontHeaderTable(Header* header, ReadableFontData* data)
: Table(header, data) {
IntegerList checksum_ranges;
checksum_ranges.push_back(0);
checksum_ranges.push_back(Offset::kCheckSumAdjustment);
checksum_ranges.push_back(Offset::kMagicNumber);
- data_->setCheckSumRanges(checksum_ranges);
-}
-
-FontHeaderTable::~FontHeaderTable() {}
-
-int32_t FontHeaderTable::tableVersion() {
- return data_->readFixed(Offset::kTableVersion);
-}
-
-int32_t FontHeaderTable::fontRevision() {
- return data_->readFixed(Offset::kFontRevision);
-}
-
-int64_t FontHeaderTable::checksumAdjustment() {
- return data_->readULong(Offset::kCheckSumAdjustment);
-}
-
-int64_t FontHeaderTable::magicNumber() {
- return data_->readULong(Offset::kMagicNumber);
-}
-
-int32_t FontHeaderTable::flagsAsInt() {
- return data_->readUShort(Offset::kFlags);
-}
-
-int32_t FontHeaderTable::unitsPerEm() {
- return data_->readUShort(Offset::kUnitsPerEm);
-}
-
-int64_t FontHeaderTable::created() {
- return data_->readDateTimeAsLong(Offset::kCreated);
-}
-
-int64_t FontHeaderTable::modified() {
- return data_->readDateTimeAsLong(Offset::kModified);
-}
-
-int32_t FontHeaderTable::xMin() {
- return data_->readUShort(Offset::kXMin);
-}
-
-int32_t FontHeaderTable::yMin() {
- return data_->readUShort(Offset::kYMin);
-}
-
-int32_t FontHeaderTable::xMax() {
- return data_->readUShort(Offset::kXMax);
-}
-
-int32_t FontHeaderTable::yMax() {
- return data_->readUShort(Offset::kYMax);
-}
-
-int32_t FontHeaderTable::macStyleAsInt() {
- return data_->readUShort(Offset::kMacStyle);
-}
-
-int32_t FontHeaderTable::lowestRecPPEM() {
- return data_->readUShort(Offset::kLowestRecPPEM);
-}
-
-int32_t FontHeaderTable::fontDirectionHint() {
- return data_->readShort(Offset::kFontDirectionHint);
-}
-
-int32_t FontHeaderTable::indexToLocFormat() {
- return data_->readShort(Offset::kIndexToLocFormat);
-}
-
-int32_t FontHeaderTable::glyphDataFormat() {
- return data_->readShort(Offset::kGlyphDataFormat);
+ data_->SetCheckSumRanges(checksum_ranges);
}
/******************************************************************************
@@ -114,146 +114,146 @@
FontHeaderTable::Builder::~Builder() {}
-CALLER_ATTACH FontDataTable* FontHeaderTable::Builder::subBuildTable(
+CALLER_ATTACH FontDataTable* FontHeaderTable::Builder::SubBuildTable(
ReadableFontData* data) {
FontDataTablePtr table = new FontHeaderTable(header(), data);
- return table.detach();
+ return table.Detach();
}
-int32_t FontHeaderTable::Builder::tableVersion() {
- return down_cast<FontHeaderTable*>(table())->tableVersion();
+int32_t FontHeaderTable::Builder::TableVersion() {
+ return down_cast<FontHeaderTable*>(GetTable())->TableVersion();
}
-void FontHeaderTable::Builder::setTableVersion(int32_t version) {
- internalWriteData()->writeFixed(Offset::kTableVersion, version);
+void FontHeaderTable::Builder::SetTableVersion(int32_t version) {
+ InternalWriteData()->WriteFixed(Offset::kTableVersion, version);
}
-int32_t FontHeaderTable::Builder::fontRevision() {
- return down_cast<FontHeaderTable*>(table())->fontRevision();
+int32_t FontHeaderTable::Builder::FontRevision() {
+ return down_cast<FontHeaderTable*>(GetTable())->FontRevision();
}
-void FontHeaderTable::Builder::setFontRevision(int32_t revision) {
- internalWriteData()->writeFixed(Offset::kFontRevision, revision);
+void FontHeaderTable::Builder::SetFontRevision(int32_t revision) {
+ InternalWriteData()->WriteFixed(Offset::kFontRevision, revision);
}
-int64_t FontHeaderTable::Builder::checksumAdjustment() {
- return down_cast<FontHeaderTable*>(table())->checksumAdjustment();
+int64_t FontHeaderTable::Builder::ChecksumAdjustment() {
+ return down_cast<FontHeaderTable*>(GetTable())->ChecksumAdjustment();
}
-void FontHeaderTable::Builder::setChecksumAdjustment(int64_t adjustment) {
- internalWriteData()->writeULong(Offset::kCheckSumAdjustment, adjustment);
+void FontHeaderTable::Builder::SetChecksumAdjustment(int64_t adjustment) {
+ InternalWriteData()->WriteULong(Offset::kCheckSumAdjustment, adjustment);
}
-int64_t FontHeaderTable::Builder::magicNumber() {
- return down_cast<FontHeaderTable*>(table())->magicNumber();
+int64_t FontHeaderTable::Builder::MagicNumber() {
+ return down_cast<FontHeaderTable*>(GetTable())->MagicNumber();
}
-void FontHeaderTable::Builder::setMagicNumber(int64_t magic_number) {
- internalWriteData()->writeULong(Offset::kMagicNumber, magic_number);
+void FontHeaderTable::Builder::SetMagicNumber(int64_t magic_number) {
+ InternalWriteData()->WriteULong(Offset::kMagicNumber, magic_number);
}
-int32_t FontHeaderTable::Builder::flagsAsInt() {
- return down_cast<FontHeaderTable*>(table())->flagsAsInt();
+int32_t FontHeaderTable::Builder::FlagsAsInt() {
+ return down_cast<FontHeaderTable*>(GetTable())->FlagsAsInt();
}
-void FontHeaderTable::Builder::setFlagsAsInt(int32_t flags) {
- internalWriteData()->writeUShort(Offset::kFlags, flags);
+void FontHeaderTable::Builder::SetFlagsAsInt(int32_t flags) {
+ InternalWriteData()->WriteUShort(Offset::kFlags, flags);
}
-int32_t FontHeaderTable::Builder::unitsPerEm() {
- return down_cast<FontHeaderTable*>(table())->unitsPerEm();
+int32_t FontHeaderTable::Builder::UnitsPerEm() {
+ return down_cast<FontHeaderTable*>(GetTable())->UnitsPerEm();
}
-void FontHeaderTable::Builder::setUnitsPerEm(int32_t units) {
- internalWriteData()->writeUShort(Offset::kUnitsPerEm, units);
+void FontHeaderTable::Builder::SetUnitsPerEm(int32_t units) {
+ InternalWriteData()->WriteUShort(Offset::kUnitsPerEm, units);
}
-int64_t FontHeaderTable::Builder::created() {
- return down_cast<FontHeaderTable*>(table())->modified();
+int64_t FontHeaderTable::Builder::Created() {
+ return down_cast<FontHeaderTable*>(GetTable())->Created();
}
-void FontHeaderTable::Builder::setCreated(int64_t date) {
- internalWriteData()->writeDateTime(Offset::kCreated, date);
+void FontHeaderTable::Builder::SetCreated(int64_t date) {
+ InternalWriteData()->WriteDateTime(Offset::kCreated, date);
}
-int64_t FontHeaderTable::Builder::modified() {
- return down_cast<FontHeaderTable*>(table())->modified();
+int64_t FontHeaderTable::Builder::Modified() {
+ return down_cast<FontHeaderTable*>(GetTable())->Modified();
}
-void FontHeaderTable::Builder::setModified(int64_t date) {
- internalWriteData()->writeDateTime(Offset::kModified, date);
+void FontHeaderTable::Builder::SetModified(int64_t date) {
+ InternalWriteData()->WriteDateTime(Offset::kModified, date);
}
-int32_t FontHeaderTable::Builder::xMin() {
- return down_cast<FontHeaderTable*>(table())->xMin();
+int32_t FontHeaderTable::Builder::XMin() {
+ return down_cast<FontHeaderTable*>(GetTable())->XMin();
}
-void FontHeaderTable::Builder::setXMin(int32_t xmin) {
- internalWriteData()->writeShort(Offset::kXMin, xmin);
+void FontHeaderTable::Builder::SetXMin(int32_t xmin) {
+ InternalWriteData()->WriteShort(Offset::kXMin, xmin);
}
-int32_t FontHeaderTable::Builder::yMin() {
- return down_cast<FontHeaderTable*>(table())->yMin();
+int32_t FontHeaderTable::Builder::YMin() {
+ return down_cast<FontHeaderTable*>(GetTable())->YMin();
}
-void FontHeaderTable::Builder::setYMin(int32_t ymin) {
- internalWriteData()->writeShort(Offset::kYMin, ymin);
+void FontHeaderTable::Builder::SetYMin(int32_t ymin) {
+ InternalWriteData()->WriteShort(Offset::kYMin, ymin);
}
-int32_t FontHeaderTable::Builder::xMax() {
- return down_cast<FontHeaderTable*>(table())->xMax();
+int32_t FontHeaderTable::Builder::XMax() {
+ return down_cast<FontHeaderTable*>(GetTable())->XMax();
}
-void FontHeaderTable::Builder::setXMax(int32_t xmax) {
- internalWriteData()->writeShort(Offset::kXMax, xmax);
+void FontHeaderTable::Builder::SetXMax(int32_t xmax) {
+ InternalWriteData()->WriteShort(Offset::kXMax, xmax);
}
-int32_t FontHeaderTable::Builder::yMax() {
- return down_cast<FontHeaderTable*>(table())->yMax();
+int32_t FontHeaderTable::Builder::YMax() {
+ return down_cast<FontHeaderTable*>(GetTable())->YMax();
}
-void FontHeaderTable::Builder::setYMax(int32_t ymax) {
- internalWriteData()->writeShort(Offset::kYMax, ymax);
+void FontHeaderTable::Builder::SetYMax(int32_t ymax) {
+ InternalWriteData()->WriteShort(Offset::kYMax, ymax);
}
-int32_t FontHeaderTable::Builder::macStyleAsInt() {
- return down_cast<FontHeaderTable*>(table())->macStyleAsInt();
+int32_t FontHeaderTable::Builder::MacStyleAsInt() {
+ return down_cast<FontHeaderTable*>(GetTable())->MacStyleAsInt();
}
-void FontHeaderTable::Builder::setMacStyleAsInt(int32_t style) {
- internalWriteData()->writeUShort(Offset::kMacStyle, style);
+void FontHeaderTable::Builder::SetMacStyleAsInt(int32_t style) {
+ InternalWriteData()->WriteUShort(Offset::kMacStyle, style);
}
-int32_t FontHeaderTable::Builder::lowestRecPPEM() {
- return down_cast<FontHeaderTable*>(table())->lowestRecPPEM();
+int32_t FontHeaderTable::Builder::LowestRecPPEM() {
+ return down_cast<FontHeaderTable*>(GetTable())->LowestRecPPEM();
}
-void FontHeaderTable::Builder::setLowestRecPPEM(int32_t size) {
- internalWriteData()->writeUShort(Offset::kLowestRecPPEM, size);
+void FontHeaderTable::Builder::SetLowestRecPPEM(int32_t size) {
+ InternalWriteData()->WriteUShort(Offset::kLowestRecPPEM, size);
}
-int32_t FontHeaderTable::Builder::fontDirectionHint() {
- return down_cast<FontHeaderTable*>(table())->fontDirectionHint();
+int32_t FontHeaderTable::Builder::FontDirectionHint() {
+ return down_cast<FontHeaderTable*>(GetTable())->FontDirectionHint();
}
-void FontHeaderTable::Builder::setFontDirectionHint(int32_t hint) {
- internalWriteData()->writeShort(Offset::kFontDirectionHint, hint);
+void FontHeaderTable::Builder::SetFontDirectionHint(int32_t hint) {
+ InternalWriteData()->WriteShort(Offset::kFontDirectionHint, hint);
}
-int32_t FontHeaderTable::Builder::indexToLocFormat() {
- return down_cast<FontHeaderTable*>(table())->indexToLocFormat();
+int32_t FontHeaderTable::Builder::IndexToLocFormat() {
+ return down_cast<FontHeaderTable*>(GetTable())->IndexToLocFormat();
}
-void FontHeaderTable::Builder::setIndexToLocFormat(int32_t format) {
- internalWriteData()->writeShort(Offset::kIndexToLocFormat, format);
+void FontHeaderTable::Builder::SetIndexToLocFormat(int32_t format) {
+ InternalWriteData()->WriteShort(Offset::kIndexToLocFormat, format);
}
-int32_t FontHeaderTable::Builder::glyphDataFormat() {
- return down_cast<FontHeaderTable*>(table())->glyphDataFormat();
+int32_t FontHeaderTable::Builder::GlyphDataFormat() {
+ return down_cast<FontHeaderTable*>(GetTable())->GlyphDataFormat();
}
-void FontHeaderTable::Builder::setGlyphDataFormat(int32_t format) {
- internalWriteData()->writeShort(Offset::kGlyphDataFormat, format);
+void FontHeaderTable::Builder::SetGlyphDataFormat(int32_t format) {
+ InternalWriteData()->WriteShort(Offset::kGlyphDataFormat, format);
}
} // namespace sfntly
diff --git a/sfntly/font_header_table.h b/sfntly/font_header_table.h
index c8aa9fe..dd6f593 100644
--- a/sfntly/font_header_table.h
+++ b/sfntly/font_header_table.h
@@ -39,6 +39,101 @@
};
class FontHeaderTable : public Table, public RefCounted<FontHeaderTable> {
+ public:
+ class Builder : public Table::TableBasedTableBuilder,
+ public RefCounted<Builder> {
+ public:
+ // Constructor scope altered to public because C++ does not allow base
+ // class to instantiate derived class with protected constructors.
+ Builder(FontDataTableBuilderContainer* font_builder, Header* header,
+ WritableFontData* data);
+ Builder(FontDataTableBuilderContainer* font_builder, Header* header,
+ ReadableFontData* data);
+ virtual ~Builder();
+ virtual CALLER_ATTACH FontDataTable* SubBuildTable(ReadableFontData* data);
+
+ virtual int32_t TableVersion();
+ virtual void SetTableVersion(int32_t version);
+ virtual int32_t FontRevision();
+ virtual void SetFontRevision(int32_t revision);
+ virtual int64_t ChecksumAdjustment();
+ virtual void SetChecksumAdjustment(int64_t adjustment);
+ virtual int64_t MagicNumber();
+ virtual void SetMagicNumber(int64_t magic_number);
+ virtual int32_t FlagsAsInt();
+ virtual void SetFlagsAsInt(int32_t flags);
+ // TODO(arthurhsu): IMPLEMENT EnumSet<Flags> Flags()
+ // TODO(arthurhsu): IMPLEMENT setFlags(EnumSet<Flags> flags)
+ virtual int32_t UnitsPerEm();
+ virtual void SetUnitsPerEm(int32_t units);
+ virtual int64_t Created();
+ virtual void SetCreated(int64_t date);
+ virtual int64_t Modified();
+ virtual void SetModified(int64_t date);
+ virtual int32_t XMin();
+ virtual void SetXMin(int32_t xmin);
+ virtual int32_t YMin();
+ virtual void SetYMin(int32_t ymin);
+ virtual int32_t XMax();
+ virtual void SetXMax(int32_t xmax);
+ virtual int32_t YMax();
+ virtual void SetYMax(int32_t ymax);
+ virtual int32_t MacStyleAsInt();
+ virtual void SetMacStyleAsInt(int32_t style);
+ // TODO(arthurhsu): IMPLEMENT EnumSet<MacStyle> macStyle()
+ // TODO(arthurhsu): IMPLEMENT setMacStyle(EnumSet<MacStyle> style)
+ virtual int32_t LowestRecPPEM();
+ virtual void SetLowestRecPPEM(int32_t size);
+ virtual int32_t FontDirectionHint();
+ virtual void SetFontDirectionHint(int32_t hint);
+ virtual int32_t IndexToLocFormat();
+ virtual void SetIndexToLocFormat(int32_t format);
+ virtual int32_t GlyphDataFormat();
+ virtual void SetGlyphDataFormat(int32_t format);
+ };
+
+ virtual ~FontHeaderTable();
+ int32_t TableVersion();
+ int32_t FontRevision();
+
+ // Get the checksum adjustment. To compute: set it to 0, sum the entire font
+ // as ULONG, then store 0xB1B0AFBA - sum.
+ int64_t ChecksumAdjustment();
+
+ // Get the magic number. Set to 0x5F0F3CF5.
+ int64_t MagicNumber();
+
+ // TODO(arthurhsu): IMPLEMENT: EnumSet<Flags>
+ int32_t FlagsAsInt();
+ // TODO(arthurhsu): IMPLEMENT: Flags() returning EnumSet<Flags>
+
+ int32_t UnitsPerEm();
+
+ // Get the created date. Number of seconds since 12:00 midnight, January 1,
+ // 1904. 64-bit integer.
+ int64_t Created();
+ // Get the modified date. Number of seconds since 12:00 midnight, January 1,
+ // 1904. 64-bit integer.
+ int64_t Modified();
+
+ // Get the x min. For all glyph bounding boxes.
+ int32_t XMin();
+ // Get the y min. For all glyph bounding boxes.
+ int32_t YMin();
+ // Get the x max. For all glyph bounding boxes.
+ int32_t XMax();
+ // Get the y max. For all glyph bounding boxes.
+ int32_t YMax();
+
+ // TODO(arthurhsu): IMPLEMENT: EnumSet<MacStyle>
+ int32_t MacStyleAsInt();
+ // TODO(arthurhsu): IMPLEMENT: macStyle() returning EnumSet<MacStyle>
+
+ int32_t LowestRecPPEM();
+ int32_t FontDirectionHint(); // Note: no AsInt() form, already int
+ int32_t IndexToLocFormat(); // Note: no AsInt() form, already int
+ int32_t GlyphDataFormat();
+
private:
struct Offset {
enum {
@@ -62,104 +157,7 @@
};
};
- private:
FontHeaderTable(Header* header, ReadableFontData* data);
-
- public: // class is final, no virtual functions unless from parent
- virtual ~FontHeaderTable();
- int32_t tableVersion();
- int32_t fontRevision();
-
- // Get the checksum adjustment. To compute: set it to 0, sum the entire font
- // as ULONG, then store 0xB1B0AFBA - sum.
- int64_t checksumAdjustment();
-
- // Get the magic number. Set to 0x5F0F3CF5.
- int64_t magicNumber();
-
- // TODO(arthurhsu): IMPLEMENT: EnumSet<Flags>
- int32_t flagsAsInt();
- // TODO(arthurhsu): IMPLEMENT: flags() returning EnumSet<Flags>
-
- int32_t unitsPerEm();
-
- // Get the created date. Number of seconds since 12:00 midnight, January 1,
- // 1904. 64-bit integer.
- int64_t created();
- // Get the modified date. Number of seconds since 12:00 midnight, January 1,
- // 1904. 64-bit integer.
- int64_t modified();
-
- // Get the x min. For all glyph bounding boxes.
- int32_t xMin();
- // Get the y min. For all glyph bounding boxes.
- int32_t yMin();
- // Get the x max. For all glyph bounding boxes.
- int32_t xMax();
- // Get the y max. For all glyph bounding boxes.
- int32_t yMax();
-
- // TODO(arthurhsu): IMPLEMENT: EnumSet<MacStyle>
- int32_t macStyleAsInt();
- // TODO(arthurhsu): IMPLEMENT: macStyle() returning EnumSet<MacStyle>
-
- int32_t lowestRecPPEM();
- int32_t fontDirectionHint(); // Note: no AsInt() form, already int
- int32_t indexToLocFormat(); // Note: no AsInt() form, already int
- int32_t glyphDataFormat();
-
- public:
- class Builder : public Table::TableBasedTableBuilder,
- public RefCounted<Builder> {
- public:
- // Constructor scope altered to public because C++ does not allow base
- // class to instantiate derived class with protected constructors.
- Builder(FontDataTableBuilderContainer* font_builder, Header* header,
- WritableFontData* data);
- Builder(FontDataTableBuilderContainer* font_builder, Header* header,
- ReadableFontData* data);
- virtual ~Builder();
- virtual CALLER_ATTACH FontDataTable* subBuildTable(ReadableFontData* data);
-
- virtual int32_t tableVersion();
- virtual void setTableVersion(int32_t version);
- virtual int32_t fontRevision();
- virtual void setFontRevision(int32_t revision);
- virtual int64_t checksumAdjustment();
- virtual void setChecksumAdjustment(int64_t adjustment);
- virtual int64_t magicNumber();
- virtual void setMagicNumber(int64_t magic_number);
- virtual int32_t flagsAsInt();
- virtual void setFlagsAsInt(int32_t flags);
- // TODO(arthurhsu): IMPLEMENT EnumSet<Flags> flags()
- // TODO(arthurhsu): IMPLEMENT setFlags(EnumSet<Flags> flags)
- virtual int32_t unitsPerEm();
- virtual void setUnitsPerEm(int32_t units);
- virtual int64_t created();
- virtual void setCreated(int64_t date);
- virtual int64_t modified();
- virtual void setModified(int64_t date);
- virtual int32_t xMin();
- virtual void setXMin(int32_t xmin);
- virtual int32_t yMin();
- virtual void setYMin(int32_t ymin);
- virtual int32_t xMax();
- virtual void setXMax(int32_t xmax);
- virtual int32_t yMax();
- virtual void setYMax(int32_t ymax);
- virtual int32_t macStyleAsInt();
- virtual void setMacStyleAsInt(int32_t style);
- // TODO(arthurhsu): IMPLEMENT EnumSet<MacStyle> macStyle()
- // TODO(arthurhsu): IMPLEMENT setMacStyle(EnumSet<MacStyle> style)
- virtual int32_t lowestRecPPEM();
- virtual void setLowestRecPPEM(int32_t size);
- virtual int32_t fontDirectionHint();
- virtual void setFontDirectionHint(int32_t hint);
- virtual int32_t indexToLocFormat();
- virtual void setIndexToLocFormat(int32_t format);
- virtual int32_t glyphDataFormat();
- virtual void setGlyphDataFormat(int32_t format);
- };
};
typedef Ptr<FontHeaderTable> FontHeaderTablePtr;
typedef Ptr<FontHeaderTable::Builder> FontHeaderTableBuilderPtr;
diff --git a/sfntly/glyph_table.cc b/sfntly/glyph_table.cc
index 3ff6d97..99e7c06 100644
--- a/sfntly/glyph_table.cc
+++ b/sfntly/glyph_table.cc
@@ -14,9 +14,10 @@
* limitations under the License.
*/
+#include "sfntly/glyph_table.h"
+
#include <stdlib.h>
-#include "sfntly/glyph_table.h"
#include "sfntly/port/exception_type.h"
namespace sfntly {
@@ -47,33 +48,38 @@
/******************************************************************************
* GlyphTable class
******************************************************************************/
+GlyphTable::~GlyphTable() {
+}
+
+GlyphTable::Glyph* GlyphTable::GetGlyph(int32_t offset, int32_t length) {
+ return GlyphTable::Glyph::GetGlyph(data_, offset, length);
+}
+
GlyphTable::GlyphTable(Header* header, ReadableFontData* data)
- : Table(header, data) {}
-
-GlyphTable::~GlyphTable() {}
-
-GlyphTable::Glyph* GlyphTable::glyph(int32_t offset, int32_t length) {
- return GlyphTable::Glyph::getGlyph(data_, offset, length);
+ : Table(header, data) {
}
/******************************************************************************
* GlyphTable::Builder class
******************************************************************************/
GlyphTable::Builder::Builder(FontDataTableBuilderContainer* font_builder,
- Header* header, WritableFontData* data) :
- Table::ArrayElementTableBuilder(font_builder, header, data) {}
+ Header* header,
+ WritableFontData* data)
+ : Table::ArrayElementTableBuilder(font_builder, header, data) {
+}
-GlyphTable::Builder::~Builder() {}
+GlyphTable::Builder::~Builder() {
+}
-void GlyphTable::Builder::setLoca(const IntegerList& loca) {
+void GlyphTable::Builder::SetLoca(const IntegerList& loca) {
loca_ = loca;
- setModelChanged(false);
+ set_model_changed(false);
glyph_builders_.clear();
}
-void GlyphTable::Builder::generateLocaList(IntegerList* locas) {
+void GlyphTable::Builder::GenerateLocaList(IntegerList* locas) {
assert(locas);
- GlyphBuilderList* glyph_builders = getGlyphBuilders();
+ GlyphBuilderList* glyph_builders = GetGlyphBuilders();
locas->resize(glyph_builders->size());
locas->push_back(0);
if (glyph_builders->size() == 0) {
@@ -83,14 +89,71 @@
for (GlyphBuilderList::iterator b = glyph_builders->begin(),
b_end = glyph_builders->end();
b != b_end; ++b) {
- int32_t size = (*b)->subDataSizeToSerialize();
+ int32_t size = (*b)->SubDataSizeToSerialize();
locas->push_back(total + size);
total += size;
}
}
}
-void GlyphTable::Builder::initialize(ReadableFontData* data,
+GlyphTable::GlyphBuilderList* GlyphTable::Builder::GlyphBuilders() {
+ return GetGlyphBuilders();
+}
+
+void GlyphTable::Builder::SetGlyphBuilders(GlyphBuilderList* glyph_builders) {
+ glyph_builders_ = *glyph_builders;
+ set_model_changed();
+}
+
+CALLER_ATTACH GlyphTable::Glyph::Builder*
+ GlyphTable::Builder::GlyphBuilder(ReadableFontData* data) {
+ return Glyph::Builder::GetBuilder(this, data);
+}
+
+CALLER_ATTACH FontDataTable*
+ GlyphTable::Builder::SubBuildTable(ReadableFontData* data) {
+ FontDataTablePtr table = new GlyphTable(header(), data);
+ return table.Detach();
+}
+
+void GlyphTable::Builder::SubDataSet() {
+ glyph_builders_.clear();
+ set_model_changed(false);
+}
+
+int32_t GlyphTable::Builder::SubDataSizeToSerialize() {
+ if (glyph_builders_.empty())
+ return 0;
+
+ bool variable = false;
+ int32_t size = 0;
+
+ // Calculate size of each table.
+ for (GlyphBuilderList::iterator b = glyph_builders_.begin(),
+ end = glyph_builders_.end(); b != end; ++b) {
+ int32_t glyph_size = (*b)->SubDataSizeToSerialize();
+ size += abs(glyph_size);
+ variable |= glyph_size <= 0;
+ }
+ return variable ? -size : size;
+}
+
+bool GlyphTable::Builder::SubReadyToSerialize() {
+ return !glyph_builders_.empty();
+}
+
+int32_t GlyphTable::Builder::SubSerialize(WritableFontData* new_data) {
+ int32_t size = 0;
+ for (GlyphBuilderList::iterator b = glyph_builders_.begin(),
+ end = glyph_builders_.end(); b != end; ++b) {
+ FontDataPtr data;
+ data.Attach(new_data->Slice(size));
+ size += (*b)->SubSerialize(down_cast<WritableFontData*>(data.p_));
+ }
+ return size;
+}
+
+void GlyphTable::Builder::Initialize(ReadableFontData* data,
const IntegerList& loca) {
if (data != NULL) {
if (loca_.empty()) {
@@ -106,222 +169,211 @@
for (size_t i = 1; i < loca.size(); ++i) {
loca_value = loca[i];
GlyphBuilderPtr builder;
- builder.attach(Glyph::Builder::getBuilder(this, data,
- last_loca_value /*offset*/, loca_value - last_loca_value /*length*/));
+ builder.Attach(
+ Glyph::Builder::GetBuilder(this,
+ data,
+ last_loca_value /*offset*/,
+ loca_value - last_loca_value /*length*/));
glyph_builders_.push_back(builder);
last_loca_value = loca_value;
}
}
}
-GlyphTable::GlyphBuilderList* GlyphTable::Builder::getGlyphBuilders() {
+GlyphTable::GlyphBuilderList* GlyphTable::Builder::GetGlyphBuilders() {
if (glyph_builders_.empty()) {
- initialize(internalReadData(), loca_);
- setModelChanged();
+ Initialize(InternalReadData(), loca_);
+ set_model_changed();
}
return &glyph_builders_;
}
-void GlyphTable::Builder::revert() {
+void GlyphTable::Builder::Revert() {
glyph_builders_.clear();
- setModelChanged(false);
-}
-
-GlyphTable::GlyphBuilderList* GlyphTable::Builder::glyphBuilders() {
- return getGlyphBuilders();
-}
-
-void GlyphTable::Builder::setGlyphBuilders(GlyphBuilderList* glyph_builders) {
- glyph_builders_ = *glyph_builders;
- setModelChanged();
-}
-
-CALLER_ATTACH GlyphTable::Glyph::Builder* GlyphTable::Builder::glyphBuilder(
- ReadableFontData* data) {
- return Glyph::Builder::getBuilder(this, data);
-}
-
-CALLER_ATTACH FontDataTable* GlyphTable::Builder::subBuildTable(
- ReadableFontData* data) {
- FontDataTablePtr table = new GlyphTable(header(), data);
- return table.detach();
-}
-
-void GlyphTable::Builder::subDataSet() {
- glyph_builders_.clear();
- setModelChanged(false);
-}
-
-int32_t GlyphTable::Builder::subDataSizeToSerialize() {
- if (glyph_builders_.empty())
- return 0;
-
- bool variable = false;
- int32_t size = 0;
-
- // Calculate size of each table.
- for (GlyphBuilderList::iterator b = glyph_builders_.begin(),
- end = glyph_builders_.end(); b != end; ++b) {
- int32_t glyph_size = (*b)->subDataSizeToSerialize();
- size += abs(glyph_size);
- variable |= glyph_size <= 0;
- }
- return variable ? -size : size;
-}
-
-bool GlyphTable::Builder::subReadyToSerialize() {
- return !glyph_builders_.empty();
-}
-
-int32_t GlyphTable::Builder::subSerialize(WritableFontData* new_data) {
- int32_t size = 0;
- for (GlyphBuilderList::iterator b = glyph_builders_.begin(),
- end = glyph_builders_.end(); b != end; ++b) {
- FontDataPtr data;
- data.attach(new_data->slice(size));
- size += (*b)->subSerialize(down_cast<WritableFontData*>(data.p_));
- }
- return size;
+ set_model_changed(false);
}
/******************************************************************************
* GlyphTable::Glyph class
******************************************************************************/
+GlyphTable::Glyph::~Glyph() {}
+
+CALLER_ATTACH GlyphTable::Glyph*
+ GlyphTable::Glyph::GetGlyph(ReadableFontData* data,
+ int32_t offset,
+ int32_t length) {
+ int32_t type = GlyphType(data, offset, length);
+ GlyphPtr glyph;
+
+ ReadableFontDataPtr sliced_data;
+ sliced_data.Attach(down_cast<ReadableFontData*>(data->Slice(offset, length)));
+ if (type == GlyphType::kSimple) {
+ glyph = new SimpleGlyph(sliced_data);
+ }
+ glyph = new CompositeGlyph(sliced_data);
+ return glyph.Detach();
+}
+
+int32_t GlyphTable::Glyph::GlyphType() {
+ return glyph_type_;
+}
+
+int32_t GlyphTable::Glyph::NumberOfContours() {
+ return number_of_contours_;
+}
+
+int32_t GlyphTable::Glyph::XMin() {
+ return data_->ReadShort(Offset::kXMin);
+}
+
+int32_t GlyphTable::Glyph::XMax() {
+ return data_->ReadShort(Offset::kXMax);
+}
+
+int32_t GlyphTable::Glyph::YMin() {
+ return data_->ReadShort(Offset::kYMin);
+}
+
+int32_t GlyphTable::Glyph::YMax() {
+ return data_->ReadShort(Offset::kYMax);
+}
+
+int32_t GlyphTable::Glyph::Padding() {
+ return padding_;
+}
+
GlyphTable::Glyph::Glyph(ReadableFontData* data, int32_t glyph_type)
- : SubTable(data), glyph_type_(glyph_type) {
- if (data_->length() == 0) {
+ : SubTable(data),
+ glyph_type_(glyph_type) {
+ if (data_->Length() == 0) {
number_of_contours_ = 0;
} else {
// -1 if composite
- number_of_contours_ = data_->readShort(Offset::kNumberOfContours);
+ number_of_contours_ = data_->ReadShort(Offset::kNumberOfContours);
}
}
-GlyphTable::Glyph::~Glyph() {}
-
-int32_t GlyphTable::Glyph::glyphType(ReadableFontData* data, int32_t offset,
+int32_t GlyphTable::Glyph::GlyphType(ReadableFontData* data,
+ int32_t offset,
int32_t length) {
if (length == 0) {
return GlyphType::kSimple;
}
- int32_t number_of_contours = data->readShort(offset);
+ int32_t number_of_contours = data->ReadShort(offset);
if (number_of_contours >= 0) {
return GlyphType::kSimple;
}
return GlyphType::kComposite;
}
-CALLER_ATTACH GlyphTable::Glyph* GlyphTable::Glyph::getGlyph(
- ReadableFontData* data, int32_t offset, int32_t length) {
- int32_t type = glyphType(data, offset, length);
- GlyphPtr glyph;
-
- ReadableFontDataPtr sliced_data;
- sliced_data.attach(down_cast<ReadableFontData*>(data->slice(offset, length)));
- if (type == GlyphType::kSimple) {
- glyph = new SimpleGlyph(sliced_data);
- }
- glyph = new CompositeGlyph(sliced_data);
- return glyph.detach();
-}
-
-int32_t GlyphTable::Glyph::glyphType() {
- return glyph_type_;
-}
-
-int32_t GlyphTable::Glyph::numberOfContours() {
- return number_of_contours_;
-}
-
-int32_t GlyphTable::Glyph::xMin() {
- return data_->readShort(Offset::kXMin);
-}
-
-int32_t GlyphTable::Glyph::xMax() {
- return data_->readShort(Offset::kXMax);
-}
-
-int32_t GlyphTable::Glyph::yMin() {
- return data_->readShort(Offset::kYMin);
-}
-
-int32_t GlyphTable::Glyph::yMax() {
- return data_->readShort(Offset::kYMax);
-}
-
-int32_t GlyphTable::Glyph::padding() {
- return padding_;
-}
-
/******************************************************************************
* GlyphTable::Glyph::Builder class
******************************************************************************/
-GlyphTable::Glyph::Builder::Builder(FontDataTableBuilderContainer* font_builder,
- WritableFontData* data) :
- SubTable::Builder(font_builder, data) {
+GlyphTable::Glyph::Builder::~Builder() {
}
GlyphTable::Glyph::Builder::Builder(FontDataTableBuilderContainer* font_builder,
- ReadableFontData* data) :
- SubTable::Builder(font_builder, data) {
+ WritableFontData* data)
+ : SubTable::Builder(font_builder, data) {
}
-GlyphTable::Glyph::Builder::~Builder() {}
-
-CALLER_ATTACH GlyphTable::Glyph::Builder*
- GlyphTable::Glyph::Builder::getBuilder(
- FontDataTableBuilderContainer* table_builder, ReadableFontData* data) {
- return getBuilder(table_builder, data, 0, data->length());
+GlyphTable::Glyph::Builder::Builder(FontDataTableBuilderContainer* font_builder,
+ ReadableFontData* data)
+ : SubTable::Builder(font_builder, data) {
}
CALLER_ATTACH GlyphTable::Glyph::Builder*
- GlyphTable::Glyph::Builder::getBuilder(
- FontDataTableBuilderContainer* table_builder, ReadableFontData* data,
- int32_t offset, int32_t length) {
- int32_t type = Glyph::glyphType(data, offset, length);
+ GlyphTable::Glyph::Builder::GetBuilder(
+ FontDataTableBuilderContainer* table_builder,
+ ReadableFontData* data) {
+ return GetBuilder(table_builder, data, 0, data->Length());
+}
+
+CALLER_ATTACH GlyphTable::Glyph::Builder*
+ GlyphTable::Glyph::Builder::GetBuilder(
+ FontDataTableBuilderContainer* table_builder,
+ ReadableFontData* data,
+ int32_t offset,
+ int32_t length) {
+ int32_t type = Glyph::GlyphType(data, offset, length);
GlyphBuilderPtr builder;
ReadableFontDataPtr sliced_data;
- sliced_data.attach(down_cast<ReadableFontData*>(data->slice(offset, length)));
+ sliced_data.Attach(down_cast<ReadableFontData*>(data->Slice(offset, length)));
if (type == GlyphType::kSimple) {
builder = new SimpleGlyph::SimpleGlyphBuilder(table_builder, sliced_data);
} else {
builder = new CompositeGlyph::CompositeGlyphBuilder(table_builder,
sliced_data);
}
- return builder.detach();
+ return builder.Detach();
}
-void GlyphTable::Glyph::Builder::subDataSet() {
+void GlyphTable::Glyph::Builder::SubDataSet() {
// NOP
}
-int32_t GlyphTable::Glyph::Builder::subDataSizeToSerialize() {
- return internalReadData()->length();
+int32_t GlyphTable::Glyph::Builder::SubDataSizeToSerialize() {
+ return InternalReadData()->Length();
}
-bool GlyphTable::Glyph::Builder::subReadyToSerialize() {
+bool GlyphTable::Glyph::Builder::SubReadyToSerialize() {
return true;
}
-int32_t GlyphTable::Glyph::Builder::subSerialize(WritableFontData* new_data) {
- return internalReadData()->copyTo(new_data);
+int32_t GlyphTable::Glyph::Builder::SubSerialize(WritableFontData* new_data) {
+ return InternalReadData()->CopyTo(new_data);
}
/******************************************************************************
- * GlyphTable::SimpleGlyph and its builder
+ * GlyphTable::SimpleGlyph
******************************************************************************/
GlyphTable::SimpleGlyph::SimpleGlyph(ReadableFontData* data)
: GlyphTable::Glyph(data, GlyphType::kSimple) {
}
-GlyphTable::SimpleGlyph::~SimpleGlyph() {}
+GlyphTable::SimpleGlyph::~SimpleGlyph() {
+}
-void GlyphTable::SimpleGlyph::initialize() {
+int32_t GlyphTable::SimpleGlyph::InstructionSize() {
+ Initialize();
+ return instruction_size_;
+}
+
+CALLER_ATTACH ReadableFontData* GlyphTable::SimpleGlyph::Instructions() {
+ Initialize();
+ return down_cast<ReadableFontData*>(
+ data_->Slice(instructions_offset_, InstructionSize()));
+}
+
+int32_t GlyphTable::SimpleGlyph::NumberOfPoints(int32_t contour) {
+ Initialize();
+ if (contour >= NumberOfContours()) {
+ return 0;
+ }
+ return contour_index_[contour + 1] - contour_index_[contour];
+}
+
+int32_t GlyphTable::SimpleGlyph::XCoordinate(int32_t contour, int32_t point) {
+ Initialize();
+ return x_coordinates_[contour_index_[contour] + point];
+}
+
+int32_t GlyphTable::SimpleGlyph::YCoordinate(int32_t contour, int32_t point) {
+ Initialize();
+ return y_coordinates_[contour_index_[contour] + point];
+}
+
+bool GlyphTable::SimpleGlyph::OnCurve(int32_t contour, int32_t point) {
+ Initialize();
+ return on_curve_[contour_index_[contour] + point];
+}
+
+void GlyphTable::SimpleGlyph::Initialize() {
if (initialized_) {
return;
}
- if (readFontData()->length() == 0) {
+ if (ReadFontData()->Length() == 0) {
instruction_size_ = 0;
number_of_points_ = 0;
instructions_offset_ = 0;
@@ -331,38 +383,38 @@
return;
}
- instruction_size_ = data_->readUShort(Offset::kSimpleEndPtsOfCountours +
- numberOfContours() * DataSize::kUSHORT);
+ instruction_size_ = data_->ReadUShort(Offset::kSimpleEndPtsOfCountours +
+ NumberOfContours() * DataSize::kUSHORT);
instructions_offset_ = Offset::kSimpleEndPtsOfCountours +
- (numberOfContours() + 1) * DataSize::kUSHORT;
+ (NumberOfContours() + 1) * DataSize::kUSHORT;
flags_offset_ = instructions_offset_ + instruction_size_ * DataSize::kBYTE;
- number_of_points_ = contourEndPoint(numberOfContours() - 1) + 1;
+ number_of_points_ = ContourEndPoint(NumberOfContours() - 1) + 1;
x_coordinates_.resize(number_of_points_);
y_coordinates_.resize(number_of_points_);
on_curve_.resize(number_of_points_);
- parseData(false);
+ ParseData(false);
x_coordinates_offset_ = flags_offset_ + flag_byte_count_ * DataSize::kBYTE;
y_coordinates_offset_ = x_coordinates_offset_ + x_byte_count_ *
DataSize::kBYTE;
- contour_index_.resize(numberOfContours() + 1);
+ contour_index_.resize(NumberOfContours() + 1);
contour_index_[0] = 0;
for (uint32_t contour = 0; contour < contour_index_.size() - 1; ++contour) {
- contour_index_[contour + 1] = contourEndPoint(contour) + 1;
+ contour_index_[contour + 1] = ContourEndPoint(contour) + 1;
}
- parseData(true);
+ ParseData(true);
int32_t non_padded_data_length =
5 * DataSize::kSHORT +
- (numberOfContours() * DataSize::kUSHORT) +
+ (NumberOfContours() * DataSize::kUSHORT) +
DataSize::kUSHORT +
(instruction_size_ * DataSize::kBYTE) +
(flag_byte_count_ * DataSize::kBYTE) +
(x_byte_count_ * DataSize::kBYTE) +
(y_byte_count_ * DataSize::kBYTE);
- padding_ = length() - non_padded_data_length;
+ padding_ = Length() - non_padded_data_length;
initialized_ = true;
}
-void GlyphTable::SimpleGlyph::parseData(bool fill_arrays) {
+void GlyphTable::SimpleGlyph::ParseData(bool fill_arrays) {
int32_t flag = 0;
int32_t flag_repeat = 0;
int32_t flag_index = 0;
@@ -373,9 +425,9 @@
++point_index) {
// get the flag for the current point
if (flag_repeat == 0) {
- flag = flagAsInt(flag_index++);
+ flag = FlagAsInt(flag_index++);
if ((flag & kFLAG_REPEAT) == kFLAG_REPEAT) {
- flag_repeat = flagAsInt(flag_index++);
+ flag_repeat = FlagAsInt(flag_index++);
}
} else {
flag_repeat--;
@@ -390,7 +442,7 @@
// single byte x coord value
if (fill_arrays) {
x_coordinates_[point_index] =
- data_->readUByte(x_coordinates_offset_ + x_byte_index);
+ data_->ReadUByte(x_coordinates_offset_ + x_byte_index);
x_coordinates_[point_index] *=
((flag & kFLAG_XREPEATSIGN) == kFLAG_XREPEATSIGN) ? 1 : -1;
}
@@ -400,7 +452,7 @@
if (!((flag & kFLAG_XREPEATSIGN) == kFLAG_XREPEATSIGN)) {
if (fill_arrays) {
x_coordinates_[point_index] =
- data_->readShort(x_coordinates_offset_ + x_byte_index);
+ data_->ReadShort(x_coordinates_offset_ + x_byte_index);
}
x_byte_index += 2;
}
@@ -413,7 +465,7 @@
if ((flag & kFLAG_YSHORT) == kFLAG_YSHORT) {
if (fill_arrays) {
y_coordinates_[point_index] =
- data_->readUByte(y_coordinates_offset_ + y_byte_index);
+ data_->ReadUByte(y_coordinates_offset_ + y_byte_index);
y_coordinates_[point_index] *=
((flag & kFLAG_YREPEATSIGN) == kFLAG_YREPEATSIGN) ? 1 : -1;
}
@@ -422,7 +474,7 @@
if (!((flag & kFLAG_YREPEATSIGN) == kFLAG_YREPEATSIGN)) {
if (fill_arrays) {
y_coordinates_[point_index] =
- data_->readShort(y_coordinates_offset_ + y_byte_index);
+ data_->ReadShort(y_coordinates_offset_ + y_byte_index);
}
y_byte_index += 2;
}
@@ -436,86 +488,130 @@
y_byte_count_ = y_byte_index;
}
-int32_t GlyphTable::SimpleGlyph::flagAsInt(int32_t index) {
- return data_->readUByte(flags_offset_ + index * DataSize::kBYTE);
+int32_t GlyphTable::SimpleGlyph::FlagAsInt(int32_t index) {
+ return data_->ReadUByte(flags_offset_ + index * DataSize::kBYTE);
}
-int32_t GlyphTable::SimpleGlyph::contourEndPoint(int32_t contour) {
- return data_->readUShort(contour * DataSize::kUSHORT +
+int32_t GlyphTable::SimpleGlyph::ContourEndPoint(int32_t contour) {
+ return data_->ReadUShort(contour * DataSize::kUSHORT +
Offset::kSimpleEndPtsOfCountours);
}
-int32_t GlyphTable::SimpleGlyph::instructionSize() {
- initialize();
- return instruction_size_;
-}
-
-CALLER_ATTACH ReadableFontData* GlyphTable::SimpleGlyph::instructions() {
- initialize();
- return down_cast<ReadableFontData*>(
- data_->slice(instructions_offset_, instructionSize()));
-}
-
-int32_t GlyphTable::SimpleGlyph::numberOfPoints(int32_t contour) {
- initialize();
- if (contour >= numberOfContours()) {
- return 0;
- }
- return contour_index_[contour + 1] - contour_index_[contour];
-}
-
-int32_t GlyphTable::SimpleGlyph::xCoordinate(int32_t contour, int32_t point) {
- initialize();
- return x_coordinates_[contour_index_[contour] + point];
-}
-
-int32_t GlyphTable::SimpleGlyph::yCoordinate(int32_t contour, int32_t point) {
- initialize();
- return y_coordinates_[contour_index_[contour] + point];
-}
-
-bool GlyphTable::SimpleGlyph::onCurve(int32_t contour, int32_t point) {
- initialize();
- return on_curve_[contour_index_[contour] + point];
+/******************************************************************************
+ * GlyphTable::SimpleGlyph::Builder
+ ******************************************************************************/
+GlyphTable::SimpleGlyph::SimpleGlyphBuilder::~SimpleGlyphBuilder() {
}
GlyphTable::SimpleGlyph::SimpleGlyphBuilder::SimpleGlyphBuilder(
- FontDataTableBuilderContainer* table_builder, WritableFontData* data) :
- Glyph::Builder(table_builder, data) {
+ FontDataTableBuilderContainer* table_builder,
+ WritableFontData* data)
+ : Glyph::Builder(table_builder, data) {
}
GlyphTable::SimpleGlyph::SimpleGlyphBuilder::SimpleGlyphBuilder(
- FontDataTableBuilderContainer* table_builder, ReadableFontData* data) :
- Glyph::Builder(table_builder, data) {
+ FontDataTableBuilderContainer* table_builder,
+ ReadableFontData* data)
+ : Glyph::Builder(table_builder, data) {
}
-GlyphTable::SimpleGlyph::SimpleGlyphBuilder::~SimpleGlyphBuilder() {}
-
CALLER_ATTACH FontDataTable*
- GlyphTable::SimpleGlyph::SimpleGlyphBuilder::subBuildTable(
+ GlyphTable::SimpleGlyph::SimpleGlyphBuilder::SubBuildTable(
ReadableFontData* data) {
FontDataTablePtr table = new SimpleGlyph(data);
- return table.detach();
+ return table.Detach();
}
/******************************************************************************
- * GlyphTable::CompositeGlyph and its builder
+ * GlyphTable::CompositeGlyph
******************************************************************************/
GlyphTable::CompositeGlyph::CompositeGlyph(ReadableFontData* data)
: GlyphTable::Glyph(data, GlyphType::kComposite),
- instruction_size_(0), instructions_offset_(0) {
- parseData();
+ instruction_size_(0),
+ instructions_offset_(0) {
+ ParseData();
}
-GlyphTable::CompositeGlyph::~CompositeGlyph() {}
+GlyphTable::CompositeGlyph::~CompositeGlyph() {
+}
-void GlyphTable::CompositeGlyph::parseData() {
+int32_t GlyphTable::CompositeGlyph::Flags(int32_t contour) {
+ return data_->ReadUShort(contour_index_[contour]);
+}
+
+int32_t GlyphTable::CompositeGlyph::NumGlyphs() {
+ return contour_index_.size();
+}
+
+int32_t GlyphTable::CompositeGlyph::GlyphIndex(int32_t contour) {
+ return data_->ReadUShort(DataSize::kUSHORT + contour_index_[contour]);
+}
+
+int32_t GlyphTable::CompositeGlyph::Argument1(int32_t contour) {
+ int32_t index = 2 * DataSize::kUSHORT + contour_index_[contour];
+ int32_t contour_flags = Flags(contour);
+ if ((contour_flags & kFLAG_ARG_1_AND_2_ARE_WORDS) ==
+ kFLAG_ARG_1_AND_2_ARE_WORDS) {
+ return data_->ReadUShort(index);
+ }
+ return data_->ReadByte(index);
+}
+
+int32_t GlyphTable::CompositeGlyph::Argument2(int32_t contour) {
+ int32_t index = 2 * DataSize::kUSHORT + contour_index_[contour];
+ int32_t contour_flags = Flags(contour);
+ if ((contour_flags & kFLAG_ARG_1_AND_2_ARE_WORDS) ==
+ kFLAG_ARG_1_AND_2_ARE_WORDS) {
+ return data_->ReadUShort(index + DataSize::kUSHORT);
+ }
+ return data_->ReadByte(index + DataSize::kUSHORT);
+}
+
+int32_t GlyphTable::CompositeGlyph::TransformationSize(int32_t contour) {
+ int32_t contour_flags = Flags(contour);
+ if ((contour_flags & kFLAG_WE_HAVE_A_SCALE) == kFLAG_WE_HAVE_A_SCALE) {
+ return DataSize::kF2DOT14;
+ } else if ((contour_flags & kFLAG_WE_HAVE_AN_X_AND_Y_SCALE) ==
+ kFLAG_WE_HAVE_AN_X_AND_Y_SCALE) {
+ return 2 * DataSize::kF2DOT14;
+ } else if ((contour_flags & kFLAG_WE_HAVE_A_TWO_BY_TWO) ==
+ kFLAG_WE_HAVE_A_TWO_BY_TWO) {
+ return 4 * DataSize::kF2DOT14;
+ }
+ return 0;
+}
+
+void GlyphTable::CompositeGlyph::Transformation(int32_t contour,
+ ByteVector* transformation) {
+ int32_t contour_flags = Flags(contour);
+ int32_t index = contour_index_[contour] + 2 * DataSize::kUSHORT;
+ if ((contour_flags & kFLAG_ARG_1_AND_2_ARE_WORDS) ==
+ kFLAG_ARG_1_AND_2_ARE_WORDS) {
+ index += 2 * DataSize::kSHORT;
+ } else {
+ index += 2 * DataSize::kBYTE;
+ }
+ int32_t tsize = TransformationSize(contour);
+ transformation->resize(tsize);
+ data_->ReadBytes(index, transformation, 0, tsize);
+}
+
+int32_t GlyphTable::CompositeGlyph::InstructionSize() {
+ return instruction_size_;
+}
+
+CALLER_ATTACH ReadableFontData* GlyphTable::CompositeGlyph::Instructions() {
+ return down_cast<ReadableFontData*>(
+ data_->Slice(instructions_offset_, InstructionSize()));
+}
+
+void GlyphTable::CompositeGlyph::ParseData() {
int32_t index = 5 * DataSize::kUSHORT;
int32_t flags = kFLAG_MORE_COMPONENTS;
while ((flags & kFLAG_MORE_COMPONENTS) == kFLAG_MORE_COMPONENTS) {
contour_index_.push_back(index);
- flags = data_->readUShort(index);
+ flags = data_->ReadUShort(index);
index += 2 * DataSize::kUSHORT; // flags and glyphIndex
if ((flags & kFLAG_ARG_1_AND_2_ARE_WORDS) == kFLAG_ARG_1_AND_2_ARE_WORDS) {
index += 2 * DataSize::kSHORT;
@@ -533,102 +629,38 @@
}
int32_t non_padded_data_length = index;
if ((flags & kFLAG_WE_HAVE_INSTRUCTIONS) == kFLAG_WE_HAVE_INSTRUCTIONS) {
- instruction_size_ = data_->readUShort(index);
+ instruction_size_ = data_->ReadUShort(index);
index += DataSize::kUSHORT;
instructions_offset_ = index;
non_padded_data_length = index + (instruction_size_ * DataSize::kBYTE);
}
- padding_ = length() - non_padded_data_length;
+ padding_ = Length() - non_padded_data_length;
}
}
-int32_t GlyphTable::CompositeGlyph::flags(int32_t contour) {
- return data_->readUShort(contour_index_[contour]);
-}
-
-int32_t GlyphTable::CompositeGlyph::numGlyphs() {
- return contour_index_.size();
-}
-
-int32_t GlyphTable::CompositeGlyph::glyphIndex(int32_t contour) {
- return data_->readUShort(DataSize::kUSHORT + contour_index_[contour]);
-}
-
-int32_t GlyphTable::CompositeGlyph::argument1(int32_t contour) {
- int32_t index = 2 * DataSize::kUSHORT + contour_index_[contour];
- int32_t contour_flags = flags(contour);
- if ((contour_flags & kFLAG_ARG_1_AND_2_ARE_WORDS) ==
- kFLAG_ARG_1_AND_2_ARE_WORDS) {
- return data_->readUShort(index);
- }
- return data_->readByte(index);
-}
-
-int32_t GlyphTable::CompositeGlyph::argument2(int32_t contour) {
- int32_t index = 2 * DataSize::kUSHORT + contour_index_[contour];
- int32_t contour_flags = flags(contour);
- if ((contour_flags & kFLAG_ARG_1_AND_2_ARE_WORDS) ==
- kFLAG_ARG_1_AND_2_ARE_WORDS) {
- return data_->readUShort(index + DataSize::kUSHORT);
- }
- return data_->readByte(index + DataSize::kUSHORT);
-}
-
-int32_t GlyphTable::CompositeGlyph::transformationSize(int32_t contour) {
- int32_t contour_flags = flags(contour);
- if ((contour_flags & kFLAG_WE_HAVE_A_SCALE) == kFLAG_WE_HAVE_A_SCALE) {
- return DataSize::kF2DOT14;
- } else if ((contour_flags & kFLAG_WE_HAVE_AN_X_AND_Y_SCALE) ==
- kFLAG_WE_HAVE_AN_X_AND_Y_SCALE) {
- return 2 * DataSize::kF2DOT14;
- } else if ((contour_flags & kFLAG_WE_HAVE_A_TWO_BY_TWO) ==
- kFLAG_WE_HAVE_A_TWO_BY_TWO) {
- return 4 * DataSize::kF2DOT14;
- }
- return 0;
-}
-
-void GlyphTable::CompositeGlyph::transformation(int32_t contour,
- ByteVector* transformation) {
- int32_t contour_flags = flags(contour);
- int32_t index = contour_index_[contour] + 2 * DataSize::kUSHORT;
- if ((contour_flags & kFLAG_ARG_1_AND_2_ARE_WORDS) ==
- kFLAG_ARG_1_AND_2_ARE_WORDS) {
- index += 2 * DataSize::kSHORT;
- } else {
- index += 2 * DataSize::kBYTE;
- }
- int32_t tsize = transformationSize(contour);
- transformation->resize(tsize);
- data_->readBytes(index, transformation, 0, tsize);
-}
-
-int32_t GlyphTable::CompositeGlyph::instructionSize() {
- return instruction_size_;
-}
-
-CALLER_ATTACH ReadableFontData* GlyphTable::CompositeGlyph::instructions() {
- return down_cast<ReadableFontData*>(
- data_->slice(instructions_offset_, instructionSize()));
+/******************************************************************************
+ * GlyphTable::CompositeGlyph::Builder
+ ******************************************************************************/
+GlyphTable::CompositeGlyph::CompositeGlyphBuilder::~CompositeGlyphBuilder() {
}
GlyphTable::CompositeGlyph::CompositeGlyphBuilder::CompositeGlyphBuilder(
- FontDataTableBuilderContainer* table_builder, WritableFontData* data) :
- Glyph::Builder(table_builder, data) {
+ FontDataTableBuilderContainer* table_builder,
+ WritableFontData* data)
+ : Glyph::Builder(table_builder, data) {
}
GlyphTable::CompositeGlyph::CompositeGlyphBuilder::CompositeGlyphBuilder(
- FontDataTableBuilderContainer* table_builder, ReadableFontData* data) :
- Glyph::Builder(table_builder, data) {
+ FontDataTableBuilderContainer* table_builder,
+ ReadableFontData* data)
+ : Glyph::Builder(table_builder, data) {
}
-GlyphTable::CompositeGlyph::CompositeGlyphBuilder::~CompositeGlyphBuilder() {}
-
CALLER_ATTACH FontDataTable*
- GlyphTable::CompositeGlyph::CompositeGlyphBuilder::subBuildTable(
+ GlyphTable::CompositeGlyph::CompositeGlyphBuilder::SubBuildTable(
ReadableFontData* data) {
FontDataTablePtr table = new CompositeGlyph(data);
- return table.detach();
+ return table.Detach();
}
} // namespace sfntly
diff --git a/sfntly/glyph_table.h b/sfntly/glyph_table.h
index 8a7a8aa..c066d47 100644
--- a/sfntly/glyph_table.h
+++ b/sfntly/glyph_table.h
@@ -36,66 +36,9 @@
// before GlyphTable::Builder to avoid compilation errors.
class GlyphTable : public Table, public RefCounted<GlyphTable> {
public:
- struct Offset {
- enum {
- // header
- kNumberOfContours = 0,
- kXMin = 2,
- kYMin = 4,
- kXMax = 6,
- kYMax = 8,
-
- // Simple Glyph Description
- kSimpleEndPtsOfCountours = 10,
- // offset from the end of the contours array
- kSimpleInstructionLength = 0,
- kSimpleInstructions = 2,
- // flags
- // xCoordinates
- // yCoordinates
-
- // Composite Glyph Description
- kCompositeFlags = 0,
- kCompositeGyphIndexWithoutFlag = 0,
- kCompositeGlyphIndexWithFlag = 2,
- };
- };
-
- private:
- GlyphTable(Header* header, ReadableFontData* data);
-
- public:
- virtual ~GlyphTable();
-
- class Glyph;
- Glyph* glyph(int32_t offset, int32_t length);
-
class Builder;
class Glyph : public SubTable {
- protected:
- // Note: constructor refactored in C++ to avoid heavy lifting.
- // caller need to do data->slice(offset, length) beforehand.
- Glyph(ReadableFontData* data, int32_t glyph_type);
-
- private:
- static int32_t glyphType(ReadableFontData* data, int32_t offset,
- int32_t length);
-
public:
- virtual ~Glyph();
- static CALLER_ATTACH Glyph* getGlyph(ReadableFontData* data, int32_t offset,
- int32_t length);
- virtual int32_t glyphType();
- virtual int32_t numberOfContours();
- virtual int32_t xMin();
- virtual int32_t xMax();
- virtual int32_t yMin();
- virtual int32_t yMax();
- virtual int32_t padding(); // override FontDataTable::padding()
-
- virtual int32_t instructionSize() = 0;
- virtual ReadableFontData* instructions() = 0;
-
// Note: Contour is an empty class for the version ported
class Contour {
protected:
@@ -104,42 +47,67 @@
};
class Builder : public SubTable::Builder {
+ public:
+ virtual ~Builder();
+
protected:
// Incoming table_builder is GlyphTable::Builder*.
// Note: constructor refactored in C++ to avoid heavy lifting.
- // caller need to do data->slice(offset, length) beforehand.
+ // caller need to do data->Slice(offset, length) beforehand.
Builder(FontDataTableBuilderContainer* table_builder,
WritableFontData* data);
Builder(FontDataTableBuilderContainer* table_builder,
ReadableFontData* data);
- public:
- virtual ~Builder();
+ static CALLER_ATTACH Builder*
+ GetBuilder(FontDataTableBuilderContainer* table_builder,
+ ReadableFontData* data);
+ static CALLER_ATTACH Builder*
+ GetBuilder(FontDataTableBuilderContainer* table_builder,
+ ReadableFontData* data,
+ int32_t offset,
+ int32_t length);
+ virtual void SubDataSet();
+ virtual int32_t SubDataSizeToSerialize();
+ virtual bool SubReadyToSerialize();
+ virtual int32_t SubSerialize(WritableFontData* new_data);
- protected:
- static CALLER_ATTACH Builder* getBuilder(
- FontDataTableBuilderContainer* table_builder, ReadableFontData* data);
- static CALLER_ATTACH Builder* getBuilder(
- FontDataTableBuilderContainer* table_builder, ReadableFontData* data,
- int32_t offset, int32_t length);
- virtual void subDataSet();
- virtual int32_t subDataSizeToSerialize();
- virtual bool subReadyToSerialize();
- virtual int32_t subSerialize(WritableFontData* new_data);
-
- protected:
+ private:
int32_t format_;
friend class GlyphTable::Builder;
};
- private:
- int32_t glyph_type_;
- int32_t number_of_contours_;
+ virtual ~Glyph();
+ static CALLER_ATTACH Glyph* GetGlyph(ReadableFontData* data,
+ int32_t offset,
+ int32_t length);
+ virtual int32_t GlyphType();
+ virtual int32_t NumberOfContours();
+ virtual int32_t XMin();
+ virtual int32_t XMax();
+ virtual int32_t YMin();
+ virtual int32_t YMax();
+ virtual int32_t Padding(); // override FontDataTable::Padding()
+
+ virtual int32_t InstructionSize() = 0;
+ virtual ReadableFontData* Instructions() = 0;
protected:
- int32_t padding_;
- };
+ // Note: constructor refactored in C++ to avoid heavy lifting.
+ // caller need to do data->Slice(offset, length) beforehand.
+ Glyph(ReadableFontData* data, int32_t glyph_type);
+ // TODO(arthurhsu): violating C++ style guide, need refactoring.
+ int32_t padding_;
+
+ private:
+ static int32_t GlyphType(ReadableFontData* data,
+ int32_t offset,
+ int32_t length);
+
+ int32_t glyph_type_;
+ int32_t number_of_contours_;
+ }; // class GlyphTable::Glyph
typedef Ptr<GlyphTable::Glyph::Builder> GlyphBuilderPtr;
typedef std::vector<GlyphBuilderPtr> GlyphBuilderList;
@@ -147,19 +115,14 @@
public RefCounted<GlyphTable::Builder> {
public:
// Note: Constructor scope altered to public for base class to instantiate.
- Builder(FontDataTableBuilderContainer* font_builder, Header* header,
+ Builder(FontDataTableBuilderContainer* font_builder,
+ Header* header,
WritableFontData* data);
virtual ~Builder();
- virtual void setLoca(const IntegerList& loca);
- virtual void generateLocaList(IntegerList* locas);
+ virtual void SetLoca(const IntegerList& loca);
+ virtual void GenerateLocaList(IntegerList* locas);
- private:
- void initialize(ReadableFontData* data, const IntegerList& loca);
- GlyphBuilderList* getGlyphBuilders();
- void revert();
-
- public:
// Gets the List of glyph builders for the glyph table builder. These may be
// manipulated in any way by the caller and the changes will be reflected in
// the final glyph table produced.
@@ -168,22 +131,26 @@
// List. If there is current data (i.e. data read from an existing font) and
// the <code>loca</code> list has not been set or is null, empty, or
// invalid, then an empty glyph builder List will be returned.
- GlyphBuilderList* glyphBuilders();
+ GlyphBuilderList* GlyphBuilders();
// Replace the internal glyph builders with the one provided.
- void setGlyphBuilders(GlyphBuilderList* glyph_builders);
+ void SetGlyphBuilders(GlyphBuilderList* glyph_builders);
// Glyph builder factories
- CALLER_ATTACH Glyph::Builder* glyphBuilder(ReadableFontData* data);
+ CALLER_ATTACH Glyph::Builder* GlyphBuilder(ReadableFontData* data);
protected: // internal API for building
- virtual CALLER_ATTACH FontDataTable* subBuildTable(ReadableFontData* data);
- virtual void subDataSet();
- virtual int32_t subDataSizeToSerialize();
- virtual bool subReadyToSerialize();
- virtual int32_t subSerialize(WritableFontData* new_data);
+ 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, const IntegerList& loca);
+ GlyphBuilderList* GetGlyphBuilders();
+ void Revert();
+
GlyphBuilderList glyph_builders_;
IntegerList loca_;
};
@@ -197,34 +164,12 @@
static const int32_t kFLAG_XREPEATSIGN;
static const int32_t kFLAG_YREPEATSIGN;
- public:
- // Note: constructor refactored in C++ to avoid heavy lifting.
- // caller need to do data->slice(offset, length) beforehand.
- explicit SimpleGlyph(ReadableFontData* data);
- virtual ~SimpleGlyph();
-
- public:
class SimpleContour : public Glyph::Contour {
protected:
SimpleContour() {}
virtual ~SimpleContour() {}
};
- private:
- void initialize();
- void parseData(bool fill_arrays);
- int32_t flagAsInt(int32_t index);
- int32_t contourEndPoint(int32_t contour);
-
- public: // class is final, , no virtual functions unless from parent
- virtual int32_t instructionSize();
- virtual CALLER_ATTACH ReadableFontData* instructions();
- int32_t numberOfPoints(int32_t contour);
- int32_t xCoordinate(int32_t contour, int32_t point);
- int32_t yCoordinate(int32_t contour, int32_t point);
- bool onCurve(int32_t contour, int32_t point);
-
- public:
class SimpleGlyphBuilder : public Glyph::Builder,
public RefCounted<SimpleGlyphBuilder> {
public:
@@ -232,17 +177,36 @@
protected:
// Note: constructor refactored in C++ to avoid heavy lifting.
- // caller need to do data->slice(offset, length) beforehand.
+ // caller need to do data->Slice(offset, length) beforehand.
SimpleGlyphBuilder(FontDataTableBuilderContainer* table_builder,
WritableFontData* data);
SimpleGlyphBuilder(FontDataTableBuilderContainer* table_builder,
ReadableFontData* data);
virtual CALLER_ATTACH FontDataTable*
- subBuildTable(ReadableFontData* data);
+ SubBuildTable(ReadableFontData* data);
+
+ private:
friend class Glyph::Builder;
};
+ // Note: constructor refactored in C++ to avoid heavy lifting.
+ // caller need to do data->Slice(offset, length) beforehand.
+ explicit SimpleGlyph(ReadableFontData* data);
+ virtual ~SimpleGlyph();
+
+ virtual int32_t InstructionSize();
+ virtual CALLER_ATTACH ReadableFontData* Instructions();
+ int32_t NumberOfPoints(int32_t contour);
+ int32_t XCoordinate(int32_t contour, int32_t point);
+ int32_t YCoordinate(int32_t contour, int32_t point);
+ bool OnCurve(int32_t contour, int32_t point);
+
private:
+ void Initialize();
+ void ParseData(bool fill_arrays);
+ int32_t FlagAsInt(int32_t index);
+ int32_t ContourEndPoint(int32_t contour);
+
bool initialized_;
int32_t instruction_size_;
int32_t number_of_points_;
@@ -279,27 +243,6 @@
static const int32_t kFLAG_SCALED_COMPONENT_OFFSET;
static const int32_t kFLAG_UNSCALED_COMPONENT_OFFSET;
- public:
- // Note: constructor refactored in C++ to avoid heavy lifting.
- // caller need to do data->slice(offset, length) beforehand.
- explicit CompositeGlyph(ReadableFontData* data);
- virtual ~CompositeGlyph();
-
- private:
- void parseData();
-
- public: // class is final, no virtual functions unless from parent
- int32_t flags(int32_t contour);
- int32_t numGlyphs();
- int32_t glyphIndex(int32_t contour);
- int32_t argument1(int32_t contour);
- int32_t argument2(int32_t contour);
- int32_t transformationSize(int32_t contour);
- void transformation(int32_t contour, ByteVector* transformation);
- virtual int32_t instructionSize();
- virtual CALLER_ATTACH ReadableFontData* instructions();
-
- public:
class CompositeGlyphBuilder : public Glyph::Builder,
public RefCounted<CompositeGlyphBuilder> {
public:
@@ -307,22 +250,74 @@
protected:
// Note: constructor refactored in C++ to avoid heavy lifting.
- // caller need to do data->slice(offset, length) beforehand.
+ // caller need to do data->Slice(offset, length) beforehand.
CompositeGlyphBuilder(FontDataTableBuilderContainer* table_builder,
WritableFontData* data);
CompositeGlyphBuilder(FontDataTableBuilderContainer* table_builder,
ReadableFontData* data);
virtual CALLER_ATTACH FontDataTable*
- subBuildTable(ReadableFontData* data);
+ SubBuildTable(ReadableFontData* data);
+
+ private:
friend class Glyph::Builder;
};
+ // Note: constructor refactored in C++ to avoid heavy lifting.
+ // caller need to do data->Slice(offset, length) beforehand.
+ explicit CompositeGlyph(ReadableFontData* data);
+ virtual ~CompositeGlyph();
+
+ int32_t Flags(int32_t contour);
+ int32_t NumGlyphs();
+ int32_t GlyphIndex(int32_t contour);
+ int32_t Argument1(int32_t contour);
+ int32_t Argument2(int32_t contour);
+ int32_t TransformationSize(int32_t contour);
+ void Transformation(int32_t contour, ByteVector* transformation);
+ virtual int32_t InstructionSize();
+ virtual CALLER_ATTACH ReadableFontData* Instructions();
+
private:
+ void ParseData();
+
IntegerList contour_index_;
int32_t instruction_size_;
int32_t instructions_offset_;
};
+
+ virtual ~GlyphTable();
+
+ // C++ port: rename glyph() to GetGlyph().
+ Glyph* GetGlyph(int32_t offset, int32_t length);
+
+ private:
+ struct Offset {
+ enum {
+ // header
+ kNumberOfContours = 0,
+ kXMin = 2,
+ kYMin = 4,
+ kXMax = 6,
+ kYMax = 8,
+
+ // Simple Glyph Description
+ kSimpleEndPtsOfCountours = 10,
+ // offset from the end of the contours array
+ kSimpleInstructionLength = 0,
+ kSimpleInstructions = 2,
+ // flags
+ // xCoordinates
+ // yCoordinates
+
+ // Composite Glyph Description
+ kCompositeFlags = 0,
+ kCompositeGyphIndexWithoutFlag = 0,
+ kCompositeGlyphIndexWithFlag = 2,
+ };
+ };
+
+ GlyphTable(Header* header, ReadableFontData* data);
};
typedef Ptr<GlyphTable> GlyphTablePtr;
typedef Ptr<GlyphTable::Builder> GlyphTableBuilderPtr;
diff --git a/sfntly/horizontal_header_table.cc b/sfntly/horizontal_header_table.cc
index f30e8db..a987d70 100644
--- a/sfntly/horizontal_header_table.cc
+++ b/sfntly/horizontal_header_table.cc
@@ -24,189 +24,192 @@
/******************************************************************************
* HorizontalHeaderTable class
******************************************************************************/
-HorizontalHeaderTable:: HorizontalHeaderTable(Header* header,
- ReadableFontData* data) :
- Table(header, data) {}
-
HorizontalHeaderTable:: ~HorizontalHeaderTable() {}
-int32_t HorizontalHeaderTable::version() {
- return data_->readFixed(Offset::kVersion);
+int32_t HorizontalHeaderTable::Version() {
+ return data_->ReadFixed(Offset::kVersion);
}
-int32_t HorizontalHeaderTable::ascender() {
- return data_->readShort(Offset::kAscender);
+int32_t HorizontalHeaderTable::Ascender() {
+ return data_->ReadShort(Offset::kAscender);
}
-int32_t HorizontalHeaderTable::descender() {
- return data_->readShort(Offset::kDescender);
+int32_t HorizontalHeaderTable::Descender() {
+ return data_->ReadShort(Offset::kDescender);
}
-int32_t HorizontalHeaderTable::lineGap() {
- return data_->readShort(Offset::kLineGap);
+int32_t HorizontalHeaderTable::LineGap() {
+ return data_->ReadShort(Offset::kLineGap);
}
-int32_t HorizontalHeaderTable::advanceWidthMax() {
- return data_->readUShort(Offset::kAdvanceWidthMax);
+int32_t HorizontalHeaderTable::AdvanceWidthMax() {
+ return data_->ReadUShort(Offset::kAdvanceWidthMax);
}
-int32_t HorizontalHeaderTable::minLeftSideBearing() {
- return data_->readShort(Offset::kMinLeftSideBearing);
+int32_t HorizontalHeaderTable::MinLeftSideBearing() {
+ return data_->ReadShort(Offset::kMinLeftSideBearing);
}
-int32_t HorizontalHeaderTable::minRightSideBearing() {
- return data_->readShort(Offset::kMinRightSideBearing);
+int32_t HorizontalHeaderTable::MinRightSideBearing() {
+ return data_->ReadShort(Offset::kMinRightSideBearing);
}
-int32_t HorizontalHeaderTable::xMaxExtent() {
- return data_->readShort(Offset::kXMaxExtent);
+int32_t HorizontalHeaderTable::XMaxExtent() {
+ return data_->ReadShort(Offset::kXMaxExtent);
}
-int32_t HorizontalHeaderTable::caretSlopeRise() {
- return data_->readShort(Offset::kCaretSlopeRise);
+int32_t HorizontalHeaderTable::CaretSlopeRise() {
+ return data_->ReadShort(Offset::kCaretSlopeRise);
}
-int32_t HorizontalHeaderTable::caretSlopeRun() {
- return data_->readShort(Offset::kCaretSlopeRun);
+int32_t HorizontalHeaderTable::CaretSlopeRun() {
+ return data_->ReadShort(Offset::kCaretSlopeRun);
}
-int32_t HorizontalHeaderTable::caretOffset() {
- return data_->readShort(Offset::kCaretOffset);
+int32_t HorizontalHeaderTable::CaretOffset() {
+ return data_->ReadShort(Offset::kCaretOffset);
}
-int32_t HorizontalHeaderTable::metricDataFormat() {
- return data_->readShort(Offset::kMetricDataFormat);
+int32_t HorizontalHeaderTable::MetricDataFormat() {
+ return data_->ReadShort(Offset::kMetricDataFormat);
}
-int32_t HorizontalHeaderTable::numberOfHMetrics() {
- return data_->readUShort(Offset::kNumberOfHMetrics);
+int32_t HorizontalHeaderTable::NumberOfHMetrics() {
+ return data_->ReadUShort(Offset::kNumberOfHMetrics);
+}
+
+HorizontalHeaderTable:: HorizontalHeaderTable(Header* header,
+ ReadableFontData* data)
+ : Table(header, data) {
}
/******************************************************************************
* HorizontalHeaderTable::Builder class
******************************************************************************/
HorizontalHeaderTable::Builder::Builder(
- FontDataTableBuilderContainer* font_builder, Header* header,
- WritableFontData* data) :
- Table::TableBasedTableBuilder(font_builder, header, data) {
+ FontDataTableBuilderContainer* font_builder,
+ Header* header,
+ WritableFontData* data)
+ : Table::TableBasedTableBuilder(font_builder, header, data) {
}
HorizontalHeaderTable::Builder::Builder(
- FontDataTableBuilderContainer* font_builder, Header* header,
- ReadableFontData* data) :
- Table::TableBasedTableBuilder(font_builder, header, data) {
+ FontDataTableBuilderContainer* font_builder,
+ Header* header,
+ ReadableFontData* data)
+ : Table::TableBasedTableBuilder(font_builder, header, data) {
}
HorizontalHeaderTable::Builder::~Builder() {}
-CALLER_ATTACH FontDataTable* HorizontalHeaderTable::Builder::subBuildTable(
- ReadableFontData* data) {
+CALLER_ATTACH FontDataTable*
+ HorizontalHeaderTable::Builder::SubBuildTable(ReadableFontData* data) {
FontDataTablePtr table = new HorizontalHeaderTable(header(), data);
- return table.detach();
+ return table.Detach();
}
-int32_t HorizontalHeaderTable::Builder::version() {
- return internalReadData()->readFixed(Offset::kVersion);
+int32_t HorizontalHeaderTable::Builder::Version() {
+ return InternalReadData()->ReadFixed(Offset::kVersion);
}
-void HorizontalHeaderTable::Builder::setVersion(int32_t version) {
- internalWriteData()->writeFixed(Offset::kVersion, version);
+void HorizontalHeaderTable::Builder::SetVersion(int32_t version) {
+ InternalWriteData()->WriteFixed(Offset::kVersion, version);
}
-int32_t HorizontalHeaderTable::Builder::ascender() {
- return internalReadData()->readUShort(Offset::kAscender);
+int32_t HorizontalHeaderTable::Builder::Ascender() {
+ return InternalReadData()->ReadUShort(Offset::kAscender);
}
-void HorizontalHeaderTable::Builder::setAscender(int32_t ascender) {
- internalWriteData()->writeUShort(Offset::kVersion, ascender);
+void HorizontalHeaderTable::Builder::SetAscender(int32_t ascender) {
+ InternalWriteData()->WriteUShort(Offset::kVersion, ascender);
}
-int32_t HorizontalHeaderTable::Builder::descender() {
- return internalReadData()->readUShort(Offset::kDescender);
+int32_t HorizontalHeaderTable::Builder::Descender() {
+ return InternalReadData()->ReadUShort(Offset::kDescender);
}
-void HorizontalHeaderTable::Builder::setDescender(int32_t descender) {
- internalWriteData()->writeUShort(Offset::kDescender, descender);
+void HorizontalHeaderTable::Builder::SetDescender(int32_t descender) {
+ InternalWriteData()->WriteUShort(Offset::kDescender, descender);
}
-int32_t HorizontalHeaderTable::Builder::lineGap() {
- return internalReadData()->readUShort(Offset::kLineGap);
+int32_t HorizontalHeaderTable::Builder::LineGap() {
+ return InternalReadData()->ReadUShort(Offset::kLineGap);
}
-void HorizontalHeaderTable::Builder::setLineGap(int32_t line_gap) {
- internalWriteData()->writeUShort(Offset::kLineGap, line_gap);
+void HorizontalHeaderTable::Builder::SetLineGap(int32_t line_gap) {
+ InternalWriteData()->WriteUShort(Offset::kLineGap, line_gap);
}
-int32_t HorizontalHeaderTable::Builder::advanceWidthMax() {
- return internalReadData()->readUShort(Offset::kAdvanceWidthMax);
+int32_t HorizontalHeaderTable::Builder::AdvanceWidthMax() {
+ return InternalReadData()->ReadUShort(Offset::kAdvanceWidthMax);
}
-void HorizontalHeaderTable::Builder::setAdvanceWidthMax(int32_t value) {
- internalWriteData()->writeUShort(Offset::kAdvanceWidthMax, value);
+void HorizontalHeaderTable::Builder::SetAdvanceWidthMax(int32_t value) {
+ InternalWriteData()->WriteUShort(Offset::kAdvanceWidthMax, value);
}
-int32_t HorizontalHeaderTable::Builder::minLeftSideBearing() {
- return internalReadData()->readUShort(Offset::kMinLeftSideBearing);
+int32_t HorizontalHeaderTable::Builder::MinLeftSideBearing() {
+ return InternalReadData()->ReadUShort(Offset::kMinLeftSideBearing);
}
-void HorizontalHeaderTable::Builder::setMinLeftSideBearing(int32_t value) {
- internalWriteData()->writeUShort(Offset::kMinLeftSideBearing, value);
+void HorizontalHeaderTable::Builder::SetMinLeftSideBearing(int32_t value) {
+ InternalWriteData()->WriteUShort(Offset::kMinLeftSideBearing, value);
}
-int32_t HorizontalHeaderTable::Builder::minRightSideBearing() {
- return internalReadData()->readUShort(Offset::kMinRightSideBearing);
+int32_t HorizontalHeaderTable::Builder::MinRightSideBearing() {
+ return InternalReadData()->ReadUShort(Offset::kMinRightSideBearing);
}
-void HorizontalHeaderTable::Builder::setMinRightSideBearing(int32_t value) {
- internalWriteData()->writeUShort(Offset::kMinRightSideBearing, value);
+void HorizontalHeaderTable::Builder::SetMinRightSideBearing(int32_t value) {
+ InternalWriteData()->WriteUShort(Offset::kMinRightSideBearing, value);
}
-int32_t HorizontalHeaderTable::Builder::xMaxExtent() {
- return internalReadData()->readUShort(Offset::kXMaxExtent);
+int32_t HorizontalHeaderTable::Builder::XMaxExtent() {
+ return InternalReadData()->ReadUShort(Offset::kXMaxExtent);
}
-void HorizontalHeaderTable::Builder::setXMaxExtent(int32_t value) {
- internalWriteData()->writeUShort(Offset::kXMaxExtent, value);
+void HorizontalHeaderTable::Builder::SetXMaxExtent(int32_t value) {
+ InternalWriteData()->WriteUShort(Offset::kXMaxExtent, value);
}
-int32_t HorizontalHeaderTable::Builder::caretSlopeRise() {
- return internalReadData()->readUShort(Offset::kCaretSlopeRise);
+int32_t HorizontalHeaderTable::Builder::CaretSlopeRise() {
+ return InternalReadData()->ReadUShort(Offset::kCaretSlopeRise);
}
-void HorizontalHeaderTable::Builder::setCaretSlopeRise(int32_t value) {
- internalWriteData()->writeUShort(Offset::kCaretSlopeRise, value);
+void HorizontalHeaderTable::Builder::SetCaretSlopeRise(int32_t value) {
+ InternalWriteData()->WriteUShort(Offset::kCaretSlopeRise, value);
}
-int32_t HorizontalHeaderTable::Builder::caretSlopeRun() {
- return internalReadData()->readUShort(Offset::kCaretSlopeRun);
+int32_t HorizontalHeaderTable::Builder::CaretSlopeRun() {
+ return InternalReadData()->ReadUShort(Offset::kCaretSlopeRun);
}
-void HorizontalHeaderTable::Builder::setCaretSlopeRun(int32_t value) {
- internalWriteData()->writeUShort(Offset::kCaretSlopeRun, value);
+void HorizontalHeaderTable::Builder::SetCaretSlopeRun(int32_t value) {
+ InternalWriteData()->WriteUShort(Offset::kCaretSlopeRun, value);
}
-int32_t HorizontalHeaderTable::Builder::caretOffset() {
- return internalReadData()->readUShort(Offset::kCaretOffset);
+int32_t HorizontalHeaderTable::Builder::CaretOffset() {
+ return InternalReadData()->ReadUShort(Offset::kCaretOffset);
}
-void HorizontalHeaderTable::Builder::setCaretOffset(int32_t value) {
- internalWriteData()->writeUShort(Offset::kCaretOffset, value);
+void HorizontalHeaderTable::Builder::SetCaretOffset(int32_t value) {
+ InternalWriteData()->WriteUShort(Offset::kCaretOffset, value);
}
-int32_t HorizontalHeaderTable::Builder::metricDataFormat() {
- return internalReadData()->readUShort(Offset::kMetricDataFormat);
+int32_t HorizontalHeaderTable::Builder::MetricDataFormat() {
+ return InternalReadData()->ReadUShort(Offset::kMetricDataFormat);
}
-void HorizontalHeaderTable::Builder::setMetricDataFormat(int32_t value) {
- internalWriteData()->writeUShort(Offset::kMetricDataFormat, value);
+void HorizontalHeaderTable::Builder::SetMetricDataFormat(int32_t value) {
+ InternalWriteData()->WriteUShort(Offset::kMetricDataFormat, value);
}
-int32_t HorizontalHeaderTable::Builder::numberOfHMetrics() {
- return internalReadData()->readUShort(Offset::kNumberOfHMetrics);
+int32_t HorizontalHeaderTable::Builder::NumberOfHMetrics() {
+ return InternalReadData()->ReadUShort(Offset::kNumberOfHMetrics);
}
-void HorizontalHeaderTable::Builder::setNumberOfHMetrics(int32_t value) {
- internalWriteData()->writeUShort(Offset::kNumberOfHMetrics, value);
+void HorizontalHeaderTable::Builder::SetNumberOfHMetrics(int32_t value) {
+ InternalWriteData()->WriteUShort(Offset::kNumberOfHMetrics, value);
}
} // namespace sfntly
diff --git a/sfntly/horizontal_header_table.h b/sfntly/horizontal_header_table.h
index 704391c..e8a3534 100644
--- a/sfntly/horizontal_header_table.h
+++ b/sfntly/horizontal_header_table.h
@@ -23,6 +23,64 @@
class HorizontalHeaderTable : public Table,
public RefCounted<HorizontalHeaderTable> {
+ public:
+ class Builder : public Table::TableBasedTableBuilder,
+ public RefCounted<Builder> {
+ public:
+ // Constructor scope altered to public because C++ does not allow base
+ // class to instantiate derived class with protected constructors.
+ Builder(FontDataTableBuilderContainer* font_builder,
+ Header* header,
+ WritableFontData* data);
+ Builder(FontDataTableBuilderContainer* font_builder,
+ Header* header,
+ ReadableFontData* data);
+ virtual ~Builder();
+ virtual CALLER_ATTACH FontDataTable* SubBuildTable(ReadableFontData* data);
+
+ int32_t Version();
+ void SetVersion(int32_t version);
+ int32_t Ascender();
+ void SetAscender(int32_t ascender);
+ int32_t Descender();
+ void SetDescender(int32_t descender);
+ int32_t LineGap();
+ void SetLineGap(int32_t line_gap);
+ int32_t AdvanceWidthMax();
+ void SetAdvanceWidthMax(int32_t value);
+ int32_t MinLeftSideBearing();
+ void SetMinLeftSideBearing(int32_t value);
+ int32_t MinRightSideBearing();
+ void SetMinRightSideBearing(int32_t value);
+ int32_t XMaxExtent();
+ void SetXMaxExtent(int32_t value);
+ int32_t CaretSlopeRise();
+ void SetCaretSlopeRise(int32_t value);
+ int32_t CaretSlopeRun();
+ void SetCaretSlopeRun(int32_t value);
+ int32_t CaretOffset();
+ void SetCaretOffset(int32_t value);
+ int32_t MetricDataFormat();
+ void SetMetricDataFormat(int32_t value);
+ int32_t NumberOfHMetrics();
+ void SetNumberOfHMetrics(int32_t value);
+ };
+
+ virtual ~HorizontalHeaderTable();
+ int32_t Version();
+ int32_t Ascender();
+ int32_t Descender();
+ int32_t LineGap();
+ int32_t AdvanceWidthMax();
+ int32_t MinLeftSideBearing();
+ int32_t MinRightSideBearing();
+ int32_t XMaxExtent();
+ int32_t CaretSlopeRise();
+ int32_t CaretSlopeRun();
+ int32_t CaretOffset();
+ int32_t MetricDataFormat();
+ int32_t NumberOfHMetrics();
+
private:
struct Offset {
enum {
@@ -42,65 +100,7 @@
};
};
- private:
HorizontalHeaderTable(Header* header, ReadableFontData* data);
-
- public:
- virtual ~HorizontalHeaderTable();
- int32_t version();
- int32_t ascender();
- int32_t descender();
- int32_t lineGap();
- int32_t advanceWidthMax();
- int32_t minLeftSideBearing();
- int32_t minRightSideBearing();
- int32_t xMaxExtent();
- int32_t caretSlopeRise();
- int32_t caretSlopeRun();
- int32_t caretOffset();
- int32_t metricDataFormat();
- int32_t numberOfHMetrics();
-
- public:
- class Builder : public Table::TableBasedTableBuilder,
- public RefCounted<Builder> {
- public:
- // Constructor scope altered to public because C++ does not allow base
- // class to instantiate derived class with protected constructors.
- Builder(FontDataTableBuilderContainer* font_builder, Header* header,
- WritableFontData* data);
- Builder(FontDataTableBuilderContainer* font_builder, Header* header,
- ReadableFontData* data);
- virtual ~Builder();
- virtual CALLER_ATTACH FontDataTable* subBuildTable(ReadableFontData* data);
-
- int32_t version();
- void setVersion(int32_t version);
- int32_t ascender();
- void setAscender(int32_t ascender);
- int32_t descender();
- void setDescender(int32_t descender);
- int32_t lineGap();
- void setLineGap(int32_t line_gap);
- int32_t advanceWidthMax();
- void setAdvanceWidthMax(int32_t value);
- int32_t minLeftSideBearing();
- void setMinLeftSideBearing(int32_t value);
- int32_t minRightSideBearing();
- void setMinRightSideBearing(int32_t value);
- int32_t xMaxExtent();
- void setXMaxExtent(int32_t value);
- int32_t caretSlopeRise();
- void setCaretSlopeRise(int32_t value);
- int32_t caretSlopeRun();
- void setCaretSlopeRun(int32_t value);
- int32_t caretOffset();
- void setCaretOffset(int32_t value);
- int32_t metricDataFormat();
- void setMetricDataFormat(int32_t value);
- int32_t numberOfHMetrics();
- void setNumberOfHMetrics(int32_t value);
- };
};
typedef Ptr<HorizontalHeaderTable> HorizontalHeaderTablePtr;
typedef Ptr<HorizontalHeaderTable::Builder> HorizontalHeaderTableBuilderPtr;
diff --git a/sfntly/horizontal_metrics_table.cc b/sfntly/horizontal_metrics_table.cc
index c151e18..921d8bc 100644
--- a/sfntly/horizontal_metrics_table.cc
+++ b/sfntly/horizontal_metrics_table.cc
@@ -21,29 +21,17 @@
/******************************************************************************
* HorizontalMetricsTable class
******************************************************************************/
-HorizontalMetricsTable::HorizontalMetricsTable(Header* header,
- ReadableFontData* data) :
- Table(header, data) {
-}
-
-HorizontalMetricsTable::HorizontalMetricsTable(Header* header,
- ReadableFontData* data,
- int32_t num_hmetrics,
- int32_t num_glyphs) :
- Table(header, data), num_hmetrics_(num_hmetrics), num_glyphs_(num_glyphs) {
-}
-
HorizontalMetricsTable::~HorizontalMetricsTable() {}
-int32_t HorizontalMetricsTable::numberOfHMetrics() {
+int32_t HorizontalMetricsTable::NumberOfHMetrics() {
return num_hmetrics_;
}
-int32_t HorizontalMetricsTable::numberOfLSBs() {
+int32_t HorizontalMetricsTable::NumberOfLSBs() {
return num_glyphs_ - num_hmetrics_;
}
-int32_t HorizontalMetricsTable::hMetricAdvanceWidth(int32_t entry) {
+int32_t HorizontalMetricsTable::HMetricAdvanceWidth(int32_t entry) {
if (entry > num_hmetrics_) {
#if defined (SFNTLY_NO_EXCEPTION)
return 0;
@@ -53,10 +41,10 @@
}
int32_t offset = Offset::kHMetricsStart + (entry * Offset::kHMetricsSize) +
Offset::kHMetricsAdvanceWidth;
- return data_->readUShort(offset);
+ return data_->ReadUShort(offset);
}
-int32_t HorizontalMetricsTable::hMetricLSB(int32_t entry) {
+int32_t HorizontalMetricsTable::HMetricLSB(int32_t entry) {
if (entry > num_hmetrics_) {
#if defined (SFNTLY_NO_EXCEPTION)
return 0;
@@ -66,10 +54,10 @@
}
int32_t offset = Offset::kHMetricsStart + (entry * Offset::kHMetricsSize) +
Offset::kHMetricsLeftSideBearing;
- return data_->readShort(offset);
+ return data_->ReadShort(offset);
}
-int32_t HorizontalMetricsTable::lsbTableEntry(int32_t entry) {
+int32_t HorizontalMetricsTable::LsbTableEntry(int32_t entry) {
if (entry > num_hmetrics_) {
#if defined (SFNTLY_NO_EXCEPTION)
return 0;
@@ -79,62 +67,78 @@
}
int32_t offset = Offset::kHMetricsStart + (entry * Offset::kHMetricsSize) +
Offset::kLeftSideBearingSize;
- return data_->readShort(offset);
+ return data_->ReadShort(offset);
}
-int32_t HorizontalMetricsTable::advanceWidth(int32_t glyph_id) {
+int32_t HorizontalMetricsTable::AdvanceWidth(int32_t glyph_id) {
if (glyph_id < num_hmetrics_) {
- return hMetricAdvanceWidth(glyph_id);
+ return HMetricAdvanceWidth(glyph_id);
}
- return hMetricAdvanceWidth(glyph_id - num_hmetrics_);
+ return HMetricAdvanceWidth(glyph_id - num_hmetrics_);
+}
+
+HorizontalMetricsTable::HorizontalMetricsTable(Header* header,
+ ReadableFontData* data)
+ : Table(header, data) {
+}
+
+HorizontalMetricsTable::HorizontalMetricsTable(Header* header,
+ ReadableFontData* data,
+ int32_t num_hmetrics,
+ int32_t num_glyphs)
+ : Table(header, data),
+ num_hmetrics_(num_hmetrics),
+ num_glyphs_(num_glyphs) {
}
/******************************************************************************
* HorizontalMetricsTable::Builder class
******************************************************************************/
-void HorizontalMetricsTable::Builder::init() {
- num_hmetrics_ = -1;
- num_glyphs_ = -1;
+HorizontalMetricsTable::Builder::Builder(
+ FontDataTableBuilderContainer* font_builder,
+ Header* header,
+ WritableFontData* data)
+ : Table::TableBasedTableBuilder(font_builder, header, data) {
+ Init();
}
HorizontalMetricsTable::Builder::Builder(
- FontDataTableBuilderContainer* font_builder, Header* header,
- WritableFontData* data) :
- Table::TableBasedTableBuilder(font_builder, header, data) {
- init();
-}
-
-HorizontalMetricsTable::Builder::Builder(
- FontDataTableBuilderContainer* font_builder, Header* header,
- ReadableFontData* data) :
- Table::TableBasedTableBuilder(font_builder, header, data) {
- init();
+ FontDataTableBuilderContainer* font_builder,
+ Header* header,
+ ReadableFontData* data)
+ : Table::TableBasedTableBuilder(font_builder, header, data) {
+ Init();
}
HorizontalMetricsTable::Builder::~Builder() {}
-CALLER_ATTACH FontDataTable* HorizontalMetricsTable::Builder::subBuildTable(
- ReadableFontData* data) {
+CALLER_ATTACH FontDataTable*
+ HorizontalMetricsTable::Builder::SubBuildTable(ReadableFontData* data) {
FontDataTablePtr table =
new HorizontalMetricsTable(header(), data, num_hmetrics_, num_glyphs_);
- return table.detach();
+ return table.Detach();
}
-void HorizontalMetricsTable::Builder::setNumberOfHMetrics(
- int32_t num_hmetrics) {
+void HorizontalMetricsTable::Builder::SetNumberOfHMetrics(
+ int32_t num_hmetrics) {
assert(num_hmetrics >= 0);
num_hmetrics_ = num_hmetrics;
- HorizontalMetricsTable* table = down_cast<HorizontalMetricsTable*>(
- this->table());
+ HorizontalMetricsTable* table =
+ down_cast<HorizontalMetricsTable*>(this->GetTable());
table->num_hmetrics_ = num_hmetrics;
}
-void HorizontalMetricsTable::Builder::setNumGlyphs(int32_t num_glyphs) {
+void HorizontalMetricsTable::Builder::SetNumGlyphs(int32_t num_glyphs) {
assert(num_glyphs >= 0);
num_glyphs_ = num_glyphs;
- HorizontalMetricsTable* table = down_cast<HorizontalMetricsTable*>(
- this->table());
+ HorizontalMetricsTable* table =
+ down_cast<HorizontalMetricsTable*>(this->GetTable());
table->num_glyphs_ = num_glyphs;
}
+void HorizontalMetricsTable::Builder::Init() {
+ num_hmetrics_ = -1;
+ num_glyphs_ = -1;
+}
+
} // namespace sfntly
diff --git a/sfntly/horizontal_metrics_table.h b/sfntly/horizontal_metrics_table.h
index c393fee..aead6fa 100644
--- a/sfntly/horizontal_metrics_table.h
+++ b/sfntly/horizontal_metrics_table.h
@@ -23,6 +23,39 @@
class HorizontalMetricsTable : public Table,
public RefCounted<HorizontalMetricsTable> {
+ public:
+ class Builder : public Table::TableBasedTableBuilder,
+ public RefCounted<Builder> {
+ public:
+ // Constructor scope altered to public because C++ does not allow base
+ // class to instantiate derived class with protected constructors.
+ Builder(FontDataTableBuilderContainer* font_builder,
+ Header* header,
+ WritableFontData* data);
+ Builder(FontDataTableBuilderContainer* font_builder,
+ Header* header,
+ ReadableFontData* data);
+ virtual ~Builder();
+
+ virtual CALLER_ATTACH FontDataTable* SubBuildTable(ReadableFontData* data);
+ void SetNumberOfHMetrics(int32_t num_hmetrics);
+ void SetNumGlyphs(int32_t num_glyphs);
+
+ private:
+ void Init();
+
+ int32_t num_hmetrics_;
+ int32_t num_glyphs_;
+ };
+
+ virtual ~HorizontalMetricsTable();
+ int32_t NumberOfHMetrics();
+ int32_t NumberOfLSBs();
+ int32_t HMetricAdvanceWidth(int32_t entry);
+ int32_t HMetricLSB(int32_t entry);
+ int32_t LsbTableEntry(int32_t entry);
+ int32_t AdvanceWidth(int32_t glyph_id);
+
private:
struct Offset {
enum {
@@ -38,43 +71,12 @@
};
};
- private:
HorizontalMetricsTable(Header* header, ReadableFontData* data);
- HorizontalMetricsTable(Header* header, ReadableFontData* data,
- int32_t num_hmetrics, int32_t num_glyphs);
+ HorizontalMetricsTable(Header* header,
+ ReadableFontData* data,
+ int32_t num_hmetrics,
+ int32_t num_glyphs);
- public: // class is final, no virtual functions unless inherited from parent.
- virtual ~HorizontalMetricsTable();
- int32_t numberOfHMetrics();
- int32_t numberOfLSBs();
- int32_t hMetricAdvanceWidth(int32_t entry);
- int32_t hMetricLSB(int32_t entry);
- int32_t lsbTableEntry(int32_t entry);
- int32_t advanceWidth(int32_t glyph_id);
-
- public:
- class Builder : public Table::TableBasedTableBuilder,
- public RefCounted<Builder> {
- public:
- // Constructor scope altered to public because C++ does not allow base
- // class to instantiate derived class with protected constructors.
- Builder(FontDataTableBuilderContainer* font_builder, Header* header,
- WritableFontData* data);
- Builder(FontDataTableBuilderContainer* font_builder, Header* header,
- ReadableFontData* data);
- virtual ~Builder();
- void init();
-
- virtual CALLER_ATTACH FontDataTable* subBuildTable(ReadableFontData* data);
- void setNumberOfHMetrics(int32_t num_hmetrics);
- void setNumGlyphs(int32_t num_glyphs);
-
- private:
- int32_t num_hmetrics_;
- int32_t num_glyphs_;
- };
-
- private:
int32_t num_hmetrics_;
int32_t num_glyphs_;
};
diff --git a/sfntly/loca_table.cc b/sfntly/loca_table.cc
index 1cd1d92..e82f709 100644
--- a/sfntly/loca_table.cc
+++ b/sfntly/loca_table.cc
@@ -21,20 +21,13 @@
/******************************************************************************
* LocaTable class
******************************************************************************/
-LocaTable::LocaTable(Header* header, ReadableFontData* data)
- : Table(header, data) {}
-
-LocaTable::LocaTable(Header* header, ReadableFontData* data, int32_t version,
- int32_t num_glyphs)
- : Table(header, data), version_(version), num_glyphs_(num_glyphs) {}
-
LocaTable::~LocaTable() {}
-int32_t LocaTable::numGlyphs() {
+int32_t LocaTable::NumGlyphs() {
return num_glyphs_;
}
-int32_t LocaTable::glyphOffset(int32_t glyph_id) {
+int32_t LocaTable::GlyphOffset(int32_t glyph_id) {
if (glyph_id < 0 || glyph_id >= num_glyphs_) {
#if defined (SFNTLY_NO_EXCEPTION)
return 0;
@@ -42,10 +35,10 @@
throw IndexOutOfBoundException("Glyph ID is out of bounds.");
#endif
}
- return loca(glyph_id);
+ return Loca(glyph_id);
}
-int32_t LocaTable::glyphLength(int32_t glyph_id) {
+int32_t LocaTable::GlyphLength(int32_t glyph_id) {
if (glyph_id < 0 || glyph_id >= num_glyphs_) {
#if defined (SFNTLY_NO_EXCEPTION)
return 0;
@@ -53,14 +46,14 @@
throw IndexOutOfBoundException("Glyph ID is out of bounds.");
#endif
}
- return loca(glyph_id + 1) - loca(glyph_id);
+ return Loca(glyph_id + 1) - Loca(glyph_id);
}
-int32_t LocaTable::numLocas() {
+int32_t LocaTable::NumLocas() {
return num_glyphs_ + 1;
}
-int32_t LocaTable::loca(int32_t index) {
+int32_t LocaTable::Loca(int32_t index) {
if (index > num_glyphs_) {
#if defined (SFNTLY_NO_EXCEPTION)
return 0;
@@ -69,92 +62,73 @@
#endif
}
if (version_ == IndexToLocFormat::kShortOffset) {
- return 2 * data_->readShort(index * DataSize::kUSHORT);
+ return 2 * data_->ReadShort(index * DataSize::kUSHORT);
}
- return data_->readULongAsInt(index * DataSize::kULONG);
+ return data_->ReadULongAsInt(index * DataSize::kULONG);
+}
+
+LocaTable::LocaTable(Header* header, ReadableFontData* data)
+ : Table(header, data) {
+}
+
+LocaTable::LocaTable(Header* header,
+ ReadableFontData* data,
+ int32_t version,
+ int32_t num_glyphs)
+ : Table(header, data), version_(version), num_glyphs_(num_glyphs) {
}
/******************************************************************************
- * LocaTable::Builder class
+ * LocaTable::Iterator class
******************************************************************************/
-LocaTable::LocaIterator::LocaIterator(LocaTable* table) : index_(-1) {
+LocaTable::LocaIterator::LocaIterator(LocaTable* table)
+ : index_(-1) {
table_ = table;
}
-bool LocaTable::LocaIterator::hasNext() {
+bool LocaTable::LocaIterator::HasNext() {
return index_ <= table_->num_glyphs_;
}
-int32_t LocaTable::LocaIterator::next() {
- return table_->loca(index_++);
+int32_t LocaTable::LocaIterator::Next() {
+ return table_->Loca(index_++);
}
/******************************************************************************
* LocaTable::Builder class
******************************************************************************/
-void LocaTable::Builder::init() {
- num_glyphs_ = -1;
- format_version_ = IndexToLocFormat::kLongOffset;
-}
-
LocaTable::Builder::Builder(FontDataTableBuilderContainer* font_builder,
Header* header, WritableFontData* data) :
Table::ArrayElementTableBuilder(font_builder, header, data) {
- init();
+ Init();
}
LocaTable::Builder::Builder(FontDataTableBuilderContainer* font_builder,
Header* header, ReadableFontData* data) :
Table::ArrayElementTableBuilder(font_builder, header, data) {
- init();
+ Init();
}
LocaTable::Builder::~Builder() {}
-void LocaTable::Builder::initialize(ReadableFontData* data) {
- if (data) {
- if (numGlyphs() < 0) {
-#if defined (SFNTLY_NO_EXCEPTION)
- return;
-#else
- throw IllegalStateException("numglyphs not set on LocaTable Builder.");
-#endif
- }
- LocaTablePtr table =
- new LocaTable(header(), data, format_version_, num_glyphs_);
- LocaTable::LocaIterator loca_iter(table);
- while (loca_iter.hasNext()) {
- loca_.push_back(loca_iter.next());
- }
- }
-}
-
-IntegerList* LocaTable::Builder::getLocaList() {
- if (loca_.empty()) {
- initialize(internalReadData());
- setModelChanged();
- }
- return &loca_;
-}
-
-void LocaTable::Builder::setFormatVersion(int32_t format_version) {
+void LocaTable::Builder::SetFormatVersion(int32_t format_version) {
format_version_ = format_version;
}
-IntegerList* LocaTable::Builder::locaList() {
- return getLocaList();
+IntegerList* LocaTable::Builder::LocaList() {
+ return GetLocaList();
}
-void LocaTable::Builder::setLocaList(IntegerList* list) {
+void LocaTable::Builder::SetLocaList(IntegerList* list) {
loca_.clear();
if (list) {
loca_ = *list;
num_glyphs_ = loca_.size();
- setModelChanged();
+ set_model_changed();
}
}
-int32_t LocaTable::Builder::glyphOffset(int32_t glyph_id) {
+int32_t LocaTable::Builder::GlyphOffset(int32_t glyph_id) {
if (glyph_id < 0 || glyph_id > (num_glyphs_ + 1)) {
#if defined (SFNTLY_NO_EXCEPTION)
return 0;
@@ -162,10 +136,10 @@
throw IndexOutOfBoundException("Glyph ID is out of bounds.");
#endif
}
- return loca(glyph_id);
+ return Loca(glyph_id);
}
-int32_t LocaTable::Builder::glyphLength(int32_t glyph_id) {
+int32_t LocaTable::Builder::GlyphLength(int32_t glyph_id) {
if (glyph_id < 0 || glyph_id > (num_glyphs_ + 1)) {
#if defined (SFNTLY_NO_EXCEPTION)
return 0;
@@ -173,49 +147,49 @@
throw IndexOutOfBoundException("Glyph ID is out of bounds.");
#endif
}
- return loca(glyph_id + 1) - loca(glyph_id);
+ return Loca(glyph_id + 1) - Loca(glyph_id);
}
-void LocaTable::Builder::setNumGlyphs(int32_t num_glyphs) {
+void LocaTable::Builder::SetNumGlyphs(int32_t num_glyphs) {
num_glyphs_ = num_glyphs;
}
-int32_t LocaTable::Builder::numGlyphs() {
+int32_t LocaTable::Builder::NumGlyphs() {
if (!loca_.empty()) {
return loca_.size() - 1;
}
return num_glyphs_;
}
-void LocaTable::Builder::revert() {
+void LocaTable::Builder::Revert() {
loca_.clear();
- setModelChanged(false);
+ set_model_changed(false);
}
-void LocaTable::Builder::clear() {
- getLocaList()->clear();
+void LocaTable::Builder::Clear() {
+ GetLocaList()->clear();
}
-int32_t LocaTable::Builder::numLocas() {
- return getLocaList()->size();
+int32_t LocaTable::Builder::NumLocas() {
+ return GetLocaList()->size();
}
-int32_t LocaTable::Builder::loca(int32_t index) {
- return getLocaList()->at(index);
+int32_t LocaTable::Builder::Loca(int32_t index) {
+ return GetLocaList()->at(index);
}
-CALLER_ATTACH FontDataTable* LocaTable::Builder::subBuildTable(
+CALLER_ATTACH FontDataTable* LocaTable::Builder::SubBuildTable(
ReadableFontData* data) {
FontDataTablePtr table =
new LocaTable(header(), data, format_version_, num_glyphs_);
- return table.detach();
+ return table.Detach();
}
-void LocaTable::Builder::subDataSet() {
- initialize(internalReadData());
+void LocaTable::Builder::SubDataSet() {
+ Initialize(InternalReadData());
}
-int32_t LocaTable::Builder::subDataSizeToSerialize() {
+int32_t LocaTable::Builder::SubDataSizeToSerialize() {
if (loca_.empty()) {
return 0;
}
@@ -225,21 +199,52 @@
return loca_.size() * DataSize::kUSHORT;
}
-bool LocaTable::Builder::subReadyToSerialize() {
+bool LocaTable::Builder::SubReadyToSerialize() {
return !loca_.empty();
}
-int32_t LocaTable::Builder::subSerialize(WritableFontData* new_data) {
+int32_t LocaTable::Builder::SubSerialize(WritableFontData* new_data) {
int32_t size = 0;
for (IntegerList::iterator l = loca_.begin(), end = loca_.end();
l != end; ++l) {
if (format_version_ == IndexToLocFormat::kLongOffset) {
- size += new_data->writeULong(size, *l);
+ size += new_data->WriteULong(size, *l);
} else {
- size += new_data->writeUShort(size, *l / 2);
+ size += new_data->WriteUShort(size, *l / 2);
}
}
return 0;
}
+void LocaTable::Builder::Init() {
+ num_glyphs_ = -1;
+ format_version_ = IndexToLocFormat::kLongOffset;
+}
+
+void LocaTable::Builder::Initialize(ReadableFontData* data) {
+ if (data) {
+ if (NumGlyphs() < 0) {
+#if defined (SFNTLY_NO_EXCEPTION)
+ return;
+#else
+ throw IllegalStateException("numglyphs not set on LocaTable Builder.");
+#endif
+ }
+ LocaTablePtr table =
+ new LocaTable(header(), data, format_version_, num_glyphs_);
+ LocaTable::LocaIterator loca_iter(table);
+ while (loca_iter.HasNext()) {
+ loca_.push_back(loca_iter.Next());
+ }
+ }
+}
+
+IntegerList* LocaTable::Builder::GetLocaList() {
+ if (loca_.empty()) {
+ Initialize(InternalReadData());
+ set_model_changed();
+ }
+ return &loca_;
+}
+
} // namespace sfntly
diff --git a/sfntly/loca_table.h b/sfntly/loca_table.h
index 741cb56..dcf9715 100644
--- a/sfntly/loca_table.h
+++ b/sfntly/loca_table.h
@@ -23,50 +23,19 @@
namespace sfntly {
class LocaTable : public Table, public RefCounted<LocaTable> {
- private:
- LocaTable(Header* header, ReadableFontData* data);
- LocaTable(Header* header, ReadableFontData* data, int32_t version,
- int32_t num_glyphs);
-
- public: // class is final, no virtual unless inherited from parents.
- virtual ~LocaTable();
- int32_t numGlyphs();
-
- // Return the offset for the given glyph id. Valid glyph ids are from 0 to the
- // one less than the number of glyphs. The zero entry is the special entry for
- // the notdef glyph. The final entry beyond the last glyph id is used to
- // calculate the size of the last glyph.
- // @param glyphId the glyph id to get the offset for; must be less than or
- // equal to one more than the number of glyph ids
- // @return the offset in the glyph table to the specified glyph id
- int32_t glyphOffset(int32_t glyph_id);
-
- // Get the length of the data in the glyph table for the specified glyph id.
- int32_t glyphLength(int32_t glyph_id);
-
- // Get the number of locations or locas. This will be one more than the number
- // of glyphs for this table since the last loca position is used to indicate
- // the size of the final glyph.
- int32_t numLocas();
-
- // Get the value from the loca table for the index specified. Valid index
- // values run from 0 to the number of glyphs in the font.
- int32_t loca(int32_t index);
-
public:
// Note: different implementation than Java, caller to instantiate this class
// object directly from stack instead of calling LocaTable::iterator().
class LocaIterator {
public:
explicit LocaIterator(LocaTable* table);
- bool hasNext();
- int32_t next();
+ bool HasNext();
+ int32_t Next();
private:
int32_t index_;
LocaTable* table_; // use dumb pointer since it's a composition object
};
- friend class LocaIterator;
class Builder : public Table::ArrayElementTableBuilder,
public RefCounted<Builder> {
@@ -78,21 +47,15 @@
ReadableFontData* data);
virtual ~Builder();
- private:
- void init(); // short hand for common code in ctors, C++ port only
- void initialize(ReadableFontData* data); // ported from Java
- IntegerList* getLocaList();
-
- public: // static class, no virtual function unless inherited from parent.
- void setFormatVersion(int32_t format_version);
+ void SetFormatVersion(int32_t format_version);
// Gets the List of locas for loca table builder. These may be manipulated
// in any way by the caller and the changes will be reflected in the final
// loca table produced.
// If there is no current data for the loca table builder or the loca list
// have not been previously set then this will return an empty List.
- IntegerList* locaList();
- void setLocaList(IntegerList* list);
+ IntegerList* LocaList();
+ void SetLocaList(IntegerList* list);
// Return the offset for the given glyph id. Valid glyph ids are from 0 to
// one less than the number of glyphs. The zero entry is the special entry
@@ -101,43 +64,79 @@
// @param glyphId the glyph id to get the offset for; must be less than or
// equal to one more than the number of glyph ids
// @return the offset in the glyph table to the specified glyph id
- int32_t glyphOffset(int32_t glyph_id);
+ int32_t GlyphOffset(int32_t glyph_id);
// Get the length of the data in the glyph table for the specified glyph id.
- int32_t glyphLength(int32_t glyph_id);
+ int32_t GlyphLength(int32_t glyph_id);
// Set the number of glyphs.
// This method sets the number of glyphs that the builder will attempt to
// parse location data for from the raw binary data. This method only needs
// to be called (and <b>must</b> be) when the raw data for this builder has
// been changed.
- void setNumGlyphs(int32_t num_glyphs);
- int numGlyphs();
+ void SetNumGlyphs(int32_t num_glyphs);
+ int NumGlyphs();
- void revert();
- void clear();
+ void Revert();
+ void Clear();
// Get the number of locations or locas. This will be one more than the
// number of glyphs for this table since the last loca position is used to
// indicate the size of the final glyph.
- int32_t numLocas();
- int32_t loca(int32_t index);
+ int32_t NumLocas();
+ int32_t Loca(int32_t index);
- virtual CALLER_ATTACH FontDataTable* subBuildTable(ReadableFontData* data);
- virtual void subDataSet();
- virtual int32_t subDataSizeToSerialize();
- virtual bool subReadyToSerialize();
- virtual int32_t subSerialize(WritableFontData* new_data);
+ 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 Init(); // short hand for common code in ctors, C++ port only
+ void Initialize(ReadableFontData* data); // ported from Java
+ IntegerList* GetLocaList();
+
int32_t format_version_; // Note: IndexToLocFormat
int32_t num_glyphs_;
IntegerList loca_;
};
+ virtual ~LocaTable();
+ int32_t NumGlyphs();
+
+ // Return the offset for the given glyph id. Valid glyph ids are from 0 to the
+ // one less than the number of glyphs. The zero entry is the special entry for
+ // the notdef glyph. The final entry beyond the last glyph id is used to
+ // calculate the size of the last glyph.
+ // @param glyphId the glyph id to get the offset for; must be less than or
+ // equal to one more than the number of glyph ids
+ // @return the offset in the glyph table to the specified glyph id
+ int32_t GlyphOffset(int32_t glyph_id);
+
+ // Get the length of the data in the glyph table for the specified glyph id.
+ int32_t GlyphLength(int32_t glyph_id);
+
+ // Get the number of locations or locas. This will be one more than the number
+ // of glyphs for this table since the last loca position is used to indicate
+ // the size of the final glyph.
+ int32_t NumLocas();
+
+ // Get the value from the loca table for the index specified. Valid index
+ // values run from 0 to the number of glyphs in the font.
+ int32_t Loca(int32_t index);
+
private:
+ LocaTable(Header* header, ReadableFontData* data);
+ LocaTable(Header* header,
+ ReadableFontData* data,
+ int32_t version,
+ int32_t num_glyphs);
+
int32_t version_; // Note: IndexToLocFormat
int32_t num_glyphs_;
+
+ friend class LocaIterator;
};
typedef Ptr<LocaTable> LocaTablePtr;
typedef Ptr<LocaTable::Builder> LocaTableBuilderPtr;
diff --git a/sfntly/math/fixed1616.h b/sfntly/math/fixed1616.h
index aa3a62b..843da51 100644
--- a/sfntly/math/fixed1616.h
+++ b/sfntly/math/fixed1616.h
@@ -23,15 +23,15 @@
class Fixed1616 {
public:
- static inline int32_t integral(int32_t fixed) {
+ static inline int32_t Integral(int32_t fixed) {
return (fixed >> 16);
}
- static inline int32_t fractional(int32_t fixed) {
+ static inline int32_t Fractional(int32_t fixed) {
return (fixed & 0xffff);
}
- static inline int32_t fixed(int32_t integral, int32_t fractional) {
+ static inline int32_t Fixed(int32_t integral, int32_t fractional) {
return ((integral & 0xffff) << 16) | (fractional & 0xffff);
}
};
diff --git a/sfntly/math/font_math.h b/sfntly/math/font_math.h
index 78b9e51..f15a786 100644
--- a/sfntly/math/font_math.h
+++ b/sfntly/math/font_math.h
@@ -23,7 +23,7 @@
class FontMath {
public:
- static int32_t log2(int32_t a) {
+ static int32_t Log2(int32_t a) {
int r = 0; // r will be lg(a)
while (a != 0) {
a >>= 1;
diff --git a/sfntly/maximum_profile_table.cc b/sfntly/maximum_profile_table.cc
index 61a176e..0ab2aaf 100644
--- a/sfntly/maximum_profile_table.cc
+++ b/sfntly/maximum_profile_table.cc
@@ -20,202 +20,204 @@
/******************************************************************************
* MaximumProfileTable class
******************************************************************************/
-MaximumProfileTable::MaximumProfileTable(Header* header,
- ReadableFontData* data) :
- Table(header, data) {
-}
-
MaximumProfileTable::~MaximumProfileTable() {}
-int32_t MaximumProfileTable::version() {
- return data_->readFixed(Offset::kVersion);
+int32_t MaximumProfileTable::Version() {
+ return data_->ReadFixed(Offset::kVersion);
}
-int32_t MaximumProfileTable::numGlyphs() {
- return data_->readUShort(Offset::kNumGlyphs);
+int32_t MaximumProfileTable::NumGlyphs() {
+ return data_->ReadUShort(Offset::kNumGlyphs);
}
-int32_t MaximumProfileTable::maxPoints() {
- return data_->readUShort(Offset::kMaxPoints);
+int32_t MaximumProfileTable::MaxPoints() {
+ return data_->ReadUShort(Offset::kMaxPoints);
}
-int32_t MaximumProfileTable::maxContours() {
- return data_->readUShort(Offset::kMaxContours);
+int32_t MaximumProfileTable::MaxContours() {
+ return data_->ReadUShort(Offset::kMaxContours);
}
-int32_t MaximumProfileTable::maxCompositePoints() {
- return data_->readUShort(Offset::kMaxCompositePoints);
+int32_t MaximumProfileTable::MaxCompositePoints() {
+ return data_->ReadUShort(Offset::kMaxCompositePoints);
}
-int32_t MaximumProfileTable::maxZones() {
- return data_->readUShort(Offset::kMaxZones);
+int32_t MaximumProfileTable::MaxZones() {
+ return data_->ReadUShort(Offset::kMaxZones);
}
-int32_t MaximumProfileTable::maxTwilightPoints() {
- return data_->readUShort(Offset::kMaxTwilightPoints);
+int32_t MaximumProfileTable::MaxTwilightPoints() {
+ return data_->ReadUShort(Offset::kMaxTwilightPoints);
}
-int32_t MaximumProfileTable::maxStorage() {
- return data_->readUShort(Offset::kMaxStorage);
+int32_t MaximumProfileTable::MaxStorage() {
+ return data_->ReadUShort(Offset::kMaxStorage);
}
-int32_t MaximumProfileTable::maxFunctionDefs() {
- return data_->readUShort(Offset::kMaxFunctionDefs);
+int32_t MaximumProfileTable::MaxFunctionDefs() {
+ return data_->ReadUShort(Offset::kMaxFunctionDefs);
}
-int32_t MaximumProfileTable::maxStackElements() {
- return data_->readUShort(Offset::kMaxStackElements);
+int32_t MaximumProfileTable::MaxStackElements() {
+ return data_->ReadUShort(Offset::kMaxStackElements);
}
-int32_t MaximumProfileTable::maxSizeOfInstructions() {
- return data_->readUShort(Offset::kMaxSizeOfInstructions);
+int32_t MaximumProfileTable::MaxSizeOfInstructions() {
+ return data_->ReadUShort(Offset::kMaxSizeOfInstructions);
}
-int32_t MaximumProfileTable::maxComponentElements() {
- return data_->readUShort(Offset::kMaxComponentElements);
+int32_t MaximumProfileTable::MaxComponentElements() {
+ return data_->ReadUShort(Offset::kMaxComponentElements);
}
-int32_t MaximumProfileTable::maxComponentDepth() {
- return data_->readUShort(Offset::kMaxComponentDepth);
+int32_t MaximumProfileTable::MaxComponentDepth() {
+ return data_->ReadUShort(Offset::kMaxComponentDepth);
+}
+
+MaximumProfileTable::MaximumProfileTable(Header* header,
+ ReadableFontData* data)
+ : Table(header, data) {
}
/******************************************************************************
* MaximumProfileTable::Builder class
******************************************************************************/
MaximumProfileTable::Builder::Builder(
- FontDataTableBuilderContainer* font_builder, Header* header,
- WritableFontData* data) :
- Table::TableBasedTableBuilder(font_builder, header, data) {
+ FontDataTableBuilderContainer* font_builder,
+ Header* header,
+ WritableFontData* data)
+ : Table::TableBasedTableBuilder(font_builder, header, data) {
}
MaximumProfileTable::Builder::Builder(
- FontDataTableBuilderContainer* font_builder, Header* header,
- ReadableFontData* data) :
- Table::TableBasedTableBuilder(font_builder, header, data) {
+ FontDataTableBuilderContainer* font_builder,
+ Header* header,
+ ReadableFontData* data)
+ : Table::TableBasedTableBuilder(font_builder, header, data) {
}
MaximumProfileTable::Builder::~Builder() {}
-CALLER_ATTACH FontDataTable* MaximumProfileTable::Builder::subBuildTable(
- ReadableFontData* data) {
+CALLER_ATTACH FontDataTable*
+ MaximumProfileTable::Builder::SubBuildTable(ReadableFontData* data) {
FontDataTablePtr table = new MaximumProfileTable(header(), data);
- return table.detach();
+ return table.Detach();
}
-int32_t MaximumProfileTable::Builder::version() {
- return internalReadData()->readUShort(Offset::kVersion);
+int32_t MaximumProfileTable::Builder::Version() {
+ return InternalReadData()->ReadUShort(Offset::kVersion);
}
-void MaximumProfileTable::Builder::setVersion(int32_t version) {
- internalWriteData()->writeUShort(Offset::kVersion, version);
+void MaximumProfileTable::Builder::SetVersion(int32_t version) {
+ InternalWriteData()->WriteUShort(Offset::kVersion, version);
}
-int32_t MaximumProfileTable::Builder::numGlyphs() {
- return internalReadData()->readUShort(Offset::kNumGlyphs);
+int32_t MaximumProfileTable::Builder::NumGlyphs() {
+ return InternalReadData()->ReadUShort(Offset::kNumGlyphs);
}
-void MaximumProfileTable::Builder::setNumGlyphs(int32_t num_glyphs) {
- internalWriteData()->writeUShort(Offset::kNumGlyphs, num_glyphs);
+void MaximumProfileTable::Builder::SetNumGlyphs(int32_t num_glyphs) {
+ InternalWriteData()->WriteUShort(Offset::kNumGlyphs, num_glyphs);
}
-int32_t MaximumProfileTable::Builder::maxPoints() {
- return internalReadData()->readUShort(Offset::kMaxPoints);
+int32_t MaximumProfileTable::Builder::MaxPoints() {
+ return InternalReadData()->ReadUShort(Offset::kMaxPoints);
}
-void MaximumProfileTable::Builder::setMaxPoints(int32_t max_points) {
- internalWriteData()->writeUShort(Offset::kMaxPoints, max_points);
+void MaximumProfileTable::Builder::SetMaxPoints(int32_t max_points) {
+ InternalWriteData()->WriteUShort(Offset::kMaxPoints, max_points);
}
-int32_t MaximumProfileTable::Builder::maxContours() {
- return internalReadData()->readUShort(Offset::kMaxContours);
+int32_t MaximumProfileTable::Builder::MaxContours() {
+ return InternalReadData()->ReadUShort(Offset::kMaxContours);
}
-void MaximumProfileTable::Builder::setMaxContours(int32_t max_contours) {
- internalWriteData()->writeUShort(Offset::kMaxContours, max_contours);
+void MaximumProfileTable::Builder::SetMaxContours(int32_t max_contours) {
+ InternalWriteData()->WriteUShort(Offset::kMaxContours, max_contours);
}
-int32_t MaximumProfileTable::Builder::maxCompositePoints() {
- return internalReadData()->readUShort(Offset::kMaxCompositePoints);
+int32_t MaximumProfileTable::Builder::MaxCompositePoints() {
+ return InternalReadData()->ReadUShort(Offset::kMaxCompositePoints);
}
-void MaximumProfileTable::Builder::setMaxCompositePoints(
+void MaximumProfileTable::Builder::SetMaxCompositePoints(
int32_t max_composite_points) {
- internalWriteData()->writeUShort(Offset::kMaxCompositePoints,
+ InternalWriteData()->WriteUShort(Offset::kMaxCompositePoints,
max_composite_points);
}
-int32_t MaximumProfileTable::Builder::maxZones() {
- return internalReadData()->readUShort(Offset::kMaxZones);
+int32_t MaximumProfileTable::Builder::MaxZones() {
+ return InternalReadData()->ReadUShort(Offset::kMaxZones);
}
-void MaximumProfileTable::Builder::setMaxZones(int32_t max_zones) {
- internalWriteData()->writeUShort(Offset::kMaxZones, max_zones);
+void MaximumProfileTable::Builder::SetMaxZones(int32_t max_zones) {
+ InternalWriteData()->WriteUShort(Offset::kMaxZones, max_zones);
}
-int32_t MaximumProfileTable::Builder::maxTwilightPoints() {
- return internalReadData()->readUShort(Offset::kMaxTwilightPoints);
+int32_t MaximumProfileTable::Builder::MaxTwilightPoints() {
+ return InternalReadData()->ReadUShort(Offset::kMaxTwilightPoints);
}
-void MaximumProfileTable::Builder::setMaxTwilightPoints(
+void MaximumProfileTable::Builder::SetMaxTwilightPoints(
int32_t max_twilight_points) {
- internalWriteData()->writeUShort(Offset::kMaxTwilightPoints,
+ InternalWriteData()->WriteUShort(Offset::kMaxTwilightPoints,
max_twilight_points);
}
-int32_t MaximumProfileTable::Builder::maxStorage() {
- return internalReadData()->readUShort(Offset::kMaxStorage);
+int32_t MaximumProfileTable::Builder::MaxStorage() {
+ return InternalReadData()->ReadUShort(Offset::kMaxStorage);
}
-void MaximumProfileTable::Builder::setMaxStorage(int32_t max_storage) {
- internalWriteData()->writeUShort(Offset::kMaxStorage, max_storage);
+void MaximumProfileTable::Builder::SetMaxStorage(int32_t max_storage) {
+ InternalWriteData()->WriteUShort(Offset::kMaxStorage, max_storage);
}
-int32_t MaximumProfileTable::Builder::maxFunctionDefs() {
- return internalReadData()->readUShort(Offset::kMaxFunctionDefs);
+int32_t MaximumProfileTable::Builder::MaxFunctionDefs() {
+ return InternalReadData()->ReadUShort(Offset::kMaxFunctionDefs);
}
-void MaximumProfileTable::Builder::setMaxFunctionDefs(
+void MaximumProfileTable::Builder::SetMaxFunctionDefs(
int32_t max_function_defs) {
- internalWriteData()->writeUShort(Offset::kMaxFunctionDefs, max_function_defs);
+ InternalWriteData()->WriteUShort(Offset::kMaxFunctionDefs, max_function_defs);
}
-int32_t MaximumProfileTable::Builder::maxStackElements() {
- return internalReadData()->readUShort(Offset::kMaxStackElements);
+int32_t MaximumProfileTable::Builder::MaxStackElements() {
+ return InternalReadData()->ReadUShort(Offset::kMaxStackElements);
}
-void MaximumProfileTable::Builder::setMaxStackElements(
+void MaximumProfileTable::Builder::SetMaxStackElements(
int32_t max_stack_elements) {
- internalWriteData()->writeUShort(Offset::kMaxStackElements,
+ InternalWriteData()->WriteUShort(Offset::kMaxStackElements,
max_stack_elements);
}
-int32_t MaximumProfileTable::Builder::maxSizeOfInstructions() {
- return internalReadData()->readUShort(Offset::kMaxSizeOfInstructions);
+int32_t MaximumProfileTable::Builder::MaxSizeOfInstructions() {
+ return InternalReadData()->ReadUShort(Offset::kMaxSizeOfInstructions);
}
-void MaximumProfileTable::Builder::setMaxSizeOfInstructions(
+void MaximumProfileTable::Builder::SetMaxSizeOfInstructions(
int32_t max_size_of_instructions) {
- internalWriteData()->writeUShort(Offset::kMaxSizeOfInstructions,
+ InternalWriteData()->WriteUShort(Offset::kMaxSizeOfInstructions,
max_size_of_instructions);
}
-int32_t MaximumProfileTable::Builder::maxComponentElements() {
- return internalReadData()->readUShort(Offset::kMaxComponentElements);
+int32_t MaximumProfileTable::Builder::MaxComponentElements() {
+ return InternalReadData()->ReadUShort(Offset::kMaxComponentElements);
}
-void MaximumProfileTable::Builder::setMaxComponentElements(
+void MaximumProfileTable::Builder::SetMaxComponentElements(
int32_t max_component_elements) {
- internalWriteData()->writeUShort(Offset::kMaxComponentElements,
+ InternalWriteData()->WriteUShort(Offset::kMaxComponentElements,
max_component_elements);
}
-int32_t MaximumProfileTable::Builder::maxComponentDepth() {
- return internalReadData()->readUShort(Offset::kMaxComponentDepth);
+int32_t MaximumProfileTable::Builder::MaxComponentDepth() {
+ return InternalReadData()->ReadUShort(Offset::kMaxComponentDepth);
}
-void MaximumProfileTable::Builder::setMaxComponentDepth(
+void MaximumProfileTable::Builder::SetMaxComponentDepth(
int32_t max_component_depth) {
- internalWriteData()->writeUShort(Offset::kMaxComponentDepth,
+ InternalWriteData()->WriteUShort(Offset::kMaxComponentDepth,
max_component_depth);
}
diff --git a/sfntly/maximum_profile_table.h b/sfntly/maximum_profile_table.h
index 044eccf..9e0d0a6 100644
--- a/sfntly/maximum_profile_table.h
+++ b/sfntly/maximum_profile_table.h
@@ -24,6 +24,63 @@
class MaximumProfileTable : public Table,
public RefCounted<MaximumProfileTable> {
+ public:
+ class Builder : public Table::TableBasedTableBuilder,
+ public RefCounted<Builder> {
+ public:
+ // Constructor scope altered to public because C++ does not allow base
+ // class to instantiate derived class with protected constructors.
+ Builder(FontDataTableBuilderContainer* font_builder, Header* header,
+ WritableFontData* data);
+ Builder(FontDataTableBuilderContainer* font_builder, Header* header,
+ ReadableFontData* data);
+ virtual ~Builder();
+
+ virtual CALLER_ATTACH FontDataTable* SubBuildTable(ReadableFontData* data);
+
+ int32_t Version();
+ void SetVersion(int32_t version);
+ int32_t NumGlyphs();
+ void SetNumGlyphs(int32_t num_glyphs);
+ int32_t MaxPoints();
+ void SetMaxPoints(int32_t max_points);
+ int32_t MaxContours();
+ void SetMaxContours(int32_t max_contours);
+ int32_t MaxCompositePoints();
+ void SetMaxCompositePoints(int32_t max_composite_points);
+ int32_t MaxZones();
+ void SetMaxZones(int32_t max_zones);
+ int32_t MaxTwilightPoints();
+ void SetMaxTwilightPoints(int32_t max_twilight_points);
+ int32_t MaxStorage();
+ void SetMaxStorage(int32_t max_storage);
+ int32_t MaxFunctionDefs();
+ void SetMaxFunctionDefs(int32_t max_function_defs);
+ int32_t MaxStackElements();
+ void SetMaxStackElements(int32_t max_stack_elements);
+ int32_t MaxSizeOfInstructions();
+ void SetMaxSizeOfInstructions(int32_t max_size_of_instructions);
+ int32_t MaxComponentElements();
+ void SetMaxComponentElements(int32_t max_component_elements);
+ int32_t MaxComponentDepth();
+ void SetMaxComponentDepth(int32_t max_component_depth);
+ };
+
+ virtual ~MaximumProfileTable();
+ int32_t Version();
+ int32_t NumGlyphs();
+ int32_t MaxPoints();
+ int32_t MaxContours();
+ int32_t MaxCompositePoints();
+ int32_t MaxZones();
+ int32_t MaxTwilightPoints();
+ int32_t MaxStorage();
+ int32_t MaxFunctionDefs();
+ int32_t MaxStackElements();
+ int32_t MaxSizeOfInstructions();
+ int32_t MaxComponentElements();
+ int32_t MaxComponentDepth();
+
private:
struct Offset {
enum {
@@ -48,67 +105,7 @@
};
};
- private:
MaximumProfileTable(Header* header, ReadableFontData* data);
-
- public: // Class is final, no virtual functions unless derived from parent.
- virtual ~MaximumProfileTable();
- int32_t version();
- int32_t numGlyphs();
- int32_t maxPoints();
- int32_t maxContours();
- int32_t maxCompositePoints();
- int32_t maxZones();
- int32_t maxTwilightPoints();
- int32_t maxStorage();
- int32_t maxFunctionDefs();
- int32_t maxStackElements();
- int32_t maxSizeOfInstructions();
- int32_t maxComponentElements();
- int32_t maxComponentDepth();
-
- public:
- class Builder : public Table::TableBasedTableBuilder,
- public RefCounted<Builder> {
- public:
- // Constructor scope altered to public because C++ does not allow base
- // class to instantiate derived class with protected constructors.
- Builder(FontDataTableBuilderContainer* font_builder, Header* header,
- WritableFontData* data);
- Builder(FontDataTableBuilderContainer* font_builder, Header* header,
- ReadableFontData* data);
- virtual ~Builder();
-
- virtual CALLER_ATTACH FontDataTable* subBuildTable(ReadableFontData* data);
-
- public: // Class is static, no virtual functions unless derived from parent.
- int32_t version();
- void setVersion(int32_t version);
- int32_t numGlyphs();
- void setNumGlyphs(int32_t num_glyphs);
- int32_t maxPoints();
- void setMaxPoints(int32_t max_points);
- int32_t maxContours();
- void setMaxContours(int32_t max_contours);
- int32_t maxCompositePoints();
- void setMaxCompositePoints(int32_t max_composite_points);
- int32_t maxZones();
- void setMaxZones(int32_t max_zones);
- int32_t maxTwilightPoints();
- void setMaxTwilightPoints(int32_t max_twilight_points);
- int32_t maxStorage();
- void setMaxStorage(int32_t max_storage);
- int32_t maxFunctionDefs();
- void setMaxFunctionDefs(int32_t max_function_defs);
- int32_t maxStackElements();
- void setMaxStackElements(int32_t max_stack_elements);
- int32_t maxSizeOfInstructions();
- void setMaxSizeOfInstructions(int32_t max_size_of_instructions);
- int32_t maxComponentElements();
- void setMaxComponentElements(int32_t max_component_elements);
- int32_t maxComponentDepth();
- void setMaxComponentDepth(int32_t max_component_depth);
- };
};
typedef Ptr<MaximumProfileTable> MaximumProfileTablePtr;
typedef Ptr<MaximumProfileTable::Builder> MaximumProfileTableBuilderPtr;
diff --git a/sfntly/name_table.cc b/sfntly/name_table.cc
index 0858603..19c299c 100644
--- a/sfntly/name_table.cc
+++ b/sfntly/name_table.cc
@@ -14,142 +14,558 @@
* limitations under the License.
*/
-#include "port/type.h"
+#include "sfntly/name_table.h"
#include <stdio.h>
#include <string.h>
#include <unicode/unistr.h>
-#include "sfntly/name_table.h"
#include "sfntly/font.h"
#include "sfntly/port/exception_type.h"
namespace sfntly {
/******************************************************************************
+ * NameTable::NameEntryId class
+ ******************************************************************************/
+NameTable::NameEntryId::NameEntryId()
+ : platform_id_(0),
+ encoding_id_(0),
+ language_id_(0),
+ name_id_(0) {
+}
+
+NameTable::NameEntryId::NameEntryId(int32_t platform_id,
+ int32_t encoding_id,
+ int32_t language_id,
+ int32_t name_id)
+ : platform_id_(platform_id),
+ encoding_id_(encoding_id),
+ language_id_(language_id),
+ name_id_(name_id) {
+}
+
+NameTable::NameEntryId::NameEntryId(const NameTable::NameEntryId& rhs) {
+ *this = rhs;
+}
+
+const NameTable::NameEntryId&
+ NameTable::NameEntryId::operator=(const NameTable::NameEntryId& rhs) const {
+ platform_id_ = rhs.platform_id_;
+ encoding_id_ = rhs.encoding_id_;
+ language_id_ = rhs.language_id_;
+ name_id_ = rhs.name_id_;
+ return *this;
+}
+
+bool NameTable::NameEntryId::operator==(const NameEntryId& rhs) const {
+ return platform_id_ == rhs.platform_id_ &&
+ encoding_id_ == rhs.encoding_id_ &&
+ language_id_ == rhs.language_id_ &&
+ name_id_ == rhs.name_id_;
+}
+
+bool NameTable::NameEntryId::operator<(const NameEntryId& rhs) const {
+ if (platform_id_ != rhs.platform_id_) return platform_id_ < rhs.platform_id_;
+ if (encoding_id_ != rhs.encoding_id_) return encoding_id_ < rhs.encoding_id_;
+ if (language_id_ != rhs.language_id_) return language_id_ < rhs.language_id_;
+ return name_id_ < rhs.name_id_;
+}
+
+/******************************************************************************
+ * NameTable::NameEntry class
+ ******************************************************************************/
+NameTable::NameEntry::NameEntry() {
+ Init(0, 0, 0, 0, NULL);
+}
+
+NameTable::NameEntry::NameEntry(const NameEntryId& name_entry_id,
+ const ByteVector& name_bytes) {
+ Init(name_entry_id.platform_id(),
+ name_entry_id.encoding_id(),
+ name_entry_id.language_id(),
+ name_entry_id.name_id(),
+ &name_bytes);
+}
+
+NameTable::NameEntry::NameEntry(int32_t platform_id,
+ int32_t encoding_id,
+ int32_t language_id,
+ int32_t name_id,
+ const ByteVector& name_bytes) {
+ Init(platform_id, encoding_id, language_id, name_id, &name_bytes);
+}
+
+NameTable::NameEntry::~NameEntry() {}
+
+ByteVector* NameTable::NameEntry::NameAsBytes() {
+ return &name_bytes_;
+}
+
+int32_t NameTable::NameEntry::NameBytesLength() {
+ return name_bytes_.size();
+}
+
+UChar* NameTable::NameEntry::Name() {
+ return NameTable::ConvertFromNameBytes(&name_bytes_,
+ platform_id(),
+ encoding_id());
+}
+
+bool NameTable::NameEntry::operator==(const NameEntry& rhs) const {
+ return (name_entry_id_ == rhs.name_entry_id_ &&
+ name_bytes_ == rhs.name_bytes_);
+}
+
+void NameTable::NameEntry::Init(int32_t platform_id,
+ int32_t encoding_id,
+ int32_t language_id,
+ int32_t name_id,
+ const ByteVector* name_bytes) {
+ name_entry_id_ = NameEntryId(platform_id, encoding_id, language_id, name_id);
+ if (name_bytes) {
+ name_bytes_ = *name_bytes;
+ } else {
+ name_bytes_.clear();
+ }
+}
+
+/******************************************************************************
+ * NameTable::NameEntryBuilder class
+ ******************************************************************************/
+NameTable::NameEntryBuilder::NameEntryBuilder() {
+ Init(0, 0, 0, 0, NULL);
+}
+
+NameTable::NameEntryBuilder::NameEntryBuilder(
+ const NameEntryId& name_entry_id, const ByteVector& name_bytes) {
+ Init(name_entry_id.platform_id(),
+ name_entry_id.encoding_id(),
+ name_entry_id.language_id(),
+ name_entry_id.name_id(),
+ &name_bytes);
+}
+
+NameTable::NameEntryBuilder::NameEntryBuilder(
+ const NameEntryId& name_entry_id) {
+ Init(name_entry_id.platform_id(),
+ name_entry_id.encoding_id(),
+ name_entry_id.language_id(),
+ name_entry_id.name_id(),
+ NULL);
+}
+
+NameTable::NameEntryBuilder::NameEntryBuilder(NameEntry* b) {
+ Init(b->platform_id(),
+ b->encoding_id(),
+ b->language_id(),
+ b->name_id(),
+ b->NameAsBytes());
+}
+
+NameTable::NameEntryBuilder::~NameEntryBuilder() {}
+
+void NameTable::NameEntryBuilder::SetName(const UChar* name) {
+ if (name == NULL) {
+ name_entry_->name_bytes_.clear();
+ return;
+ }
+ NameTable::ConvertToNameBytes(name,
+ name_entry_->platform_id(),
+ name_entry_->encoding_id(),
+ &name_entry_->name_bytes_);
+}
+
+void NameTable::NameEntryBuilder::SetName(const ByteVector& name_bytes) {
+ name_entry_->name_bytes_.clear();
+ std::copy(name_bytes.begin(),
+ name_bytes.end(),
+ name_entry_->name_bytes_.begin());
+}
+
+void NameTable::NameEntryBuilder::SetName(const ByteVector& name_bytes,
+ int32_t offset,
+ int32_t length) {
+ name_entry_->name_bytes_.clear();
+ std::copy(name_bytes.begin() + offset,
+ name_bytes.begin() + offset + length,
+ name_entry_->name_bytes_.begin());
+}
+
+void NameTable::NameEntryBuilder::Init(int32_t platform_id,
+ int32_t encoding_id,
+ int32_t language_id,
+ int32_t name_id,
+ const ByteVector* name_bytes) {
+ name_entry_ = new NameEntry();
+ name_entry_->Init(platform_id, encoding_id, language_id, name_id, name_bytes);
+}
+
+/******************************************************************************
+ * NameTable::NameEntryFilterInPlace class (C++ port only)
+ ******************************************************************************/
+NameTable::NameEntryFilterInPlace::NameEntryFilterInPlace(int32_t platform_id,
+ int32_t encoding_id,
+ int32_t language_id,
+ int32_t name_id)
+ : platform_id_(platform_id),
+ encoding_id_(encoding_id),
+ language_id_(language_id),
+ name_id_(name_id) {
+}
+
+bool NameTable::NameEntryFilterInPlace::Accept(int32_t platform_id,
+ int32_t encoding_id,
+ int32_t language_id,
+ int32_t name_id) {
+ return (platform_id_ == platform_id &&
+ encoding_id_ == encoding_id &&
+ language_id_ == language_id &&
+ name_id_ == name_id);
+}
+
+/******************************************************************************
+ * NameTable::NameEntryIterator class
+ ******************************************************************************/
+NameTable::NameEntryIterator::NameEntryIterator(NameTable* table) {
+ Init(table, NULL);
+}
+
+NameTable::NameEntryIterator::NameEntryIterator(NameTable* table,
+ NameEntryFilter* filter) {
+ Init(table, filter);
+}
+
+bool NameTable::NameEntryIterator::HasNext() {
+ if (!filter_) {
+ if (name_index_ < table_->NameCount()) {
+ return true;
+ }
+ return false;
+ }
+ for (; name_index_ < table_->NameCount(); ++name_index_) {
+ if (filter_->Accept(table_->PlatformId(name_index_),
+ table_->EncodingId(name_index_),
+ table_->LanguageId(name_index_),
+ table_->NameId(name_index_))) {
+ return true;
+ }
+ }
+ return false;
+}
+
+CALLER_ATTACH NameTable::NameEntry* NameTable::NameEntryIterator::Next() {
+ if (!HasNext())
+ return NULL;
+ return table_->GetNameEntry(name_index_++);
+}
+
+void NameTable::NameEntryIterator::Remove() {
+#if !defined (SFNTLY_NO_EXCEPTION)
+ throw UnsupportedOperationException(
+ "Cannot remove a CMap table from an existing font.");
+#endif
+}
+
+void NameTable::NameEntryIterator::Init(NameTable* table,
+ NameEntryFilter* filter) {
+ table_ = table;
+ filter_ = filter;
+ name_index_ = 0;
+}
+
+/******************************************************************************
+ * NameTable::Builder class
+ ******************************************************************************/
+NameTable::Builder::Builder(FontDataTableBuilderContainer* font_builder,
+ Header* header,
+ WritableFontData* data)
+ : Table::ArrayElementTableBuilder(font_builder, header, data) {
+}
+
+NameTable::Builder::Builder(FontDataTableBuilderContainer* font_builder,
+ Header* header,
+ ReadableFontData* data)
+ : Table::ArrayElementTableBuilder(font_builder, header, data) {
+}
+
+void NameTable::Builder::RevertNames() {
+ name_entry_map_.clear();
+ set_model_changed(false);
+}
+
+int32_t NameTable::Builder::BuilderCount() {
+ GetNameBuilders(); // Ensure name_entry_map_ is built.
+ return (int32_t)name_entry_map_.size();
+}
+
+bool NameTable::Builder::Has(int32_t platform_id,
+ int32_t encoding_id,
+ int32_t language_id,
+ int32_t name_id) {
+ NameEntryId probe(platform_id, encoding_id, language_id, name_id);
+ GetNameBuilders(); // Ensure name_entry_map_ is built.
+ return (name_entry_map_.find(probe) != name_entry_map_.end());
+}
+
+CALLER_ATTACH NameTable::NameEntryBuilder*
+ NameTable::Builder::NameBuilder(int32_t platform_id,
+ int32_t encoding_id,
+ int32_t language_id,
+ int32_t name_id) {
+ NameEntryId probe(platform_id, encoding_id, language_id, name_id);
+ NameEntryBuilderMap builders;
+ GetNameBuilders(); // Ensure name_entry_map_ is built.
+ if (name_entry_map_.find(probe) != name_entry_map_.end()) {
+ return name_entry_map_[probe];
+ }
+ NameEntryBuilderPtr builder = new NameEntryBuilder(probe);
+ name_entry_map_[probe] = builder;
+ return builder.Detach();
+}
+
+bool NameTable::Builder::Remove(int32_t platform_id,
+ int32_t encoding_id,
+ int32_t language_id,
+ int32_t name_id) {
+ NameEntryId probe(platform_id, encoding_id, language_id, name_id);
+ GetNameBuilders(); // Ensure name_entry_map_ is built.
+ NameEntryBuilderMap::iterator position = name_entry_map_.find(probe);
+ if (position != name_entry_map_.end()) {
+ name_entry_map_.erase(position);
+ return true;
+ }
+ return false;
+}
+
+CALLER_ATTACH FontDataTable*
+ NameTable::Builder::SubBuildTable(ReadableFontData* data) {
+ FontDataTablePtr table = new NameTable(header(), data);
+ return table.Detach();
+}
+
+void NameTable::Builder::SubDataSet() {
+ name_entry_map_.clear();
+ set_model_changed(false);
+}
+
+int32_t NameTable::Builder::SubDataSizeToSerialize() {
+ if (name_entry_map_.empty()) {
+ return 0;
+ }
+
+ int32_t size = NameTable::Offset::kNameRecordStart +
+ name_entry_map_.size() * NameTable::Offset::kNameRecordSize;
+ for (NameEntryBuilderMap::iterator b = name_entry_map_.begin(),
+ end = name_entry_map_.end();
+ b != end; ++b) {
+ NameEntryBuilderPtr p = b->second;
+ NameEntry* entry = p->name_entry();
+ size += entry->NameBytesLength();
+ }
+ return size;
+}
+
+bool NameTable::Builder::SubReadyToSerialize() {
+ return !name_entry_map_.empty();
+}
+
+int32_t NameTable::Builder::SubSerialize(WritableFontData* new_data) {
+ int32_t string_table_start_offset =
+ NameTable::Offset::kNameRecordStart +
+ name_entry_map_.size() * NameTable::Offset::kNameRecordSize;
+
+ // Header
+ new_data->WriteUShort(NameTable::Offset::kFormat, 0);
+ new_data->WriteUShort(NameTable::Offset::kCount, name_entry_map_.size());
+ new_data->WriteUShort(NameTable::Offset::kStringOffset,
+ string_table_start_offset);
+ int32_t name_record_offset = NameTable::Offset::kNameRecordStart;
+ int32_t string_offset = 0;
+ // Note: we offered operator< in NameEntryId, which will be used by std::less,
+ // and therefore our map will act like TreeMap in Java to provide
+ // sorted key set.
+ for (NameEntryBuilderMap::iterator b = name_entry_map_.begin(),
+ end = name_entry_map_.end();
+ b != end; ++b) {
+ new_data->WriteUShort(
+ name_record_offset + NameTable::Offset::kNameRecordPlatformId,
+ b->first.platform_id());
+ new_data->WriteUShort(
+ name_record_offset + NameTable::Offset::kNameRecordEncodingId,
+ b->first.encoding_id());
+ new_data->WriteUShort(
+ name_record_offset + NameTable::Offset::kNameRecordLanguageId,
+ b->first.language_id());
+ new_data->WriteUShort(
+ name_record_offset + NameTable::Offset::kNameRecordNameId,
+ b->first.name_id());
+ NameEntry* builder_entry = b->second->name_entry();
+ new_data->WriteUShort(
+ name_record_offset + NameTable::Offset::kNameRecordStringLength,
+ builder_entry->NameBytesLength());
+ new_data->WriteUShort(
+ name_record_offset + NameTable::Offset::kNameRecordStringOffset,
+ string_offset);
+ name_record_offset += NameTable::Offset::kNameRecordSize;
+ string_offset += new_data->WriteBytes(
+ string_offset + string_table_start_offset,
+ builder_entry->NameAsBytes());
+ }
+
+ return string_offset + string_table_start_offset;
+}
+
+void NameTable::Builder::Initialize(ReadableFontData* data) {
+ if (data) {
+ NameTablePtr table = new NameTable(header(), data);
+ NameEntryIterator name_iter(table, NULL);
+ while (name_iter.HasNext()) {
+ NameEntryPtr name_entry = name_iter.Next();
+ NameEntryBuilderPtr name_entry_builder = new NameEntryBuilder(name_entry);
+ NameEntry* builder_entry = name_entry_builder->name_entry();
+ NameEntryId probe = builder_entry->name_entry_id();
+ name_entry_map_[probe] = name_entry_builder;
+ }
+ }
+}
+
+NameTable::NameEntryBuilderMap* NameTable::Builder::GetNameBuilders() {
+ if (name_entry_map_.empty()) {
+ Initialize(InternalReadData());
+ }
+ set_model_changed();
+ return &name_entry_map_;
+}
+
+/******************************************************************************
* NameTable class
******************************************************************************/
-NameTable::NameTable(Header* header, ReadableFontData* data)
- : Table(header, data) {}
-
NameTable::~NameTable() {}
-int32_t NameTable::format() {
- return data_->readUShort(Offset::kFormat);
+int32_t NameTable::Format() {
+ return data_->ReadUShort(Offset::kFormat);
}
-int32_t NameTable::nameCount() {
- return data_->readUShort(Offset::kCount);
+int32_t NameTable::NameCount() {
+ return data_->ReadUShort(Offset::kCount);
}
-int32_t NameTable::stringOffset() {
- return data_->readUShort(Offset::kStringOffset);
+int32_t NameTable::PlatformId(int32_t index) {
+ return data_->ReadUShort(Offset::kNameRecordPlatformId +
+ OffsetForNameRecord(index));
}
-int32_t NameTable::offsetForNameRecord(int32_t index) {
- return Offset::kNameRecordStart + index * Offset::kNameRecordSize;
+int32_t NameTable::EncodingId(int32_t index) {
+ return data_->ReadUShort(Offset::kNameRecordEncodingId +
+ OffsetForNameRecord(index));
}
-int32_t NameTable::platformId(int32_t index) {
- return data_->readUShort(Offset::kNameRecordPlatformId +
- offsetForNameRecord(index));
+int32_t NameTable::LanguageId(int32_t index) {
+ return data_->ReadUShort(Offset::kNameRecordLanguageId +
+ OffsetForNameRecord(index));
}
-int32_t NameTable::encodingId(int32_t index) {
- return data_->readUShort(Offset::kNameRecordEncodingId +
- offsetForNameRecord(index));
+int32_t NameTable::NameId(int32_t index) {
+ return data_->ReadUShort(Offset::kNameRecordNameId +
+ OffsetForNameRecord(index));
}
-int32_t NameTable::languageId(int32_t index) {
- return data_->readUShort(Offset::kNameRecordLanguageId +
- offsetForNameRecord(index));
-}
-
-int32_t NameTable::nameId(int32_t index) {
- return data_->readUShort(Offset::kNameRecordNameId +
- offsetForNameRecord(index));
-}
-
-int32_t NameTable::nameLength(int32_t index) {
- return data_->readUShort(Offset::kNameRecordStringLength +
- offsetForNameRecord(index));
-}
-
-int32_t NameTable::nameOffset(int32_t index) {
- return data_->readUShort(Offset::kNameRecordStringOffset +
- offsetForNameRecord(index)) + stringOffset();
-}
-
-void NameTable::nameAsBytes(int32_t index, ByteVector* b) {
+void NameTable::NameAsBytes(int32_t index, ByteVector* b) {
assert(b);
- int32_t length = nameLength(index);
+ int32_t length = NameLength(index);
b->clear();
b->resize(length);
- data_->readBytes(nameOffset(index), b, 0, length);
+ data_->ReadBytes(NameOffset(index), b, 0, length);
}
-void NameTable::nameAsBytes(int32_t platform_id, int32_t encoding_id,
- int32_t language_id, int32_t name_id,
+void NameTable::NameAsBytes(int32_t platform_id,
+ int32_t encoding_id,
+ int32_t language_id,
+ int32_t name_id,
ByteVector* b) {
assert(b);
NameEntryPtr entry;
- entry.attach(nameEntry(platform_id, encoding_id, language_id, name_id));
+ entry.Attach(GetNameEntry(platform_id, encoding_id, language_id, name_id));
if (entry) {
- ByteVector* name = entry->nameAsBytes();
+ ByteVector* name = entry->NameAsBytes();
std::copy(name->begin(), name->end(), b->begin());
}
}
-UChar* NameTable::name(int index) {
+UChar* NameTable::Name(int index) {
ByteVector b;
- nameAsBytes(index, &b);
- return convertFromNameBytes(&b, platformId(index), encodingId(index));
+ NameAsBytes(index, &b);
+ return ConvertFromNameBytes(&b, PlatformId(index), EncodingId(index));
}
-UChar* NameTable::name(int32_t platform_id, int32_t encoding_id,
- int32_t language_id, int32_t name_id) {
+UChar* NameTable::Name(int32_t platform_id,
+ int32_t encoding_id,
+ int32_t language_id,
+ int32_t name_id) {
NameEntryPtr entry;
- entry.attach(nameEntry(platform_id, encoding_id, language_id, name_id));
+ entry.Attach(GetNameEntry(platform_id, encoding_id, language_id, name_id));
if (entry) {
- return entry->name();
+ return entry->Name();
}
return NULL;
}
-CALLER_ATTACH NameTable::NameEntry* NameTable::nameEntry(int32_t index) {
+CALLER_ATTACH NameTable::NameEntry* NameTable::GetNameEntry(int32_t index) {
ByteVector b;
- nameAsBytes(index, &b);
- NameEntryPtr instance = new NameEntry(platformId(index), encodingId(index),
- languageId(index), nameId(index), b);
- return instance.detach();
+ NameAsBytes(index, &b);
+ NameEntryPtr instance = new NameEntry(PlatformId(index),
+ EncodingId(index),
+ LanguageId(index),
+ NameId(index), b);
+ return instance.Detach();
}
-CALLER_ATTACH NameTable::NameEntry* NameTable::nameEntry(int32_t platform_id,
- int32_t encoding_id,
- int32_t language_id,
- int32_t name_id) {
- NameTable::NameEntryFilterInPlace filter(platform_id, encoding_id,
- language_id, name_id);
- NameTable::NameEntryIterator* name_entry_iter = iterator(&filter);
+CALLER_ATTACH NameTable::NameEntry* NameTable::GetNameEntry(int32_t platform_id,
+ int32_t encoding_id,
+ int32_t language_id,
+ int32_t name_id) {
+ NameTable::NameEntryFilterInPlace
+ filter(platform_id, encoding_id, language_id, name_id);
+ NameTable::NameEntryIterator* name_entry_iter = Iterator(&filter);
NameEntryPtr result;
- if (name_entry_iter->hasNext()) {
- result = name_entry_iter->next();
- delete name_entry_iter;
- return result;
+ if (name_entry_iter->HasNext()) {
+ result = name_entry_iter->Next();
}
delete name_entry_iter;
- return NULL;
+ return result;
}
-NameTable::NameEntryIterator* NameTable::iterator() {
+NameTable::NameEntryIterator* NameTable::Iterator() {
return new NameTable::NameEntryIterator(this);
}
-NameTable::NameEntryIterator* NameTable::iterator(NameEntryFilter* filter) {
+NameTable::NameEntryIterator* NameTable::Iterator(NameEntryFilter* filter) {
return new NameTable::NameEntryIterator(this, filter);
}
-const char* NameTable::getEncodingName(int32_t platform_id,
+NameTable::NameTable(Header* header, ReadableFontData* data)
+ : Table(header, data) {}
+
+int32_t NameTable::StringOffset() {
+ return data_->ReadUShort(Offset::kStringOffset);
+}
+
+int32_t NameTable::OffsetForNameRecord(int32_t index) {
+ return Offset::kNameRecordStart + index * Offset::kNameRecordSize;
+}
+
+int32_t NameTable::NameLength(int32_t index) {
+ return data_->ReadUShort(Offset::kNameRecordStringLength +
+ OffsetForNameRecord(index));
+}
+
+int32_t NameTable::NameOffset(int32_t index) {
+ return data_->ReadUShort(Offset::kNameRecordStringOffset +
+ OffsetForNameRecord(index)) + StringOffset();
+}
+
+const char* NameTable::GetEncodingName(int32_t platform_id,
int32_t encoding_id) {
switch (platform_id) {
case PlatformId::kUnicode:
@@ -178,7 +594,7 @@
return "MacThai";
case MacintoshEncodingId::kChineseSimplified:
return "EUC-CN";
- default: // unknown/unconfirmed cases are not ported
+ default: // Note: unknown/unconfirmed cases are not ported.
break;
}
break;
@@ -211,9 +627,9 @@
return NULL;
}
-UConverter* NameTable::getCharset(int32_t platform_id, int32_t encoding_id) {
+UConverter* NameTable::GetCharset(int32_t platform_id, int32_t encoding_id) {
UErrorCode error_code = U_ZERO_ERROR;
- UConverter* conv = ucnv_open(getEncodingName(platform_id, encoding_id),
+ UConverter* conv = ucnv_open(GetEncodingName(platform_id, encoding_id),
&error_code);
if (U_SUCCESS(error_code)) {
return conv;
@@ -225,12 +641,14 @@
return NULL;
}
-void NameTable::convertToNameBytes(const UChar* name, int32_t platform_id,
- int32_t encoding_id, ByteVector* b) {
+void NameTable::ConvertToNameBytes(const UChar* name,
+ int32_t platform_id,
+ int32_t encoding_id,
+ ByteVector* b) {
assert(b);
assert(name);
b->clear();
- UConverter* cs = getCharset(platform_id, encoding_id);
+ UConverter* cs = GetCharset(platform_id, encoding_id);
if (cs == NULL) {
return;
}
@@ -238,23 +656,28 @@
// Preflight to get buffer size.
UErrorCode error_code = U_ZERO_ERROR;
int32_t length = ucnv_fromUChars(cs, NULL, 0, name, -1, &error_code);
- b->resize(length + 4); // the longest termination "\0" is 4 bytes
+ b->resize(length + 4); // The longest termination "\0" is 4 bytes.
memset(&((*b)[0]), 0, length + 4);
error_code = U_ZERO_ERROR;
- ucnv_fromUChars(cs, reinterpret_cast<char*>(&((*b)[0])), length + 4, name,
- -1, &error_code);
+ ucnv_fromUChars(cs,
+ reinterpret_cast<char*>(&((*b)[0])),
+ length + 4,
+ name,
+ -1,
+ &error_code);
if (!U_SUCCESS(error_code)) {
b->clear();
}
ucnv_close(cs);
}
-UChar* NameTable::convertFromNameBytes(ByteVector* name_bytes,
- int32_t platform_id, int32_t encoding_id) {
+UChar* NameTable::ConvertFromNameBytes(ByteVector* name_bytes,
+ int32_t platform_id,
+ int32_t encoding_id) {
if (name_bytes == NULL) {
return NULL;
}
- UConverter* cs = getCharset(platform_id, encoding_id);
+ UConverter* cs = GetCharset(platform_id, encoding_id);
UErrorCode error_code = U_ZERO_ERROR;
if (cs == NULL) {
char buffer[11] = {0};
@@ -280,9 +703,12 @@
// No preflight needed here, we will be bigger.
UChar* output_buffer = new UChar[name_bytes->size() + 1];
memset(output_buffer, 0, sizeof(UChar) * (name_bytes->size() + 1));
- int32_t length = ucnv_toUChars(cs, output_buffer, name_bytes->size(),
+ int32_t length = ucnv_toUChars(cs,
+ output_buffer,
+ name_bytes->size(),
reinterpret_cast<char*>(&((*name_bytes)[0])),
- name_bytes->size(), &error_code);
+ name_bytes->size(),
+ &error_code);
ucnv_close(cs);
if (length > 0) {
return output_buffer;
@@ -292,413 +718,4 @@
return NULL;
}
-/******************************************************************************
- * NameTable::NameEntryId class
- ******************************************************************************/
-NameTable::NameEntryId::NameEntryId()
- : platform_id_(0), encoding_id_(0), language_id_(0), name_id_(0) {
-}
-
-NameTable::NameEntryId::NameEntryId(int32_t platform_id, int32_t encoding_id,
- int32_t language_id, int32_t name_id)
- : platform_id_(platform_id), encoding_id_(encoding_id),
- language_id_(language_id), name_id_(name_id) {
-}
-
-NameTable::NameEntryId::NameEntryId(const NameTable::NameEntryId& rhs) {
- *this = rhs;
-}
-
-NameTable::NameEntryId::~NameEntryId() {}
-
-int32_t NameTable::NameEntryId::getPlatformId() const {
- return platform_id_;
-}
-
-int32_t NameTable::NameEntryId::getEncodingId() const {
- return encoding_id_;
-}
-
-int32_t NameTable::NameEntryId::getLanguageId() const {
- return language_id_;
-}
-
-int32_t NameTable::NameEntryId::getNameId() const {
- return name_id_;
-}
-
-const NameTable::NameEntryId& NameTable::NameEntryId::operator=(
- const NameTable::NameEntryId& rhs) const {
- platform_id_ = rhs.platform_id_;
- encoding_id_ = rhs.encoding_id_;
- language_id_ = rhs.language_id_;
- name_id_ = rhs.name_id_;
- return *this;
-}
-
-bool NameTable::NameEntryId::operator==(const NameEntryId& rhs) const {
- return platform_id_ == rhs.platform_id_ && encoding_id_ == rhs.encoding_id_ &&
- language_id_ == rhs.language_id_ && name_id_ == rhs.name_id_;
-}
-
-bool NameTable::NameEntryId::operator<(const NameEntryId& rhs) const {
- if (platform_id_ != rhs.platform_id_) return platform_id_ < rhs.platform_id_;
- if (encoding_id_ != rhs.encoding_id_) return encoding_id_ < rhs.encoding_id_;
- if (language_id_ != rhs.language_id_) return language_id_ < rhs.language_id_;
- return name_id_ < rhs.name_id_;
-}
-
-/******************************************************************************
- * NameTable::NameEntry class
- ******************************************************************************/
-void NameTable::NameEntry::init(int32_t platform_id, int32_t encoding_id,
- int32_t language_id, int32_t name_id,
- const ByteVector* name_bytes) {
- name_entry_id_ = NameEntryId(platform_id, encoding_id, language_id, name_id);
- if (name_bytes) {
- name_bytes_ = *name_bytes;
- } else {
- name_bytes_.clear();
- }
-}
-
-NameTable::NameEntry::NameEntry() {
- init(0, 0, 0, 0, NULL);
-}
-
-NameTable::NameEntry::NameEntry(const NameEntryId& name_entry_id,
- const ByteVector& name_bytes) {
- init(name_entry_id.getPlatformId(), name_entry_id.getEncodingId(),
- name_entry_id.getLanguageId(), name_entry_id.getNameId(), &name_bytes);
-}
-
-NameTable::NameEntry::NameEntry(int32_t platform_id, int32_t encoding_id,
- int32_t language_id, int32_t name_id,
- const ByteVector& name_bytes) {
- init(platform_id, encoding_id, language_id, name_id, &name_bytes);
-}
-
-NameTable::NameEntry::~NameEntry() {}
-
-NameTable::NameEntryId& NameTable::NameEntry::getNameEntryId() {
- return name_entry_id_;
-}
-
-int32_t NameTable::NameEntry::platformId() {
- return name_entry_id_.getPlatformId();
-}
-
-int32_t NameTable::NameEntry::encodingId() {
- return name_entry_id_.getEncodingId();
-}
-
-int32_t NameTable::NameEntry::languageId() {
- return name_entry_id_.getLanguageId();
-}
-
-int32_t NameTable::NameEntry::nameId() {
- return name_entry_id_.getNameId();
-}
-
-int32_t NameTable::NameEntry::nameBytesLength() {
- return name_bytes_.size();
-}
-
-ByteVector* NameTable::NameEntry::nameAsBytes() {
- return &name_bytes_;
-}
-
-UChar* NameTable::NameEntry::name() {
- return NameTable::convertFromNameBytes(&name_bytes_, platformId(),
- encodingId());
-}
-
-bool NameTable::NameEntry::operator==(const NameEntry& rhs) const {
- return (name_entry_id_ == rhs.name_entry_id_ &&
- name_bytes_ == rhs.name_bytes_);
-}
-
-/******************************************************************************
- * NameTable::NameEntryBuilder class
- ******************************************************************************/
-NameTable::NameEntryBuilder::NameEntryBuilder() {
- init(0, 0, 0, 0, NULL);
-}
-
-NameTable::NameEntryBuilder::NameEntryBuilder(
- const NameEntryId& name_entry_id, const ByteVector& name_bytes) {
- init(name_entry_id.getPlatformId(), name_entry_id.getEncodingId(),
- name_entry_id.getLanguageId(), name_entry_id.getNameId(), &name_bytes);
-}
-
-NameTable::NameEntryBuilder::NameEntryBuilder(
- const NameEntryId& name_entry_id) {
- init(name_entry_id.getPlatformId(), name_entry_id.getEncodingId(),
- name_entry_id.getLanguageId(), name_entry_id.getNameId(), NULL);
-}
-
-NameTable::NameEntryBuilder::NameEntryBuilder(NameEntry* b) {
- init(b->platformId(), b->encodingId(), b->languageId(), b->nameId(),
- b->nameAsBytes());
-}
-
-NameTable::NameEntryBuilder::~NameEntryBuilder() {}
-
-void NameTable::NameEntryBuilder::setName(const UChar* name) {
- if (name == NULL) {
- name_entry_->name_bytes_.clear();
- return;
- }
- NameTable::convertToNameBytes(name, name_entry_->platformId(),
- name_entry_->encodingId(),
- &name_entry_->name_bytes_);
-}
-
-void NameTable::NameEntryBuilder::setName(const ByteVector& name_bytes) {
- name_entry_->name_bytes_.clear();
- std::copy(name_bytes.begin(), name_bytes.end(),
- name_entry_->name_bytes_.begin());
-}
-
-void NameTable::NameEntryBuilder::setName(const ByteVector& name_bytes,
- int32_t offset, int32_t length) {
- name_entry_->name_bytes_.clear();
- std::copy(name_bytes.begin() + offset, name_bytes.begin() + offset + length,
- name_entry_->name_bytes_.begin());
-}
-
-CALLER_ATTACH NameTable::NameEntry* NameTable::NameEntryBuilder::entry() {
- return name_entry_;
-}
-
-void NameTable::NameEntryBuilder::init(int32_t platform_id, int32_t encoding_id,
- int32_t language_id, int32_t name_id, const ByteVector* name_bytes) {
- name_entry_ = new NameEntry();
- name_entry_->init(platform_id, encoding_id, language_id, name_id, name_bytes);
-}
-
-/******************************************************************************
- * NameTable::NameEntryFilterInPlace class (C++ port only)
- ******************************************************************************/
-NameTable::NameEntryFilterInPlace::NameEntryFilterInPlace(int32_t platform_id,
- int32_t encoding_id, int32_t language_id, int32_t name_id)
- : platform_id_(platform_id), encoding_id_(encoding_id),
- language_id_(language_id), name_id_(name_id) {
-}
-
-bool NameTable::NameEntryFilterInPlace::accept(int32_t platform_id,
- int32_t encoding_id, int32_t language_id, int32_t name_id) {
- return (platform_id_ == platform_id && encoding_id_ == encoding_id &&
- language_id_ == language_id && name_id_ == name_id);
-}
-
-/******************************************************************************
- * NameTable::NameEntryIterator class
- ******************************************************************************/
-void NameTable::NameEntryIterator::init(NameTable* table,
- NameEntryFilter* filter) {
- table_ = table;
- filter_ = filter;
- name_index_ = 0;
-}
-
-NameTable::NameEntryIterator::NameEntryIterator(NameTable* table) {
- init(table, NULL);
-}
-
-NameTable::NameEntryIterator::NameEntryIterator(NameTable* table,
- NameEntryFilter* filter) {
- init(table, filter);
-}
-
-NameTable::NameEntryIterator::~NameEntryIterator() {
-}
-
-bool NameTable::NameEntryIterator::hasNext() {
- if (!filter_) {
- if (name_index_ < table_->nameCount()) {
- return true;
- }
- return false;
- }
- for (; name_index_ < table_->nameCount(); ++name_index_) {
- if (filter_->accept(table_->platformId(name_index_),
- table_->encodingId(name_index_),
- table_->languageId(name_index_),
- table_->nameId(name_index_))) {
- return true;
- }
- }
- return false;
-}
-
-CALLER_ATTACH NameTable::NameEntry* NameTable::NameEntryIterator::next() {
- if (!hasNext())
- return NULL;
- return table_->nameEntry(name_index_++);
-}
-
-void NameTable::NameEntryIterator::remove() {
-#if !defined (SFNTLY_NO_EXCEPTION)
- throw UnsupportedOperationException(
- "Cannot remove a CMap table from an existing font.");
-#endif
-}
-
-/******************************************************************************
- * NameTable::Builder class
- ******************************************************************************/
-NameTable::Builder::Builder(FontDataTableBuilderContainer* font_builder,
- Header* header, WritableFontData* data) :
- Table::ArrayElementTableBuilder(font_builder, header, data) {
-}
-
-NameTable::Builder::Builder(FontDataTableBuilderContainer* font_builder,
- Header* header, ReadableFontData* data) :
- Table::ArrayElementTableBuilder(font_builder, header, data) {
-}
-
-void NameTable::Builder::initialize(ReadableFontData* data) {
- if (data) {
- NameTablePtr table = new NameTable(header(), data);
- NameEntryIterator name_iter(table, NULL);
- while (name_iter.hasNext()) {
- NameEntryPtr name_entry = name_iter.next();
- NameEntryBuilderPtr name_entry_builder = new NameEntryBuilder(name_entry);
- NameEntry* builder_entry = name_entry_builder->entry();
- NameEntryId probe = builder_entry->getNameEntryId();
- name_entry_map_[probe] = name_entry_builder;
- }
- }
-}
-
-NameTable::NameEntryBuilderMap* NameTable::Builder::getNameBuilders() {
- if (name_entry_map_.empty()) {
- initialize(internalReadData());
- }
- setModelChanged();
- return &name_entry_map_;
-}
-
-void NameTable::Builder::revertNames() {
- name_entry_map_.clear();
- setModelChanged(false);
-}
-
-int32_t NameTable::Builder::builderCount() {
- getNameBuilders(); // ensure name_entry_map_ is built
- return (int32_t)name_entry_map_.size();
-}
-
-bool NameTable::Builder::has(int32_t platform_id, int32_t encoding_id,
- int32_t language_id, int32_t name_id) {
- NameEntryId probe(platform_id, encoding_id, language_id, name_id);
- getNameBuilders(); // ensure name_entry_map_ is built
- return (name_entry_map_.find(probe) != name_entry_map_.end());
-}
-
-CALLER_ATTACH NameTable::NameEntryBuilder* NameTable::Builder::nameBuilder(
- int32_t platform_id, int32_t encoding_id, int32_t language_id,
- int32_t name_id) {
- NameEntryId probe(platform_id, encoding_id, language_id, name_id);
- NameEntryBuilderMap builders;
- getNameBuilders(); // ensure name_entry_map_ is built
- if (name_entry_map_.find(probe) != name_entry_map_.end()) {
- return name_entry_map_[probe];
- }
- NameEntryBuilderPtr builder = new NameEntryBuilder(probe);
- name_entry_map_[probe] = builder;
- return builder.detach();
-}
-
-bool NameTable::Builder::remove(int32_t platform_id, int32_t encoding_id,
- int32_t language_id, int32_t name_id) {
- NameEntryId probe(platform_id, encoding_id, language_id, name_id);
- getNameBuilders(); // ensure name_entry_map_ is built
- NameEntryBuilderMap::iterator position = name_entry_map_.find(probe);
- if (position != name_entry_map_.end()) {
- name_entry_map_.erase(position);
- return true;
- }
- return false;
-}
-
-CALLER_ATTACH FontDataTable* NameTable::Builder::subBuildTable(
- ReadableFontData* data) {
- FontDataTablePtr table = new NameTable(header(), data);
- return table.detach();
-}
-
-void NameTable::Builder::subDataSet() {
- name_entry_map_.clear();
- setModelChanged(false);
-}
-
-int32_t NameTable::Builder::subDataSizeToSerialize() {
- if (name_entry_map_.empty()) {
- return 0;
- }
-
- int32_t size = NameTable::Offset::kNameRecordStart + name_entry_map_.size() *
- NameTable::Offset::kNameRecordSize;
- for (NameEntryBuilderMap::iterator b = name_entry_map_.begin(),
- end = name_entry_map_.end();
- b != end; ++b) {
- NameEntryBuilderPtr p = b->second;
- NameEntry* entry = p->entry();
- size += entry->nameBytesLength();
- }
- return size;
-}
-
-bool NameTable::Builder::subReadyToSerialize() {
- return !name_entry_map_.empty();
-}
-
-int32_t NameTable::Builder::subSerialize(WritableFontData* new_data) {
- int32_t string_table_start_offset =
- NameTable::Offset::kNameRecordStart + name_entry_map_.size() *
- NameTable::Offset::kNameRecordSize;
-
- // header
- new_data->writeUShort(NameTable::Offset::kFormat, 0);
- new_data->writeUShort(NameTable::Offset::kCount, name_entry_map_.size());
- new_data->writeUShort(NameTable::Offset::kStringOffset,
- string_table_start_offset);
- int32_t name_record_offset = NameTable::Offset::kNameRecordStart;
- int32_t string_offset = 0;
- // Note: we offered operator< in NameEntryId, which will be used by std::less,
- // and therefore our map will act like TreeMap in Java to provide
- // sorted key set.
- for (NameEntryBuilderMap::iterator b = name_entry_map_.begin(),
- end = name_entry_map_.end();
- b != end; ++b) {
- new_data->writeUShort(
- name_record_offset + NameTable::Offset::kNameRecordPlatformId,
- b->first.getPlatformId());
- new_data->writeUShort(
- name_record_offset + NameTable::Offset::kNameRecordEncodingId,
- b->first.getEncodingId());
- new_data->writeUShort(
- name_record_offset + NameTable::Offset::kNameRecordLanguageId,
- b->first.getLanguageId());
- new_data->writeUShort(
- name_record_offset + NameTable::Offset::kNameRecordNameId,
- b->first.getNameId());
- NameEntry* builder_entry = b->second->entry();
- new_data->writeUShort(
- name_record_offset + NameTable::Offset::kNameRecordStringLength,
- builder_entry->nameBytesLength());
- new_data->writeUShort(
- name_record_offset + NameTable::Offset::kNameRecordStringOffset,
- string_offset);
- name_record_offset += NameTable::Offset::kNameRecordSize;
- string_offset += new_data->writeBytes(
- string_offset + string_table_start_offset,
- builder_entry->nameAsBytes());
- }
-
- return string_offset + string_table_start_offset;
-}
-
} // namespace sfntly
diff --git a/sfntly/name_table.h b/sfntly/name_table.h
index 6d5df2b..d0dd345 100644
--- a/sfntly/name_table.h
+++ b/sfntly/name_table.h
@@ -34,6 +34,10 @@
namespace sfntly {
+// The following code implements the name table defined in TTF/OTF spec, which
+// can be found at http://www.microsoft.com/typography/otspec/name.htm.
+
+// Name IDs defined in TTF/OTF spec.
struct NameId {
enum {
kUnknown = -1,
@@ -63,6 +67,7 @@
};
};
+// Unicode language IDs used in Name Records.
struct UnicodeLanguageId {
enum {
kUnknown = -1,
@@ -408,6 +413,266 @@
};
class NameTable : public Table, public RefCounted<NameTable> {
+ public:
+ // Unique identifier for a given name record.
+ class NameEntryId {
+ public:
+ NameEntryId(); // C++ port only, must provide default constructor.
+ NameEntryId(int32_t platform_id, int32_t encoding_id, int32_t language_id,
+ int32_t name_id);
+ NameEntryId(const NameEntryId&);
+ // Make gcc -Wnon-virtual-dtor happy.
+ virtual ~NameEntryId() {}
+
+ int32_t platform_id() const { return platform_id_; }
+ int32_t encoding_id() const { return encoding_id_; }
+ int32_t language_id() const { return language_id_; }
+ int32_t name_id() const { return name_id_; }
+
+ const NameEntryId& operator=(const NameEntryId& rhs) const;
+ bool operator==(const NameEntryId& rhs) const;
+ bool operator<(const NameEntryId& rhs) const;
+
+ private:
+ mutable int32_t platform_id_;
+ mutable int32_t encoding_id_;
+ mutable int32_t language_id_;
+ mutable int32_t name_id_;
+ };
+
+ class NameEntryBuilder;
+
+ // Class to represent a name entry in the name table.
+ class NameEntry : public RefCounted<NameEntry> {
+ public:
+ NameEntry();
+ NameEntry(const NameEntryId& name_entry_id, const ByteVector& name_bytes);
+ NameEntry(int32_t platform_id, int32_t encoding_id, int32_t language_id,
+ int32_t name_id, const ByteVector& name_bytes);
+ virtual ~NameEntry();
+
+ NameEntryId& name_entry_id() { return name_entry_id_; }
+ int32_t platform_id() const { return name_entry_id_.platform_id(); }
+ int32_t encoding_id() const { return name_entry_id_.encoding_id(); }
+ int32_t language_id() const { return name_entry_id_.language_id(); };
+ int32_t name_id() const { return name_entry_id_.name_id(); }
+
+ // Get the bytes for name. Returned pointer is the address of private
+ // member of this class, do not attempt to delete.
+ ByteVector* NameAsBytes();
+
+ // C++ port only: get the length of NameAsBytes.
+ int32_t NameBytesLength();
+
+ // Returns the name in Unicode as UChar array.
+ // Note: ICU UChar* convention requires caller to delete[] it.
+ UChar* Name();
+ bool operator==(const NameEntry& rhs) const;
+
+ private:
+ void Init(int32_t platform_id, int32_t encoding_id, int32_t language_id,
+ int32_t name_id, const ByteVector* name_bytes);
+
+ NameEntryId name_entry_id_;
+ int32_t length_;
+ ByteVector name_bytes_;
+
+ friend class NameEntryBuilder;
+ };
+
+ // Builder of a name entry.
+ // C++ port: original Java hierarchy inherits from NameEntry. In C++ port, we
+ // opted not doing so to avoid ref count issues and nasty protected members.
+ class NameEntryBuilder : public RefCounted<NameEntryBuilder> {
+ public:
+ NameEntryBuilder();
+ NameEntryBuilder(const NameEntryId& name_entry_id,
+ const ByteVector& name_bytes);
+ explicit NameEntryBuilder(const NameEntryId& name_entry_id);
+ explicit NameEntryBuilder(NameEntry* entry);
+ virtual ~NameEntryBuilder();
+
+ virtual void SetName(const UChar* name);
+ virtual void SetName(const ByteVector& name_bytes);
+ virtual void SetName(const ByteVector& name_bytes, int32_t offset,
+ int32_t length);
+
+ // C++ port only. CALLER_ATTACH is not added because the lifetime shall be
+ // controlled by this class, therefore the caller shall not increase the ref
+ // count.
+ NameEntry* name_entry() { return name_entry_; }
+
+ private:
+ void Init(int32_t platform_id, int32_t encoding_id, int32_t language_id,
+ int32_t name_id, const ByteVector* name_bytes);
+
+ Ptr<NameEntry> name_entry_;
+ };
+ typedef std::map<NameEntryId, Ptr<NameEntryBuilder> > NameEntryBuilderMap;
+
+ // An interface for a filter to use with the name entry iterator. This allows
+ // name entries to be iterated and only those acceptable to the filter will be
+ // returned.
+ class NameEntryFilter {
+ public:
+ virtual bool Accept(int32_t platform_id, int32_t encoding_id,
+ int32_t language_id, int32_t name_id) = 0;
+ // Make gcc -Wnon-virtual-dtor happy.
+ virtual ~NameEntryFilter() {}
+ };
+
+ // C++ port only: an in-place filter to mimic Java Iterator's filtering.
+ class NameEntryFilterInPlace : public NameEntryFilter {
+ public:
+ NameEntryFilterInPlace(int32_t platform_id, int32_t encoding_id,
+ int32_t language_id, int32_t name_id);
+ // Make gcc -Wnon-virtual-dtor happy.
+ virtual ~NameEntryFilterInPlace() {}
+
+ virtual bool Accept(int32_t platform_id, int32_t encoding_id,
+ int32_t language_id, int32_t name_id);
+
+ private:
+ int32_t platform_id_;
+ int32_t encoding_id_;
+ int32_t language_id_;
+ int32_t name_id_;
+ };
+
+ // Mimic Java's iterator to iterate through the entries within the name table.
+ class NameEntryIterator {
+ public:
+ // If filter is NULL, filter through all tables.
+ explicit NameEntryIterator(NameTable* table);
+ NameEntryIterator(NameTable* table, NameEntryFilter* filter);
+ // Make gcc -Wnon-virtual-dtor happy.
+ virtual ~NameEntryIterator() {}
+
+ virtual bool HasNext();
+ virtual CALLER_ATTACH NameEntry* Next();
+ virtual void Remove();
+
+ private:
+ void Init(NameTable* table, NameEntryFilter* filter);
+
+ NameTable* table_; // Use dumb pointer since it's a composition object.
+ int32_t name_index_;
+ NameEntryFilter* filter_;
+ };
+
+ // The builder to construct name table for outputting.
+ class Builder : public Table::ArrayElementTableBuilder,
+ public RefCounted<Builder> {
+ public:
+ // Constructor scope altered to public because C++ does not allow base
+ // class to instantiate derived class with protected constructors.
+ Builder(FontDataTableBuilderContainer* font_builder, Header* header,
+ WritableFontData* data);
+ Builder(FontDataTableBuilderContainer* font_builder, Header* header,
+ ReadableFontData* data);
+
+ // Revert the name builders for the name table to the last version that came
+ // from data.
+ void RevertNames();
+
+ // Number of name entry builders contained.
+ int32_t BuilderCount();
+
+ // Note: For C++ port, clear() is not implemented. The clear() function
+ // implies completely remove name entry builders, which is easy in
+ // Java but will take a lot of efforts in C++ to release the builders
+ // nicely and correctly.
+ // TODO(arthurhsu): IMPLEMENT
+ // Clear the name builders for the name table.
+ // void clear();
+
+ // Check the existance of a name entry builder by key.
+ bool Has(int32_t platform_id, int32_t encoding_id, int32_t language_id,
+ int32_t name_id);
+
+ // Get name entry builder by key.
+ CALLER_ATTACH NameEntryBuilder* NameBuilder(int32_t platform_id,
+ int32_t encoding_id, int32_t language_id, int32_t name_id);
+
+ // Remove name entry builder by key.
+ bool Remove(int32_t platform_id, int32_t encoding_id, int32_t language_id,
+ int32_t name_id);
+
+ // FontDataTable::Builder API implementation
+ 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);
+ NameEntryBuilderMap* GetNameBuilders();
+
+ // Note: callers should use the getter funtion provided above to ensure that
+ // this is lazily initialized instead of accessing directly.
+ NameEntryBuilderMap name_entry_map_;
+ };
+
+ /****************************************************************************
+ * public methods of NameTable class
+ ****************************************************************************/
+ virtual ~NameTable();
+
+ // Get the format used in the name table.
+ virtual int32_t Format();
+
+ // Get the number of names in the name table.
+ virtual int32_t NameCount();
+
+ // Get the platform id for the given name record.
+ virtual int32_t PlatformId(int32_t index);
+
+ // Get the encoding id for the given name record.
+ // see MacintoshEncodingId, WindowsEncodingId, UnicodeEncodingId
+ virtual int32_t EncodingId(int32_t index);
+
+ // Get the language id for the given name record.
+ virtual int32_t LanguageId(int32_t index);
+
+ // Get the name id for given name record.
+ virtual int32_t NameId(int32_t index);
+
+ // Get the name as bytes for the specified name. If there is no entry for the
+ // requested name, then empty vector is returned.
+ virtual void NameAsBytes(int32_t index, ByteVector* b);
+ virtual void NameAsBytes(int32_t platform_id, int32_t encoding_id,
+ int32_t language_id, int32_t name_id,
+ ByteVector* b);
+
+ // Get the name as a UChar* for the given name record. If there is no
+ // encoding conversion available for the name record then a best attempt
+ // UChar* will be returned.
+ // Note: ICU UChar* convention requires caller to delete[] it.
+ virtual UChar* Name(int index);
+
+ // Get the name as a UChar* for the specified name. If there is no entry for
+ // the requested name then NULL is returned. If there is no encoding
+ // conversion available for the name then a best attempt UChar* will be
+ // returned.
+ // Note: ICU UChar* convention requires caller to delete[] it.
+ virtual UChar* Name(int32_t platform_id, int32_t encoding_id,
+ int32_t language_id, int32_t name_id);
+
+ // Note: These functions are renamed in C++ port. Their original Java name is
+ // nameEntry().
+ virtual CALLER_ATTACH NameEntry* GetNameEntry(int32_t index);
+ virtual CALLER_ATTACH NameEntry* GetNameEntry(int32_t platform_id,
+ int32_t encoding_id, int32_t language_id, int32_t name_id);
+
+ // Note: Not implemented in C++ port due to complexity and low usage.
+ // virtual void names(std::set<NameEntryPtr>*);
+
+ // Get the iterator to iterate through all name entries.
+ // Note: Caller delete the returned object.
+ virtual NameEntryIterator* Iterator();
+ virtual NameEntryIterator* Iterator(NameEntryFilter* filter);
+
private:
struct Offset {
enum {
@@ -416,7 +681,7 @@
kStringOffset = 4,
kNameRecordStart = 6,
- // format 1 - offset from the end of the name records
+ // Format 1 - offset from the end of the name records
kLangTagCount = 0,
kLangTagRecord = 2,
@@ -431,254 +696,36 @@
};
};
+ // The table shall be constructed using Builder, no direct instantiation.
NameTable(Header* header, ReadableFontData* data);
- public:
- virtual ~NameTable();
- virtual int32_t format();
-
- // Get the number of names in the name table.
- virtual int32_t nameCount();
-
- private:
// Get the offset to the string data in the name table.
- int32_t stringOffset();
+ int32_t StringOffset();
// Get the offset for the given name record.
- int32_t offsetForNameRecord(int32_t index);
+ int32_t OffsetForNameRecord(int32_t index);
- public:
- // Get the platform id for the given name record.
- virtual int32_t platformId(int32_t index);
-
- // Get the encoding id for the given name record.
- // see MacintoshEncodingId, WindowsEncodingId, UnicodeEncodingId
- virtual int32_t encodingId(int32_t index);
-
- // Get the language id for the given name record.
- virtual int32_t languageId(int32_t index);
-
- // Get the name id for given name record.
- virtual int32_t nameId(int32_t index);
-
- private:
// Get the length of the string data for the given name record.
- int32_t nameLength(int32_t index);
+ int32_t NameLength(int32_t index);
// Get the offset of the string data for the given name record.
- int32_t nameOffset(int32_t index);
+ int32_t NameOffset(int32_t index);
- public:
- // Get the name as bytes for the specified name. If there is no entry for the
- // requested name, then empty vector is returned.
- virtual void nameAsBytes(int32_t index, ByteVector* b);
- virtual void nameAsBytes(int32_t platform_id, int32_t encoding_id,
- int32_t language_id, int32_t name_id,
- ByteVector* b);
+ // Note: string literals are returned. Caller shall not attempt to manipulate
+ // the returned pointer.
+ static const char* GetEncodingName(int32_t platform_id, int32_t encoding_id);
- // Get the name as a UChar* for the given name record. If there is no
- // encoding conversion available for the name record then a best attempt
- // UChar* will be returned.
- // Note: ICU UChar* convention requires caller to delete[] it.
- virtual UChar* name(int index);
+ // Note: ICU UConverter* convention requires caller to ucnv_close() it.
+ static UConverter* GetCharset(int32_t platform_id, int32_t encoding_id);
- // Get the name as a UChar* for the specified name. If there is no entry for
- // the requested name then NULL is returned. If there is no encoding
- // conversion available for the name then a best attempt UChar* will be
- // returned.
- // Note: ICU UChar* convention requires caller to delete[] it.
- virtual UChar* name(int32_t platform_id, int32_t encoding_id,
- int32_t language_id, int32_t name_id);
-
- class NameEntry;
- virtual CALLER_ATTACH NameEntry* nameEntry(int32_t index);
- virtual CALLER_ATTACH NameEntry* nameEntry(int32_t platform_id,
- int32_t encoding_id, int32_t language_id, int32_t name_id);
-
- // Note: Not implemented in C++ port due to complexity and low usage.
- // virtual void names(std::set<NameEntryPtr>*);
-
- class NameEntryId {
- protected:
- mutable int32_t platform_id_;
- mutable int32_t encoding_id_;
- mutable int32_t language_id_;
- mutable int32_t name_id_;
-
- public:
- NameEntryId(); // C++ port only, must provide default constructor.
- NameEntryId(int32_t platform_id, int32_t encoding_id, int32_t language_id,
- int32_t name_id);
- NameEntryId(const NameEntryId&);
- virtual ~NameEntryId();
- virtual int32_t getPlatformId() const;
- virtual int32_t getEncodingId() const;
- virtual int32_t getLanguageId() const;
- virtual int32_t getNameId() const;
- virtual const NameEntryId& operator=(const NameEntryId& rhs) const;
- virtual bool operator==(const NameEntryId& rhs) const;
- virtual bool operator<(const NameEntryId& rhs) const;
- };
-
- // Class to represent a name entry in the name table.
- class NameEntryBuilder;
- class NameEntry : public RefCounted<NameEntry> {
- public:
- NameEntry();
- NameEntry(const NameEntryId& name_entry_id, const ByteVector& name_bytes);
- NameEntry(int32_t platform_id, int32_t encoding_id, int32_t language_id,
- int32_t name_id, const ByteVector& name_bytes);
- virtual ~NameEntry();
- virtual NameEntryId& getNameEntryId();
- virtual int32_t platformId();
- virtual int32_t encodingId();
- virtual int32_t languageId();
- virtual int32_t nameId();
- virtual int32_t nameBytesLength(); // C++ port only
- virtual ByteVector* nameAsBytes();
- virtual UChar* name();
- virtual bool operator==(const NameEntry& rhs) const;
-
- private:
- void init(int32_t platform_id, int32_t encoding_id, int32_t language_id,
- int32_t name_id, const ByteVector* name_bytes);
-
- NameEntryId name_entry_id_;
- int32_t length_;
- ByteVector name_bytes_;
-
- friend class NameEntryBuilder;
- };
-
- // C++ port: we don't use original Java hierarchy to avoid ref count issues
- // and nasty protected members.
- class NameEntryBuilder : public RefCounted<NameEntryBuilder> {
- public:
- NameEntryBuilder();
- NameEntryBuilder(const NameEntryId& name_entry_id,
- const ByteVector& name_bytes);
- explicit NameEntryBuilder(const NameEntryId& name_entry_id);
- explicit NameEntryBuilder(NameEntry* entry);
- virtual ~NameEntryBuilder();
-
- virtual void setName(const UChar* name);
- virtual void setName(const ByteVector& name_bytes);
- virtual void setName(const ByteVector& name_bytes, int32_t offset,
- int32_t length);
-
- // C++ port only member functions. CALLER_ATTACH is not added because the
- // lifetime shall be controlled by build, therefore the caller shall not
- // increase the ref count.
- NameEntry* entry();
-
- private:
- void init(int32_t platform_id, int32_t encoding_id, int32_t language_id,
- int32_t name_id, const ByteVector* name_bytes);
-
- Ptr<NameEntry> name_entry_;
- };
-
- class NameEntryFilter {
- public:
- virtual bool accept(int32_t platform_id, int32_t encoding_id,
- int32_t language_id, int32_t name_id) = 0;
- // Make gcc -Wnon-virtual-dtor happy.
- virtual ~NameEntryFilter() {}
- };
-
- // C++ port only
- class NameEntryFilterInPlace : public NameEntryFilter {
- public:
- NameEntryFilterInPlace(int32_t platform_id, int32_t encoding_id,
- int32_t language_id, int32_t name_id);
- // Make gcc -Wnon-virtual-dtor happy.
- virtual ~NameEntryFilterInPlace() {}
- virtual bool accept(int32_t platform_id, int32_t encoding_id,
- int32_t language_id, int32_t name_id);
-
- private:
- int32_t platform_id_;
- int32_t encoding_id_;
- int32_t language_id_;
- int32_t name_id_;
- };
-
- class NameEntryIterator {
- public:
- // If filter is NULL, filter through all tables.
- explicit NameEntryIterator(NameTable* table);
- NameEntryIterator(NameTable* table, NameEntryFilter* filter);
- // Make gcc -Wnon-virtual-dtor happy.
- virtual ~NameEntryIterator();
- virtual bool hasNext();
- virtual CALLER_ATTACH NameEntry* next();
- virtual void remove();
-
- private:
- void init(NameTable* table, NameEntryFilter* filter);
-
- NameTable* table_; // use dumb pointer since it's a composition object
- int32_t name_index_;
- NameEntryFilter* filter_;
- };
-
- // caller delete the object
- virtual NameEntryIterator* iterator();
- virtual NameEntryIterator* iterator(NameEntryFilter* filter);
-
- private:
- static const char* getEncodingName(int32_t platform_id, int32_t encoding_id);
- static UConverter* getCharset(int32_t platform_id, int32_t encoding_id);
- static void convertToNameBytes(const UChar* name, int32_t platform_id,
+ // Note: Output will be stored in ByteVector* b. Original data in b will be
+ // erased and replaced with converted name bytes.
+ static void ConvertToNameBytes(const UChar* name, int32_t platform_id,
int32_t encoding_id, ByteVector* b);
- static UChar* convertFromNameBytes(ByteVector* name_bytes,
+
+ // Note: ICU UChar* convention requires caller to delete[] it.
+ static UChar* ConvertFromNameBytes(ByteVector* name_bytes,
int32_t platform_id, int32_t encoding_id);
-
- public:
- typedef std::map<NameEntryId, Ptr<NameEntryBuilder> > NameEntryBuilderMap;
-
- class Builder : public Table::ArrayElementTableBuilder,
- public RefCounted<Builder> {
- public:
- // Constructor scope altered to public because C++ does not allow base
- // class to instantiate derived class with protected constructors.
- Builder(FontDataTableBuilderContainer* font_builder, Header* header,
- WritableFontData* data);
- Builder(FontDataTableBuilderContainer* font_builder, Header* header,
- ReadableFontData* data);
-
- private:
- void initialize(ReadableFontData* data);
- NameEntryBuilderMap* getNameBuilders();
-
- public: // static class in Java, functions are not virtual unless inherited
- void revertNames();
- int32_t builderCount();
-
- // Note: For C++ port, this is not implemented so far. The clear() function
- // implies completely remove name entry builders, which is easy in
- // Java but will take a lot of efforts in C++ to release the builders
- // nicely and correctly.
- // TODO(arthurhsu): IMPLEMENT
- // Clear the name builders for the name table.
- // void clear();
-
- bool has(int32_t platform_id, int32_t encoding_id, int32_t language_id,
- int32_t name_id);
- CALLER_ATTACH NameEntryBuilder* nameBuilder(int32_t platform_id,
- int32_t encoding_id, int32_t language_id, int32_t name_id);
- bool remove(int32_t platform_id, int32_t encoding_id, int32_t language_id,
- int32_t name_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:
- NameEntryBuilderMap name_entry_map_;
- };
}; // class NameTable
typedef Ptr<NameTable> NameTablePtr;
typedef Ptr<NameTable::NameEntry> NameEntryPtr;
diff --git a/sfntly/os2_table.cc b/sfntly/os2_table.cc
index 4e7189d..6d6d338 100644
--- a/sfntly/os2_table.cc
+++ b/sfntly/os2_table.cc
@@ -98,163 +98,164 @@
/******************************************************************************
* class OS2Table
******************************************************************************/
-OS2Table::OS2Table(Header* header, ReadableFontData* data)
- : Table(header, data) {
-}
-
OS2Table::~OS2Table() {}
-int32_t OS2Table::version() {
- return data_->readUShort(Offset::kVersion);
+int32_t OS2Table::Version() {
+ return data_->ReadUShort(Offset::kVersion);
}
-int32_t OS2Table::xAvgCharWidth() {
- return data_->readShort(Offset::kXAvgCharWidth);
+int32_t OS2Table::XAvgCharWidth() {
+ return data_->ReadShort(Offset::kXAvgCharWidth);
}
-int32_t OS2Table::usWeightClass() {
- return data_->readUShort(Offset::kUsWeightClass);
+int32_t OS2Table::UsWeightClass() {
+ return data_->ReadUShort(Offset::kUsWeightClass);
}
-int32_t OS2Table::usWidthClass() {
- return data_->readUShort(Offset::kUsWidthClass);
+int32_t OS2Table::UsWidthClass() {
+ return data_->ReadUShort(Offset::kUsWidthClass);
}
-int32_t OS2Table::fsType() {
- return data_->readUShort(Offset::kFsType);
+int32_t OS2Table::FsType() {
+ return data_->ReadUShort(Offset::kFsType);
}
-int32_t OS2Table::ySubscriptXSize() {
- return data_->readShort(Offset::kYSubscriptXSize);
+int32_t OS2Table::YSubscriptXSize() {
+ return data_->ReadShort(Offset::kYSubscriptXSize);
}
-int32_t OS2Table::ySubscriptYSize() {
- return data_->readShort(Offset::kYSubscriptYSize);
+int32_t OS2Table::YSubscriptYSize() {
+ return data_->ReadShort(Offset::kYSubscriptYSize);
}
-int32_t OS2Table::ySubscriptXOffset() {
- return data_->readShort(Offset::kYSubscriptXOffset);
+int32_t OS2Table::YSubscriptXOffset() {
+ return data_->ReadShort(Offset::kYSubscriptXOffset);
}
-int32_t OS2Table::ySubscriptYOffset() {
- return data_->readShort(Offset::kYSubscriptYOffset);
+int32_t OS2Table::YSubscriptYOffset() {
+ return data_->ReadShort(Offset::kYSubscriptYOffset);
}
-int32_t OS2Table::ySuperscriptXSize() {
- return data_->readShort(Offset::kYSuperscriptXSize);
+int32_t OS2Table::YSuperscriptXSize() {
+ return data_->ReadShort(Offset::kYSuperscriptXSize);
}
-int32_t OS2Table::ySuperscriptYSize() {
- return data_->readShort(Offset::kYSuperscriptYSize);
+int32_t OS2Table::YSuperscriptYSize() {
+ return data_->ReadShort(Offset::kYSuperscriptYSize);
}
-int32_t OS2Table::ySuperscriptXOffset() {
- return data_->readShort(Offset::kYSuperscriptXOffset);
+int32_t OS2Table::YSuperscriptXOffset() {
+ return data_->ReadShort(Offset::kYSuperscriptXOffset);
}
-int32_t OS2Table::ySuperscriptYOffset() {
- return data_->readShort(Offset::kYSuperscriptYOffset);
+int32_t OS2Table::YSuperscriptYOffset() {
+ return data_->ReadShort(Offset::kYSuperscriptYOffset);
}
-int32_t OS2Table::yStrikeoutSize() {
- return data_->readShort(Offset::kYStrikeoutSize);
+int32_t OS2Table::YStrikeoutSize() {
+ return data_->ReadShort(Offset::kYStrikeoutSize);
}
-int32_t OS2Table::yStrikeoutPosition() {
- return data_->readShort(Offset::kYStrikeoutPosition);
+int32_t OS2Table::YStrikeoutPosition() {
+ return data_->ReadShort(Offset::kYStrikeoutPosition);
}
-int32_t OS2Table::sFamilyClass() {
- return data_->readShort(Offset::kSFamilyClass);
+int32_t OS2Table::SFamilyClass() {
+ return data_->ReadShort(Offset::kSFamilyClass);
}
-void OS2Table::panose(ByteVector* value) {
+void OS2Table::Panose(ByteVector* value) {
value->clear();
value->resize(10);
- data_->readBytes(Offset::kPanose, value, 0, 10);
+ data_->ReadBytes(Offset::kPanose, value, 0, 10);
}
-int64_t OS2Table::ulUnicodeRange1() {
- return data_->readULong(Offset::kUlUnicodeRange1);
+int64_t OS2Table::UlUnicodeRange1() {
+ return data_->ReadULong(Offset::kUlUnicodeRange1);
}
-int64_t OS2Table::ulUnicodeRange2() {
- return data_->readULong(Offset::kUlUnicodeRange2);
+int64_t OS2Table::UlUnicodeRange2() {
+ return data_->ReadULong(Offset::kUlUnicodeRange2);
}
-int64_t OS2Table::ulUnicodeRange3() {
- return data_->readULong(Offset::kUlUnicodeRange3);
+int64_t OS2Table::UlUnicodeRange3() {
+ return data_->ReadULong(Offset::kUlUnicodeRange3);
}
-int64_t OS2Table::ulUnicodeRange4() {
- return data_->readULong(Offset::kUlUnicodeRange4);
+int64_t OS2Table::UlUnicodeRange4() {
+ return data_->ReadULong(Offset::kUlUnicodeRange4);
}
-void OS2Table::achVendId(ByteVector* b) {
+void OS2Table::AchVendId(ByteVector* b) {
b->clear();
b->resize(4);
- data_->readBytes(Offset::kAchVendId, b, 0, 4);
+ data_->ReadBytes(Offset::kAchVendId, b, 0, 4);
}
-int32_t OS2Table::fsSelection() {
- return data_->readUShort(Offset::kFsSelection);
+int32_t OS2Table::FsSelection() {
+ return data_->ReadUShort(Offset::kFsSelection);
}
-int32_t OS2Table::usFirstCharIndex() {
- return data_->readUShort(Offset::kUsFirstCharIndex);
+int32_t OS2Table::UsFirstCharIndex() {
+ return data_->ReadUShort(Offset::kUsFirstCharIndex);
}
-int32_t OS2Table::usLastCharIndex() {
- return data_->readUShort(Offset::kUsLastCharIndex);
+int32_t OS2Table::UsLastCharIndex() {
+ return data_->ReadUShort(Offset::kUsLastCharIndex);
}
-int32_t OS2Table::sTypoAscender() {
- return data_->readShort(Offset::kSTypoAscender);
+int32_t OS2Table::STypoAscender() {
+ return data_->ReadShort(Offset::kSTypoAscender);
}
-int32_t OS2Table::sTypoDecender() {
- return data_->readShort(Offset::kSTypoDescender);
+int32_t OS2Table::STypoDecender() {
+ return data_->ReadShort(Offset::kSTypoDescender);
}
-int32_t OS2Table::sTypoLineGap() {
- return data_->readShort(Offset::kSTypoLineGap);
+int32_t OS2Table::STypoLineGap() {
+ return data_->ReadShort(Offset::kSTypoLineGap);
}
-int32_t OS2Table::usWinAscent() {
- return data_->readUShort(Offset::kUsWinAscent);
+int32_t OS2Table::UsWinAscent() {
+ return data_->ReadUShort(Offset::kUsWinAscent);
}
-int32_t OS2Table::usWinDescent() {
- return data_->readUShort(Offset::kUsWinDescent);
+int32_t OS2Table::UsWinDescent() {
+ return data_->ReadUShort(Offset::kUsWinDescent);
}
-int64_t OS2Table::ulCodePageRange1() {
- return data_->readULong(Offset::kUlCodePageRange1);
+int64_t OS2Table::UlCodePageRange1() {
+ return data_->ReadULong(Offset::kUlCodePageRange1);
}
-int64_t OS2Table::ulCodePageRange2() {
- return data_->readULong(Offset::kUlCodePageRange2);
+int64_t OS2Table::UlCodePageRange2() {
+ return data_->ReadULong(Offset::kUlCodePageRange2);
}
-int64_t OS2Table::ulCodePageRange() {
- return ((0xffffffff & ulCodePageRange2()) << 32) |
- (0xffffffff & ulCodePageRange1());
+int64_t OS2Table::UlCodePageRange() {
+ // TODO(arthurhsu): Possible bug point, check with stuartg.
+ return ((0xffffffff & UlCodePageRange2()) << 32) |
+ (0xffffffff & UlCodePageRange1());
}
-int32_t OS2Table::sxHeight() {
- return data_->readShort(Offset::kSxHeight);
+int32_t OS2Table::SxHeight() {
+ return data_->ReadShort(Offset::kSxHeight);
}
-int32_t OS2Table::usDefaultChar() {
- return data_->readUShort(Offset::kUsDefaultChar);
+int32_t OS2Table::UsDefaultChar() {
+ return data_->ReadUShort(Offset::kUsDefaultChar);
}
-int32_t OS2Table::usBreakChar() {
- return data_->readUShort(Offset::kUsBreakChar);
+int32_t OS2Table::UsBreakChar() {
+ return data_->ReadUShort(Offset::kUsBreakChar);
}
-int32_t OS2Table::usMaxContext() {
- return data_->readUShort(Offset::kUsMaxContext);
+int32_t OS2Table::UsMaxContext() {
+ return data_->ReadUShort(Offset::kUsMaxContext);
+}
+
+OS2Table::OS2Table(Header* header, ReadableFontData* data)
+ : Table(header, data) {
}
/******************************************************************************
@@ -267,10 +268,10 @@
OS2Table::Builder::~Builder() {}
-CALLER_ATTACH FontDataTable* OS2Table::Builder::subBuildTable(
+CALLER_ATTACH FontDataTable* OS2Table::Builder::SubBuildTable(
ReadableFontData* data) {
FontDataTablePtr table = new OS2Table(header(), data);
- return table.detach();
+ return table.Detach();
}
} // namespace sfntly
diff --git a/sfntly/os2_table.h b/sfntly/os2_table.h
index 9bf33c2..058435a 100644
--- a/sfntly/os2_table.h
+++ b/sfntly/os2_table.h
@@ -300,6 +300,61 @@
};
class OS2Table : public Table, public RefCounted<OS2Table> {
+ public:
+ class Builder : public Table::TableBasedTableBuilder,
+ public RefCounted<Builder> {
+ public:
+ Builder(FontDataTableBuilderContainer* font_builder, Header* header,
+ WritableFontData* data);
+ virtual ~Builder();
+ virtual CALLER_ATTACH FontDataTable* SubBuildTable(ReadableFontData* data);
+ };
+
+ ~OS2Table();
+
+ int32_t Version();
+ int32_t XAvgCharWidth();
+ int32_t UsWeightClass();
+ int32_t UsWidthClass();
+ // UNIMPLEMENTED: public EnumSet<EmbeddingFlags> fsType()
+ int32_t FsType();
+ int32_t YSubscriptXSize();
+ int32_t YSubscriptYSize();
+ int32_t YSubscriptXOffset();
+ int32_t YSubscriptYOffset();
+ int32_t YSuperscriptXSize();
+ int32_t YSuperscriptYSize();
+ int32_t YSuperscriptXOffset();
+ int32_t YSuperscriptYOffset();
+ int32_t YStrikeoutSize();
+ int32_t YStrikeoutPosition();
+ int32_t SFamilyClass();
+ void Panose(ByteVector* value);
+ int64_t UlUnicodeRange1();
+ int64_t UlUnicodeRange2();
+ int64_t UlUnicodeRange3();
+ int64_t UlUnicodeRange4();
+ // UNIMPLEMENTED: public EnumSet<UnicodeRange> UlUnicodeRange()
+ void AchVendId(ByteVector* b);
+ // UNIMPLEMENTED: public EnumSet<FsSelection> fsSelection()
+ int32_t FsSelection();
+ int32_t UsFirstCharIndex();
+ int32_t UsLastCharIndex();
+ int32_t STypoAscender();
+ int32_t STypoDecender();
+ int32_t STypoLineGap();
+ int32_t UsWinAscent();
+ int32_t UsWinDescent();
+ int64_t UlCodePageRange1();
+ int64_t UlCodePageRange2();
+ // UNIMPLEMENTED: public EnumSet<CodePageRange> ulCodePageRange()
+ int64_t UlCodePageRange();
+ int32_t SxHeight();
+ int32_t SCapHeight();
+ int32_t UsDefaultChar();
+ int32_t UsBreakChar();
+ int32_t UsMaxContext();
+
private:
struct Offset {
enum {
@@ -344,62 +399,6 @@
};
OS2Table(Header* header, ReadableFontData* data);
-
- public:
- ~OS2Table();
-
- int32_t version();
- int32_t xAvgCharWidth();
- int32_t usWeightClass();
- int32_t usWidthClass();
- // UNIMPLEMENTED: public EnumSet<EmbeddingFlags> fsType()
- int32_t fsType();
- int32_t ySubscriptXSize();
- int32_t ySubscriptYSize();
- int32_t ySubscriptXOffset();
- int32_t ySubscriptYOffset();
- int32_t ySuperscriptXSize();
- int32_t ySuperscriptYSize();
- int32_t ySuperscriptXOffset();
- int32_t ySuperscriptYOffset();
- int32_t yStrikeoutSize();
- int32_t yStrikeoutPosition();
- int32_t sFamilyClass();
- void panose(ByteVector* value);
- int64_t ulUnicodeRange1();
- int64_t ulUnicodeRange2();
- int64_t ulUnicodeRange3();
- int64_t ulUnicodeRange4();
- // UNIMPLEMENTED: public EnumSet<UnicodeRange> ulUnicodeRange()
- void achVendId(ByteVector* b);
- // UNIMPLEMENTED: public EnumSet<FsSelection> fsSelection()
- int32_t fsSelection();
- int32_t usFirstCharIndex();
- int32_t usLastCharIndex();
- int32_t sTypoAscender();
- int32_t sTypoDecender();
- int32_t sTypoLineGap();
- int32_t usWinAscent();
- int32_t usWinDescent();
- int64_t ulCodePageRange1();
- int64_t ulCodePageRange2();
- // UNIMPLEMENTED: public EnumSet<CodePageRange> ulCodePageRange()
- int64_t ulCodePageRange();
- int32_t sxHeight();
- int32_t sCapHeight();
- int32_t usDefaultChar();
- int32_t usBreakChar();
- int32_t usMaxContext();
-
- public:
- class Builder : public Table::TableBasedTableBuilder,
- public RefCounted<Builder> {
- public:
- Builder(FontDataTableBuilderContainer* font_builder, Header* header,
- WritableFontData* data);
- virtual ~Builder();
- virtual CALLER_ATTACH FontDataTable* subBuildTable(ReadableFontData* data);
- };
};
} // namespace sfntly
diff --git a/sfntly/port/atomic.h b/sfntly/port/atomic.h
index 4c2d65b..abfc429 100644
--- a/sfntly/port/atomic.h
+++ b/sfntly/port/atomic.h
@@ -21,7 +21,7 @@
#include <windows.h>
-static inline size_t atomicIncrement(size_t* address) {
+static inline size_t AtomicIncrement(size_t* address) {
#if defined (_WIN64)
return InterlockedIncrement64(reinterpret_cast<LONGLONG*>(address));
#else
@@ -29,7 +29,7 @@
#endif
}
-static inline size_t atomicDecrement(size_t* address) {
+static inline size_t AtomicDecrement(size_t* address) {
#if defined (_WIN64)
return InterlockedDecrement64(reinterpret_cast<LONGLONG*>(address));
#else
@@ -41,11 +41,11 @@
#include <libkern/OSAtomic.h>
-static inline size_t atomicIncrement(size_t* address) {
+static inline size_t AtomicIncrement(size_t* address) {
return OSAtomicIncrement32Barrier(reinterpret_cast<int32_t*>(address));
}
-static inline size_t atomicDecrement(size_t* address) {
+static inline size_t AtomicDecrement(size_t* address) {
return OSAtomicDecrement32Barrier(reinterpret_cast<int32_t*>(address));
}
@@ -58,11 +58,11 @@
#include <stddef.h>
-static inline size_t atomicIncrement(size_t* address) {
+static inline size_t AtomicIncrement(size_t* address) {
return __sync_add_and_fetch(address, 1);
}
-static inline size_t atomicDecrement(size_t* address) {
+static inline size_t AtomicDecrement(size_t* address) {
return __sync_sub_and_fetch(address, 1);
}
diff --git a/sfntly/port/endian.h b/sfntly/port/endian.h
index c6898ee..1364e42 100644
--- a/sfntly/port/endian.h
+++ b/sfntly/port/endian.h
@@ -22,18 +22,18 @@
namespace sfntly {
-static inline uint16_t endian_swap16(uint16_t value) {
+static inline uint16_t EndianSwap16(uint16_t value) {
return (uint16_t)((value >> 8) | (value << 8));
}
-static inline int32_t endian_swap32(int32_t value) {
+static inline int32_t EndianSwap32(int32_t value) {
return (((value & 0x000000ff) << 24) |
((value & 0x0000ff00) << 8) |
((value & 0x00ff0000) >> 8) |
((value & 0xff000000) >> 24));
}
-static inline uint64_t endian_swap64(uint64_t value) {
+static inline uint64_t EndianSwap64(uint64_t value) {
return (((value & 0x00000000000000ffLL) << 56) |
((value & 0x000000000000ff00LL) << 40) |
((value & 0x0000000000ff0000LL) << 24) |
@@ -45,31 +45,31 @@
}
#ifdef SFNTLY_LITTLE_ENDIAN
- #define toBE16(n) endian_swap16(n)
- #define toBE32(n) endian_swap32(n)
- #define toBE64(n) endian_swap64(n)
- #define toLE16(n) (n)
- #define toLE32(n) (n)
- #define toLE64(n) (n)
- #define fromBE16(n) endian_swap16(n)
- #define fromBE32(n) endian_swap32(n)
- #define fromBE64(n) endian_swap64(n)
- #define fromLE16(n) (n)
- #define fromLE32(n) (n)
- #define fromLE64(n) (n)
+ #define ToBE16(n) EndianSwap16(n)
+ #define ToBE32(n) EndianSwap32(n)
+ #define ToBE64(n) EndianSwap64(n)
+ #define ToLE16(n) (n)
+ #define ToLE32(n) (n)
+ #define ToLE64(n) (n)
+ #define FromBE16(n) EndianSwap16(n)
+ #define FromBE32(n) EndianSwap32(n)
+ #define FromBE64(n) EndianSwap64(n)
+ #define FromLE16(n) (n)
+ #define FromLE32(n) (n)
+ #define FromLE64(n) (n)
#else // SFNTLY_BIG_ENDIAN
- #define toBE16(n) (n)
- #define toBE32(n) (n)
- #define toBE64(n) (n)
- #define toLE16(n) endian_swap16(n)
- #define toLE32(n) endian_swap32(n)
- #define toLE64(n) endian_swap64(n)
- #define fromBE16(n) (n)
- #define fromBE32(n) (n)
- #define fromBE64(n) (n)
- #define fromLE16(n) endian_swap16(n)
- #define fromLE32(n) endian_swap32(n)
- #define fromLE64(n) endian_swap64(n)
+ #define ToBE16(n) (n)
+ #define ToBE32(n) (n)
+ #define ToBE64(n) (n)
+ #define ToLE16(n) EndianSwap16(n)
+ #define ToLE32(n) EndianSwap32(n)
+ #define ToLE64(n) EndianSwap64(n)
+ #define FromBE16(n) (n)
+ #define FromBE32(n) (n)
+ #define FromBE64(n) (n)
+ #define FromLE16(n) EndianSwap16(n)
+ #define FromLE32(n) EndianSwap32(n)
+ #define FromLE64(n) EndianSwap64(n)
#endif
} // namespace sfntly
diff --git a/sfntly/port/file_input_stream.cc b/sfntly/port/file_input_stream.cc
index 04a0fd6..661b6fd 100644
--- a/sfntly/port/file_input_stream.cc
+++ b/sfntly/port/file_input_stream.cc
@@ -23,38 +23,21 @@
namespace sfntly {
-FileInputStream::FileInputStream() : file_(NULL), position_(0), length_(0) {
+FileInputStream::FileInputStream()
+ : file_(NULL),
+ position_(0),
+ length_(0) {
}
FileInputStream::~FileInputStream() {
- close();
+ Close();
}
-int32_t FileInputStream::available() {
+int32_t FileInputStream::Available() {
return length_ - position_;
}
-bool FileInputStream::open(const char* file_path) {
- assert(file_path);
- if (file_) {
- close();
- }
-#if defined (WIN32)
- fopen_s(&file_, file_path, "rb");
-#else
- file_ = fopen(file_path, "rb");
-#endif
- if (file_ == NULL) {
- return false;
- }
-
- fseek(file_, 0, SEEK_END);
- length_ = ftell(file_);
- fseek(file_, 0, SEEK_SET);
- return true;
-}
-
-void FileInputStream::close() {
+void FileInputStream::Close() {
if (file_) {
fclose(file_);
length_ = 0;
@@ -63,16 +46,16 @@
}
}
-void FileInputStream::mark(int32_t readlimit) {
+void FileInputStream::Mark(int32_t readlimit) {
// NOP
UNREFERENCED_PARAMETER(readlimit);
}
-bool FileInputStream::markSupported() {
+bool FileInputStream::MarkSupported() {
return false;
}
-int32_t FileInputStream::read() {
+int32_t FileInputStream::Read() {
if (!file_) {
#if defined (SFNTLY_NO_EXCEPTION)
return 0;
@@ -93,11 +76,11 @@
return value;
}
-int32_t FileInputStream::read(ByteVector* b) {
- return read(b, 0, b->capacity());
+int32_t FileInputStream::Read(ByteVector* b) {
+ return Read(b, 0, b->capacity());
}
-int32_t FileInputStream::read(ByteVector* b, int32_t offset, int32_t length) {
+int32_t FileInputStream::Read(ByteVector* b, int32_t offset, int32_t length) {
assert(b);
if (!file_) {
#if defined (SFNTLY_NO_EXCEPTION)
@@ -122,11 +105,11 @@
return actual_read;
}
-void FileInputStream::reset() {
+void FileInputStream::Reset() {
// NOP
}
-int64_t FileInputStream::skip(int64_t n) {
+int64_t FileInputStream::Skip(int64_t n) {
if (!file_) {
#if defined (SFNTLY_NO_EXCEPTION)
return 0;
@@ -147,11 +130,11 @@
return skip_count;
}
-void FileInputStream::unread(ByteVector* b) {
- unread(b, 0, b->capacity());
+void FileInputStream::Unread(ByteVector* b) {
+ Unread(b, 0, b->capacity());
}
-void FileInputStream::unread(ByteVector* b, int32_t offset, int32_t length) {
+void FileInputStream::Unread(ByteVector* b, int32_t offset, int32_t length) {
assert(b);
assert(b->size() >= size_t(offset + length));
if (!file_) {
@@ -164,9 +147,29 @@
size_t unread_count = std::min<size_t>(position_, length);
fseek(file_, position_ - unread_count, SEEK_SET);
position_ -= unread_count;
- read(b, offset, length);
+ Read(b, offset, length);
fseek(file_, position_ - unread_count, SEEK_SET);
position_ -= unread_count;
}
+bool FileInputStream::Open(const char* file_path) {
+ assert(file_path);
+ if (file_) {
+ Close();
+ }
+#if defined (WIN32)
+ fopen_s(&file_, file_path, "rb");
+#else
+ file_ = fopen(file_path, "rb");
+#endif
+ if (file_ == NULL) {
+ return false;
+ }
+
+ fseek(file_, 0, SEEK_END);
+ length_ = ftell(file_);
+ fseek(file_, 0, SEEK_SET);
+ return true;
+}
+
} // namespace sfntly
diff --git a/sfntly/port/file_input_stream.h b/sfntly/port/file_input_stream.h
index 0ec85b6..a63726f 100644
--- a/sfntly/port/file_input_stream.h
+++ b/sfntly/port/file_input_stream.h
@@ -29,22 +29,22 @@
virtual ~FileInputStream();
// InputStream methods
- virtual int32_t available();
- virtual void close();
- virtual void mark(int32_t readlimit);
- virtual bool markSupported();
- virtual int32_t read();
- virtual int32_t read(ByteVector* b);
- virtual int32_t read(ByteVector* b, int32_t offset, int32_t length);
- virtual void reset();
- virtual int64_t skip(int64_t n);
+ virtual int32_t Available();
+ virtual void Close();
+ virtual void Mark(int32_t readlimit);
+ virtual bool MarkSupported();
+ virtual int32_t Read();
+ virtual int32_t Read(ByteVector* b);
+ virtual int32_t Read(ByteVector* b, int32_t offset, int32_t length);
+ virtual void Reset();
+ virtual int64_t Skip(int64_t n);
// PushbackInputStream methods
- virtual void unread(ByteVector* b);
- virtual void unread(ByteVector* b, int32_t offset, int32_t length);
+ virtual void Unread(ByteVector* b);
+ virtual void Unread(ByteVector* b, int32_t offset, int32_t length);
// Own methods
- virtual bool open(const char* file_path);
+ virtual bool Open(const char* file_path);
private:
FILE* file_;
diff --git a/sfntly/port/input_stream.h b/sfntly/port/input_stream.h
index ebbccf0..a56afb9 100644
--- a/sfntly/port/input_stream.h
+++ b/sfntly/port/input_stream.h
@@ -24,23 +24,24 @@
// C++ equivalent to Java's OutputStream class
class InputStream {
public:
- virtual int32_t available() = 0;
- virtual void close() = 0;
- virtual void mark(int32_t readlimit) = 0;
- virtual bool markSupported() = 0;
- virtual int32_t read() = 0;
- virtual int32_t read(ByteVector* b) = 0;
- virtual int32_t read(ByteVector* b, int32_t offset, int32_t length) = 0;
- virtual void reset() = 0;
- virtual int64_t skip(int64_t n) = 0;
// Make gcc -Wnon-virtual-dtor happy.
virtual ~InputStream() {}
+
+ virtual int32_t Available() = 0;
+ virtual void Close() = 0;
+ virtual void Mark(int32_t readlimit) = 0;
+ virtual bool MarkSupported() = 0;
+ virtual int32_t Read() = 0;
+ virtual int32_t Read(ByteVector* b) = 0;
+ virtual int32_t Read(ByteVector* b, int32_t offset, int32_t length) = 0;
+ virtual void Reset() = 0;
+ virtual int64_t Skip(int64_t n) = 0;
};
class PushbackInputStream : public InputStream {
public:
- virtual void unread(ByteVector* b) = 0;
- virtual void unread(ByteVector* b, int32_t offset, int32_t length) = 0;
+ virtual void Unread(ByteVector* b) = 0;
+ virtual void Unread(ByteVector* b, int32_t offset, int32_t length) = 0;
};
} // namespace sfntly
diff --git a/sfntly/port/memory_output_stream.cc b/sfntly/port/memory_output_stream.cc
index 1f3ecd4..5ddeec2 100644
--- a/sfntly/port/memory_output_stream.cc
+++ b/sfntly/port/memory_output_stream.cc
@@ -24,25 +24,27 @@
MemoryOutputStream::~MemoryOutputStream() {
}
-void MemoryOutputStream::write(ByteVector* buffer) {
+void MemoryOutputStream::Write(ByteVector* buffer) {
store_.insert(store_.end(), buffer->begin(), buffer->end());
}
-void MemoryOutputStream::write(ByteVector* buffer, int32_t offset,
+void MemoryOutputStream::Write(ByteVector* buffer,
+ int32_t offset,
int32_t length) {
- store_.insert(store_.end(), buffer->begin() + offset,
+ store_.insert(store_.end(),
+ buffer->begin() + offset,
buffer->begin() + offset + length);
}
-void MemoryOutputStream::write(byte_t b) {
+void MemoryOutputStream::Write(byte_t b) {
store_.push_back(b);
}
-byte_t* MemoryOutputStream::get() {
+byte_t* MemoryOutputStream::Get() {
return &(store_[0]);
}
-size_t MemoryOutputStream::size() {
+size_t MemoryOutputStream::Size() {
return store_.size();
}
diff --git a/sfntly/port/memory_output_stream.h b/sfntly/port/memory_output_stream.h
index 4a7cb74..a0befea 100644
--- a/sfntly/port/memory_output_stream.h
+++ b/sfntly/port/memory_output_stream.h
@@ -32,14 +32,14 @@
MemoryOutputStream();
virtual ~MemoryOutputStream();
- virtual void close() {} // no-op
- virtual void flush() {} // no-op
- virtual void write(ByteVector* buffer);
- virtual void write(ByteVector* buffer, int32_t offset, int32_t length);
- virtual void write(byte_t b);
+ virtual void Close() {} // no-op
+ virtual void Flush() {} // no-op
+ virtual void Write(ByteVector* buffer);
+ virtual void Write(ByteVector* buffer, int32_t offset, int32_t length);
+ virtual void Write(byte_t b);
- byte_t* get();
- size_t size();
+ byte_t* Get();
+ size_t Size();
private:
std::vector<byte_t> store_;
diff --git a/sfntly/port/output_stream.h b/sfntly/port/output_stream.h
index 0b232e2..c5d71cf 100644
--- a/sfntly/port/output_stream.h
+++ b/sfntly/port/output_stream.h
@@ -24,13 +24,14 @@
// C++ equivalent to Java's OutputStream class
class OutputStream {
public:
- virtual void close() = 0;
- virtual void flush() = 0;
- virtual void write(ByteVector* buffer) = 0;
- virtual void write(ByteVector* buffer, int32_t offset, int32_t length) = 0;
- virtual void write(byte_t b) = 0;
// Make gcc -Wnon-virtual-dtor happy.
virtual ~OutputStream() {}
+
+ virtual void Close() = 0;
+ virtual void Flush() = 0;
+ virtual void Write(ByteVector* buffer) = 0;
+ virtual void Write(ByteVector* buffer, int32_t offset, int32_t length) = 0;
+ virtual void Write(byte_t b) = 0;
};
} // namespace sfntly
diff --git a/sfntly/port/refcount.h b/sfntly/port/refcount.h
index ed1fa96..6ac09bb 100644
--- a/sfntly/port/refcount.h
+++ b/sfntly/port/refcount.h
@@ -27,16 +27,16 @@
// public:
// static Foo* CreateInstance() {
// Ptr<Foo> obj = new Foo(); // ref count = 1
-// return obj.detach();
+// return obj.Detach();
// }
// };
// typedef Ptr<Foo> FooPtr; // common short-hand notation
// FooPtr obj;
-// obj.attach(Foo::CreatedInstance()); // ref count = 1
+// obj.Attach(Foo::CreatedInstance()); // ref count = 1
// {
// FooPtr obj2 = obj; // ref count = 2
// } // ref count = 1, obj2 out of scope
-// obj.release(); // ref count = 0, object destroyed
+// obj.Release(); // ref count = 0, object destroyed
// Notes on usage:
// 1. Virtual inherit from RefCount interface in base class if smart pointers
@@ -57,10 +57,10 @@
// VC++ will generate SEH which is not handled well in VC++ debugger. One
// can use WinDBG to run it and get the faulting stack.
// 6. Idioms for heap object as return value
-// Foo* createFoo() { FooPtr obj = new Foo(); return obj.detach(); }
+// Foo* createFoo() { FooPtr obj = new Foo(); return obj.Detach(); }
// Foo* passthru() { FooPtr obj = createFoo(), return obj; }
// FooPtr end_scope_pointer;
-// end_scope_pointer.attach(passThrough);
+// end_scope_pointer.Attach(passThrough);
// If you are not passing that object back, you are the end of scope.
#ifndef TYPOGRAPHY_FONT_SFNTLY_SRC_SFNTLY_PORT_REFCOUNT_H_
@@ -101,10 +101,11 @@
class RefCount {
public:
- virtual size_t addRef() const = 0;
- virtual size_t release() const = 0;
// Make gcc -Wnon-virtual-dtor happy.
virtual ~RefCount() {}
+
+ virtual size_t AddRef() const = 0;
+ virtual size_t Release() const = 0;
};
template <typename T>
@@ -114,8 +115,8 @@
~NoAddRefRelease();
private:
- virtual size_t addRef() const = 0;
- virtual size_t release() const = 0;
+ virtual size_t AddRef() const = 0;
+ virtual size_t Release() const = 0;
};
template <typename TDerived>
@@ -123,15 +124,15 @@
public:
RefCounted() : ref_count_(0) {
#if defined (ENABLE_OBJECT_COUNTER)
- object_id_ = atomicIncrement(&next_id_);
- atomicIncrement(&object_counter_);
+ object_id_ = AtomicIncrement(&next_id_);
+ AtomicIncrement(&object_counter_);
DEBUG_OUTPUT("C ");
#endif
}
RefCounted(const RefCounted<TDerived>&) : ref_count_(0) {}
virtual ~RefCounted() {
#if defined (ENABLE_OBJECT_COUNTER)
- atomicDecrement(&object_counter_);
+ AtomicDecrement(&object_counter_);
DEBUG_OUTPUT("D ");
#endif
}
@@ -141,14 +142,14 @@
return *this;
}
- virtual size_t addRef() const {
- size_t new_count = atomicIncrement(&ref_count_);
+ virtual size_t AddRef() const {
+ size_t new_count = AtomicIncrement(&ref_count_);
DEBUG_OUTPUT("A ");
return new_count;
}
- virtual size_t release() const {
- size_t new_ref_count = atomicDecrement(&ref_count_);
+ virtual size_t Release() const {
+ size_t new_ref_count = AtomicDecrement(&ref_count_);
DEBUG_OUTPUT("R ");
if (new_ref_count == 0) {
// A C-style is used to cast away const-ness and to derived.
@@ -189,7 +190,7 @@
}
~Ptr() {
- release();
+ Release();
}
T* operator=(T* pT) {
@@ -201,9 +202,9 @@
if (p == NULL) {
return NULL;
}
- p->addRef(); // always addRef() before release()
+ p->AddRef(); // always AddRef() before Release()
}
- release();
+ Release();
p_ = pT;
return p_;
}
@@ -243,26 +244,26 @@
return (p_ == pT);
}
- size_t release() const {
+ size_t Release() const {
size_t ref_count = 0;
if (p_) {
RefCount* p = static_cast<RefCount*>(p_);
if (p) {
- ref_count = p->release();
+ ref_count = p->Release();
}
p_ = NULL;
}
return ref_count;
}
- void attach(T* pT) {
+ void Attach(T* pT) {
if (p_ != pT) {
- release();
+ Release();
p_ = pT;
}
}
- T* detach() {
+ T* Detach() {
T* pT = p_;
p_ = NULL;
return pT;
diff --git a/sfntly/subtable.cc b/sfntly/subtable.cc
index 9ca94f3..782fd80 100644
--- a/sfntly/subtable.cc
+++ b/sfntly/subtable.cc
@@ -20,24 +20,25 @@
/******************************************************************************
* SubTable class
******************************************************************************/
-SubTable::SubTable(ReadableFontData* data) : FontDataTable(data) {
-}
-
SubTable::~SubTable() {}
+SubTable::SubTable(ReadableFontData* data)
+ : FontDataTable(data) {
+}
+
/******************************************************************************
* SubTable::Builder class
******************************************************************************/
-SubTable::Builder::Builder(FontDataTableBuilderContainer* container,
- WritableFontData* data) :
- FontDataTable::Builder(container, data) {
-}
-
-SubTable::Builder::Builder(FontDataTableBuilderContainer* container,
- ReadableFontData* data) :
- FontDataTable::Builder(container, data) {
-}
-
SubTable::Builder::~Builder() {}
+SubTable::Builder::Builder(FontDataTableBuilderContainer* container,
+ WritableFontData* data)
+ : FontDataTable::Builder(container, data) {
+}
+
+SubTable::Builder::Builder(FontDataTableBuilderContainer* container,
+ ReadableFontData* data)
+ : FontDataTable::Builder(container, data) {
+}
+
} // namespace sfntly
diff --git a/sfntly/subtable.h b/sfntly/subtable.h
index 23e1e42..30ecf66 100644
--- a/sfntly/subtable.h
+++ b/sfntly/subtable.h
@@ -26,23 +26,22 @@
// of these are the CMap subtables within CMap table (cmap) or a glyph within
// the glyph table (glyf).
class SubTable : public FontDataTable {
- protected:
- // Note: constructor refactored in C++ to avoid heavy lifting.
- // caller need to do data->slice(offset, length) beforehand.
- explicit SubTable(ReadableFontData* data);
-
- public:
- virtual ~SubTable();
-
public:
class Builder : public FontDataTable::Builder {
+ public:
+ virtual ~Builder();
+
protected:
Builder(FontDataTableBuilderContainer* container, WritableFontData* data);
Builder(FontDataTableBuilderContainer* container, ReadableFontData* data);
-
- public:
- virtual ~Builder();
};
+
+ virtual ~SubTable();
+
+ protected:
+ // Note: constructor refactored in C++ to avoid heavy lifting.
+ // caller need to do data->Slice(offset, length) beforehand.
+ explicit SubTable(ReadableFontData* data);
};
} // namespace sfntly
diff --git a/sfntly/table.cc b/sfntly/table.cc
index 8a1ec02..a11177e 100644
--- a/sfntly/table.cc
+++ b/sfntly/table.cc
@@ -15,6 +15,7 @@
*/
#include "sfntly/table.h"
+
#include "sfntly/font.h"
#include "sfntly/tag.h"
#include "sfntly/cmap_table.h"
@@ -32,61 +33,56 @@
/******************************************************************************
* Table class
******************************************************************************/
-Table::Table(Header* header, ReadableFontData* data) : FontDataTable(data) {
- header_ = header;
-}
-
Table::~Table() {}
-int64_t Table::calculatedChecksum() {
- return data_->checksum();
+int64_t Table::CalculatedChecksum() {
+ return data_->Checksum();
}
-Table::Header* Table::header() {
- return header_;
+WritableFontData* Table::GetNewData(int32_t size) {
+ return font_->GetNewData(size);
}
-int32_t Table::headerTag() {
- return header_->tag();
-}
-
-int32_t Table::headerOffset() {
- return header_->offset();
-}
-
-int32_t Table::headerLength() {
- return header_->length();
-}
-
-int64_t Table::headerChecksum() {
- return header_->checksum();
-}
-
-WritableFontData* Table::getNewData(int32_t size) {
- return font_->getNewData(size);
-}
-
-void Table::setFont(Font* font) {
+void Table::SetFont(Font* font) {
font_ = font;
}
+Table::Table(Header* header, ReadableFontData* data)
+ : FontDataTable(data) {
+ header_ = header;
+}
+
/******************************************************************************
* Table::Header class
******************************************************************************/
Table::Header::Header(int32_t tag)
- : tag_(tag), offset_(0), length_(0), offset_valid_(false), checksum_(0),
+ : tag_(tag),
+ offset_(0),
+ length_(0),
+ offset_valid_(false),
+ checksum_(0),
checksum_valid_(false) {
}
Table::Header::Header(int32_t tag, int32_t length)
- : tag_(tag), offset_(0), length_(length), offset_valid_(false),
- checksum_(0), checksum_valid_(false) {
+ : tag_(tag),
+ offset_(0),
+ length_(length),
+ offset_valid_(false),
+ checksum_(0),
+ checksum_valid_(false) {
}
-Table::Header::Header(int32_t tag, int64_t checksum, int32_t offset,
+Table::Header::Header(int32_t tag,
+ int64_t checksum,
+ int32_t offset,
int32_t length)
- : tag_(tag), offset_(offset), length_(length), offset_valid_(true),
- checksum_(checksum), checksum_valid_(true) {
+ : tag_(tag),
+ offset_(offset),
+ length_(length),
+ offset_valid_(true),
+ checksum_(checksum),
+ checksum_valid_(true) {
}
Table::Header::~Header() {}
@@ -96,58 +92,30 @@
return lhs->offset_ > rhs->offset_;
}
-int32_t Table::Header::tag() { return tag_; }
-int32_t Table::Header::offset() { return offset_; }
-int32_t Table::Header::length() { return length_; }
-bool Table::Header::offsetValid() { return offset_valid_; }
-int64_t Table::Header::checksum() { return checksum_; }
-bool Table::Header::checksumValid() { return checksum_valid_; }
-
/******************************************************************************
* Table::Builder class
******************************************************************************/
-Table::Builder::Builder(FontDataTableBuilderContainer* font_builder,
- Header* header, WritableFontData* data) :
- FontDataTable::Builder(font_builder, data) {
- header_ = header;
-}
-
-Table::Builder::Builder(FontDataTableBuilderContainer* font_builder,
- Header* header, ReadableFontData* data) :
- FontDataTable::Builder(font_builder, data) {
- header_ = header;
-}
-
-Table::Builder::Builder(FontDataTableBuilderContainer* font_builder,
- Header* header) :
- FontDataTable::Builder(font_builder) {
- header_ = header;
-}
-
Table::Builder::~Builder() {
- header_.release();
+ header_.Release();
}
-Table::Header* Table::Builder::header() {
- return header_;
-}
-
-void Table::Builder::notifyPostTableBuild(FontDataTable* table) {
- if (modelChanged() || dataChanged()) {
+void Table::Builder::NotifyPostTableBuild(FontDataTable* table) {
+ if (modelChanged() || data_changed()) {
Table* derived_table = down_cast<Table*>(table);
header_ = new Header(header()->tag(),
- derived_table->readFontData()->length());
+ derived_table->ReadFontData()->Length());
}
}
-WritableFontData* Table::Builder::getNewData(int32_t size) {
+WritableFontData* Table::Builder::GetNewData(int32_t size) {
UNREFERENCED_PARAMETER(size);
- return internalWriteData();
+ return InternalWriteData();
}
-CALLER_ATTACH Table::Builder* Table::Builder::getBuilder(
- FontDataTableBuilderContainer* font_builder, Header* header,
- WritableFontData* table_data) {
+CALLER_ATTACH Table::Builder*
+ Table::Builder::GetBuilder(FontDataTableBuilderContainer* font_builder,
+ Header* header,
+ WritableFontData* table_data) {
int32_t tag = header->tag();
TableBuilderPtr builder;
Table::Builder* builder_raw = NULL;
@@ -199,77 +167,113 @@
}
builder = builder_raw;
- return builder.detach();
+ return builder.Detach();
+}
+
+Table::Builder::Builder(FontDataTableBuilderContainer* font_builder,
+ Header* header,
+ WritableFontData* data)
+ : FontDataTable::Builder(font_builder, data) {
+ header_ = header;
+}
+
+Table::Builder::Builder(FontDataTableBuilderContainer* font_builder,
+ Header* header,
+ ReadableFontData* data)
+ : FontDataTable::Builder(font_builder, data) {
+ header_ = header;
+}
+
+Table::Builder::Builder(FontDataTableBuilderContainer* font_builder,
+ Header* header)
+ : FontDataTable::Builder(font_builder) {
+ header_ = header;
}
/******************************************************************************
* Table::TableBasedTableBuilder class
******************************************************************************/
-Table::TableBasedTableBuilder::TableBasedTableBuilder(
- FontDataTableBuilderContainer* font_builder, Header* header,
- WritableFontData* data) : Builder(font_builder, header, data) {}
-
-Table::TableBasedTableBuilder::TableBasedTableBuilder(
- FontDataTableBuilderContainer* font_builder, Header* header,
- ReadableFontData* data) : Builder(font_builder, header, data) {}
-
-Table::TableBasedTableBuilder::TableBasedTableBuilder(
- FontDataTableBuilderContainer* font_builder, Header* header) :
- Builder(font_builder, header) {}
-
Table::TableBasedTableBuilder::~TableBasedTableBuilder() {}
-Table* Table::TableBasedTableBuilder::table() {
- if (table_ == NULL) {
- table_.attach(down_cast<Table*>(subBuildTable(internalReadData())));
- }
- return table_;
-}
-
-void Table::TableBasedTableBuilder::subDataSet() {
- table_ = NULL;
-}
-
-int32_t Table::TableBasedTableBuilder::subDataSizeToSerialize() {
+int32_t Table::TableBasedTableBuilder::SubSerialize(WritableFontData* data) {
+ UNREFERENCED_PARAMETER(data);
return 0;
}
-bool Table::TableBasedTableBuilder::subReadyToSerialize() {
+bool Table::TableBasedTableBuilder::SubReadyToSerialize() {
return false;
}
-int32_t Table::TableBasedTableBuilder::subSerialize(WritableFontData* data) {
- UNREFERENCED_PARAMETER(data);
+int32_t Table::TableBasedTableBuilder::SubDataSizeToSerialize() {
return 0;
}
+void Table::TableBasedTableBuilder::SubDataSet() {
+ table_ = NULL;
+}
+
+Table::TableBasedTableBuilder::TableBasedTableBuilder(
+ FontDataTableBuilderContainer* font_builder,
+ Header* header,
+ WritableFontData* data)
+ : Builder(font_builder, header, data) {
+}
+
+Table::TableBasedTableBuilder::TableBasedTableBuilder(
+ FontDataTableBuilderContainer* font_builder,
+ Header* header,
+ ReadableFontData* data)
+ : Builder(font_builder, header, data) {
+}
+
+Table::TableBasedTableBuilder::TableBasedTableBuilder(
+ FontDataTableBuilderContainer* font_builder,
+ Header* header)
+ : Builder(font_builder, header) {
+}
+
+Table* Table::TableBasedTableBuilder::GetTable() {
+ if (table_ == NULL) {
+ table_.Attach(down_cast<Table*>(SubBuildTable(InternalReadData())));
+ }
+ return table_;
+}
+
/******************************************************************************
* Table::GenericTableBuilder class
******************************************************************************/
Table::GenericTableBuilder::GenericTableBuilder(
- FontDataTableBuilderContainer* font_builder, Header* header,
- WritableFontData* data) :
- TableBasedTableBuilder(font_builder, header, data) {}
+ FontDataTableBuilderContainer* font_builder,
+ Header* header,
+ WritableFontData* data)
+ : TableBasedTableBuilder(font_builder, header, data) {
+}
-CALLER_ATTACH FontDataTable* Table::GenericTableBuilder::subBuildTable(
- ReadableFontData* data) {
+CALLER_ATTACH FontDataTable*
+ Table::GenericTableBuilder::SubBuildTable(ReadableFontData* data) {
// Note: In C++ port, we use GenericTable, the ref-counted version of Table
UNREFERENCED_PARAMETER(data);
- FontDataTablePtr table = new GenericTable(this->header(), internalReadData());
- return table.detach();
+ FontDataTablePtr table = new GenericTable(this->header(), InternalReadData());
+ return table.Detach();
}
/******************************************************************************
* Table::ArrayElementTableBuilder class
******************************************************************************/
-Table::ArrayElementTableBuilder::ArrayElementTableBuilder(
- FontDataTableBuilderContainer* font_builder, Header* header,
- WritableFontData* data) : Builder(font_builder, header, data) {}
-
-Table::ArrayElementTableBuilder::ArrayElementTableBuilder(
- FontDataTableBuilderContainer* font_builder, Header* header,
- ReadableFontData* data) : Builder(font_builder, header, data) {}
-
Table::ArrayElementTableBuilder::~ArrayElementTableBuilder() {}
+Table::ArrayElementTableBuilder::ArrayElementTableBuilder(
+ FontDataTableBuilderContainer* font_builder,
+ Header* header,
+ WritableFontData* data)
+ : Builder(font_builder, header, data) {
+}
+
+Table::ArrayElementTableBuilder::ArrayElementTableBuilder(
+ FontDataTableBuilderContainer* font_builder,
+ Header* header,
+ ReadableFontData* data)
+ : Builder(font_builder, header, data) {
+}
+
} // namespace sfntly
diff --git a/sfntly/table.h b/sfntly/table.h
index 9f05ef5..217abcd 100644
--- a/sfntly/table.h
+++ b/sfntly/table.h
@@ -36,13 +36,12 @@
Header(int32_t tag, int64_t checksum, int32_t offset, int32_t length);
virtual ~Header();
- public: // class is final, no virtual functions unless from parent
- int32_t tag();
- int32_t offset();
- int32_t length();
- bool offsetValid();
- int64_t checksum();
- bool checksumValid();
+ int32_t tag() { return tag_; }
+ int32_t offset() { return offset_; }
+ int32_t length() { return length_; }
+ bool offset_valid() { return offset_valid_; }
+ int64_t checksum() { return checksum_; }
+ bool checksum_valid() { return checksum_valid_; }
private:
int32_t tag_;
@@ -60,89 +59,95 @@
// chosen.
class Builder : public FontDataTable::Builder,
public FontDataTableBuilderContainer {
+ public:
+ virtual ~Builder();
+ virtual Header* header() { return header_; }
+ virtual void NotifyPostTableBuild(FontDataTable* table);
+ virtual WritableFontData* GetNewData(int32_t size);
+
+ static CALLER_ATTACH Builder*
+ GetBuilder(FontDataTableBuilderContainer* font_builder,
+ Header* header,
+ WritableFontData* table_data);
+
protected:
// Note: original version is Font.Builder font_builder. This results in
// mutual inclusion happiness that Java solved for C++. Therefore,
// we need to avoid that happiness when we port it to C++.
- Builder(FontDataTableBuilderContainer* font_builder, Header* header,
+ Builder(FontDataTableBuilderContainer* font_builder,
+ Header* header,
WritableFontData* data);
- Builder(FontDataTableBuilderContainer* font_builder, Header* header,
+ Builder(FontDataTableBuilderContainer* font_builder,
+ Header* header,
ReadableFontData* data);
- Builder(FontDataTableBuilderContainer* font_builder, Header* header);
-
- public:
- virtual ~Builder();
- virtual Header* header();
- virtual void notifyPostTableBuild(FontDataTable* table);
- virtual WritableFontData* getNewData(int32_t size);
-
- public:
- static CALLER_ATTACH Builder* getBuilder(
- FontDataTableBuilderContainer* font_builder, Header* header,
- WritableFontData* table_data);
+ Builder(FontDataTableBuilderContainer* font_builder,
+ Header* header);
private:
Ptr<Header> header_;
};
class TableBasedTableBuilder : public Builder {
- protected:
- TableBasedTableBuilder(FontDataTableBuilderContainer* font_builder,
- Header* header, WritableFontData* data);
- TableBasedTableBuilder(FontDataTableBuilderContainer* font_builder,
- Header* header, ReadableFontData* data);
- TableBasedTableBuilder(FontDataTableBuilderContainer* font_builder,
- Header* header);
public:
virtual ~TableBasedTableBuilder();
- protected:
- virtual Table* table();
-
- public:
- virtual int32_t subSerialize(WritableFontData* new_data);
- virtual bool subReadyToSerialize();
- virtual int32_t subDataSizeToSerialize();
- virtual void subDataSet();
+ virtual int32_t SubSerialize(WritableFontData* new_data);
+ virtual bool SubReadyToSerialize();
+ virtual int32_t SubDataSizeToSerialize();
+ virtual void SubDataSet();
protected:
+ TableBasedTableBuilder(FontDataTableBuilderContainer* font_builder,
+ Header* header,
+ WritableFontData* data);
+ TableBasedTableBuilder(FontDataTableBuilderContainer* font_builder,
+ Header* header,
+ ReadableFontData* data);
+ TableBasedTableBuilder(FontDataTableBuilderContainer* font_builder,
+ Header* header);
+
+ // C++ port: renamed table() to GetTable()
+ virtual Table* GetTable();
+
+ // TODO(arthurhsu): style guide violation: protected member, need refactor
Ptr<Table> table_;
};
class GenericTableBuilder : public TableBasedTableBuilder,
- public RefCounted<GenericTableBuilder> {
+ public RefCounted<GenericTableBuilder> {
public:
GenericTableBuilder(FontDataTableBuilderContainer* font_builder,
- Header* header, WritableFontData* data);
- virtual CALLER_ATTACH FontDataTable* subBuildTable(ReadableFontData* data);
+ Header* header,
+ WritableFontData* data);
+ virtual CALLER_ATTACH FontDataTable* SubBuildTable(ReadableFontData* data);
};
class ArrayElementTableBuilder : public Builder {
- protected:
- ArrayElementTableBuilder(FontDataTableBuilderContainer* font_builder,
- Header* header, WritableFontData* data);
- ArrayElementTableBuilder(FontDataTableBuilderContainer* font_builder,
- Header* header, ReadableFontData* data);
public:
virtual ~ArrayElementTableBuilder();
+
+ protected:
+ ArrayElementTableBuilder(FontDataTableBuilderContainer* font_builder,
+ Header* header,
+ WritableFontData* data);
+ ArrayElementTableBuilder(FontDataTableBuilderContainer* font_builder,
+ Header* header,
+ ReadableFontData* data);
};
+ virtual ~Table();
+ virtual int64_t CalculatedChecksum();
+ virtual Header* header() { return header_; }
+ virtual int32_t header_tag() { return header_->tag(); }
+ virtual int32_t header_offset() { return header_->offset(); }
+ virtual int32_t header_length() { return header_->length(); }
+ virtual int64_t header_checksum() { return header_->checksum(); }
+ virtual WritableFontData* GetNewData(int32_t size);
+ virtual void SetFont(Font* font);
+
protected:
Table(Header* header, ReadableFontData* data);
- public:
- virtual ~Table();
- virtual int64_t calculatedChecksum();
- virtual Header* header();
- virtual int32_t headerTag();
- virtual int32_t headerOffset();
- virtual int32_t headerLength();
- virtual int64_t headerChecksum();
-
- public: // FontDataTableBuilderContainer, deprecated
- virtual WritableFontData* getNewData(int32_t size);
- virtual void setFont(Font* font);
-
private:
Ptr<Header> header_;
Ptr<Font> font_;
diff --git a/sfntly/tag.cc b/sfntly/tag.cc
index 257e65f..e3c11cd 100644
--- a/sfntly/tag.cc
+++ b/sfntly/tag.cc
@@ -19,42 +19,42 @@
namespace sfntly {
-const int32_t Tag::ttcf = generate_tag('t', 't', 'c', 'f');
-const int32_t Tag::cmap = generate_tag('c', 'm', 'a', 'p');
-const int32_t Tag::head = generate_tag('h', 'e', 'a', 'd');
-const int32_t Tag::hhea = generate_tag('h', 'h', 'e', 'a');
-const int32_t Tag::hmtx = generate_tag('h', 'm', 't', 'x');
-const int32_t Tag::maxp = generate_tag('m', 'a', 'x', 'p');
-const int32_t Tag::name = generate_tag('n', 'a', 'm', 'e');
-const int32_t Tag::OS_2 = generate_tag('O', 'S', '/', '2');
-const int32_t Tag::post = generate_tag('p', 'o', 's', 't');
-const int32_t Tag::cvt = generate_tag('c', 'v', 't', ' ');
-const int32_t Tag::fpgm = generate_tag('f', 'p', 'g', 'm');
-const int32_t Tag::glyf = generate_tag('g', 'l', 'y', 'f');
-const int32_t Tag::loca = generate_tag('l', 'o', 'c', 'a');
-const int32_t Tag::prep = generate_tag('p', 'r', 'e', 'p');
-const int32_t Tag::CFF = generate_tag('C', 'F', 'F', ' ');
-const int32_t Tag::VORG = generate_tag('V', 'O', 'R', 'G');
-const int32_t Tag::EBDT = generate_tag('E', 'B', 'D', 'T');
-const int32_t Tag::EBLC = generate_tag('E', 'B', 'L', 'C');
-const int32_t Tag::EBSC = generate_tag('E', 'B', 'S', 'C');
-const int32_t Tag::BASE = generate_tag('B', 'A', 'S', 'E');
-const int32_t Tag::GDEF = generate_tag('G', 'D', 'E', 'F');
-const int32_t Tag::GPOS = generate_tag('G', 'P', 'O', 'S');
-const int32_t Tag::GSUB = generate_tag('G', 'S', 'U', 'B');
-const int32_t Tag::JSTF = generate_tag('J', 'S', 'T', 'F');
-const int32_t Tag::DSIG = generate_tag('D', 'S', 'I', 'G');
-const int32_t Tag::gasp = generate_tag('g', 'a', 's', 'p');
-const int32_t Tag::hdmx = generate_tag('h', 'd', 'm', 'x');
-const int32_t Tag::kern = generate_tag('k', 'e', 'r', 'n');
-const int32_t Tag::LTSH = generate_tag('L', 'T', 'S', 'H');
-const int32_t Tag::PCLT = generate_tag('P', 'C', 'L', 'T');
-const int32_t Tag::VDMX = generate_tag('V', 'D', 'M', 'X');
-const int32_t Tag::vhea = generate_tag('v', 'h', 'e', 'a');
-const int32_t Tag::vmtx = generate_tag('v', 'm', 't', 'x');
-const int32_t Tag::bhed = generate_tag('b', 'h', 'e', 'd');
-const int32_t Tag::bdat = generate_tag('b', 'd', 'a', 't');
-const int32_t Tag::bloc = generate_tag('b', 'l', 'o', 'c');
+const int32_t Tag::ttcf = GenerateTag('t', 't', 'c', 'f');
+const int32_t Tag::cmap = GenerateTag('c', 'm', 'a', 'p');
+const int32_t Tag::head = GenerateTag('h', 'e', 'a', 'd');
+const int32_t Tag::hhea = GenerateTag('h', 'h', 'e', 'a');
+const int32_t Tag::hmtx = GenerateTag('h', 'm', 't', 'x');
+const int32_t Tag::maxp = GenerateTag('m', 'a', 'x', 'p');
+const int32_t Tag::name = GenerateTag('n', 'a', 'm', 'e');
+const int32_t Tag::OS_2 = GenerateTag('O', 'S', '/', '2');
+const int32_t Tag::post = GenerateTag('p', 'o', 's', 't');
+const int32_t Tag::cvt = GenerateTag('c', 'v', 't', ' ');
+const int32_t Tag::fpgm = GenerateTag('f', 'p', 'g', 'm');
+const int32_t Tag::glyf = GenerateTag('g', 'l', 'y', 'f');
+const int32_t Tag::loca = GenerateTag('l', 'o', 'c', 'a');
+const int32_t Tag::prep = GenerateTag('p', 'r', 'e', 'p');
+const int32_t Tag::CFF = GenerateTag('C', 'F', 'F', ' ');
+const int32_t Tag::VORG = GenerateTag('V', 'O', 'R', 'G');
+const int32_t Tag::EBDT = GenerateTag('E', 'B', 'D', 'T');
+const int32_t Tag::EBLC = GenerateTag('E', 'B', 'L', 'C');
+const int32_t Tag::EBSC = GenerateTag('E', 'B', 'S', 'C');
+const int32_t Tag::BASE = GenerateTag('B', 'A', 'S', 'E');
+const int32_t Tag::GDEF = GenerateTag('G', 'D', 'E', 'F');
+const int32_t Tag::GPOS = GenerateTag('G', 'P', 'O', 'S');
+const int32_t Tag::GSUB = GenerateTag('G', 'S', 'U', 'B');
+const int32_t Tag::JSTF = GenerateTag('J', 'S', 'T', 'F');
+const int32_t Tag::DSIG = GenerateTag('D', 'S', 'I', 'G');
+const int32_t Tag::gasp = GenerateTag('g', 'a', 's', 'p');
+const int32_t Tag::hdmx = GenerateTag('h', 'd', 'm', 'x');
+const int32_t Tag::kern = GenerateTag('k', 'e', 'r', 'n');
+const int32_t Tag::LTSH = GenerateTag('L', 'T', 'S', 'H');
+const int32_t Tag::PCLT = GenerateTag('P', 'C', 'L', 'T');
+const int32_t Tag::VDMX = GenerateTag('V', 'D', 'M', 'X');
+const int32_t Tag::vhea = GenerateTag('v', 'h', 'e', 'a');
+const int32_t Tag::vmtx = GenerateTag('v', 'm', 't', 'x');
+const int32_t Tag::bhed = GenerateTag('b', 'h', 'e', 'd');
+const int32_t Tag::bdat = GenerateTag('b', 'd', 'a', 't');
+const int32_t Tag::bloc = GenerateTag('b', 'l', 'o', 'c');
const int32_t CFF_TABLE_ORDERING[] = {
Tag::head,
diff --git a/sfntly/tag.h b/sfntly/tag.h
index fe6da46..9e73007 100644
--- a/sfntly/tag.h
+++ b/sfntly/tag.h
@@ -82,7 +82,7 @@
static const int32_t bloc;
};
-inline int32_t generate_tag(char a, char b, char c, char d) {
+inline int32_t GenerateTag(char a, char b, char c, char d) {
return (((int32_t)(a) << 24) |
((int32_t)(b) << 16) |
((int32_t)(c) << 8) |
diff --git a/sfntly/tools/subsetter.cc b/sfntly/tools/subsetter.cc
index 44ba22e..c234a1e 100644
--- a/sfntly/tools/subsetter.cc
+++ b/sfntly/tools/subsetter.cc
@@ -14,10 +14,11 @@
* limitations under the License.
*/
+#include "sfntly/tools/subsetter/subsetter.h"
+
#include <algorithm>
#include <iterator>
-#include "sfntly/tools/subsetter/subsetter.h"
#include "sfntly/tools/subsetter/glyph_table_subsetter.h"
namespace sfntly {
@@ -31,32 +32,32 @@
}
Subsetter::~Subsetter() {
- font_factory_.release();
- font_.release();
+ font_factory_.Release();
+ font_.Release();
table_subsetters_.clear();
}
-void Subsetter::setGlyphs(IntegerList* glyphs) {
+void Subsetter::SetGlyphs(IntegerList* glyphs) {
new_to_old_glyphs_ = *glyphs;
}
-void Subsetter::setCMaps(CMapIdList* cmap_ids, int32_t number) {
+void Subsetter::SetCMaps(CMapIdList* cmap_ids, int32_t number) {
UNREFERENCED_PARAMETER(cmap_ids);
UNREFERENCED_PARAMETER(number);
// TODO(arthurhsu): IMPLEMENT
}
-void Subsetter::setRemoveTables(IntegerSet* remove_tables) {
+void Subsetter::SetRemoveTables(IntegerSet* remove_tables) {
remove_tables_ = *remove_tables;
}
-CALLER_ATTACH Font::Builder* Subsetter::subset() {
+CALLER_ATTACH Font::Builder* Subsetter::Subset() {
FontBuilderPtr font_builder;
- font_builder.attach(font_factory_->newFontBuilder());
+ font_builder.Attach(font_factory_->NewFontBuilder());
IntegerSet table_tags;
- for (TableMap::iterator i = font_->tables()->begin(),
- e = font_->tables()->end(); i != e; ++i) {
+ for (TableMap::iterator i = font_->Tables()->begin(),
+ e = font_->Tables()->end(); i != e; ++i) {
table_tags.insert(i->first);
}
if (!remove_tables_.empty()) {
@@ -70,9 +71,9 @@
table_subsetter = table_subsetters_.begin(),
table_subsetter_end = table_subsetters_.end();
table_subsetter != table_subsetter_end; ++table_subsetter) {
- bool handled = (*table_subsetter)->subset(this, font_, font_builder);
+ bool handled = (*table_subsetter)->Subset(this, font_, font_builder);
if (handled) {
- IntegerSet* handled_tags = (*table_subsetter)->tagsHandled();
+ IntegerSet* handled_tags = (*table_subsetter)->TagsHandled();
IntegerSet result;
std::set_difference(table_tags.begin(), table_tags.end(),
handled_tags->begin(), handled_tags->end(),
@@ -82,24 +83,24 @@
}
for (IntegerSet::iterator tag = table_tags.begin(),
tag_end = table_tags.end(); tag != tag_end; ++tag) {
- Table* table = font_->table(*tag);
+ Table* table = font_->GetTable(*tag);
if (table) {
- // The newTableBuilder() call will alter internal state of font_builder
+ // The NewTableBuilder() call will alter internal state of font_builder
// AND the reference count of returned object. Therefore we need to
// dereference it.
TableBuilderPtr dereference;
- dereference.attach(
- font_builder->newTableBuilder(*tag, table->readFontData()));
+ dereference.Attach(
+ font_builder->NewTableBuilder(*tag, table->ReadFontData()));
}
}
- return font_builder.detach();
+ return font_builder.Detach();
}
-IntegerList* Subsetter::glyphPermutationTable() {
+IntegerList* Subsetter::GlyphPermutationTable() {
return &new_to_old_glyphs_;
}
-CMapIdList* Subsetter::cmapId() {
+CMapIdList* Subsetter::CMapId() {
return &cmap_ids_;
}
diff --git a/sfntly/tools/subsetter/glyph_table_subsetter.cc b/sfntly/tools/subsetter/glyph_table_subsetter.cc
index 04d0c48..7609f74 100644
--- a/sfntly/tools/subsetter/glyph_table_subsetter.cc
+++ b/sfntly/tools/subsetter/glyph_table_subsetter.cc
@@ -14,11 +14,12 @@
* limitations under the License.
*/
+#include "sfntly/tools/subsetter/glyph_table_subsetter.h"
+
#include "sfntly/tag.h"
#include "sfntly/glyph_table.h"
#include "sfntly/loca_table.h"
#include "sfntly/tools/subsetter/subsetter.h"
-#include "sfntly/tools/subsetter/glyph_table_subsetter.h"
#include "sfntly/port/exception_type.h"
namespace sfntly {
@@ -31,18 +32,19 @@
GlyphTableSubsetter::~GlyphTableSubsetter() {}
-bool GlyphTableSubsetter::subset(Subsetter* subsetter, Font* font,
+bool GlyphTableSubsetter::Subset(Subsetter* subsetter,
+ Font* font,
Font::Builder* font_builder) {
assert(font);
assert(subsetter);
assert(font_builder);
- IntegerList* permutation_table = subsetter->glyphPermutationTable();
+ IntegerList* permutation_table = subsetter->GlyphPermutationTable();
if (!permutation_table || permutation_table->empty())
return false;
- GlyphTablePtr glyph_table = down_cast<GlyphTable*>(font->table(Tag::glyf));
- LocaTablePtr loca_table = down_cast<LocaTable*>(font->table(Tag::loca));
+ GlyphTablePtr glyph_table = down_cast<GlyphTable*>(font->GetTable(Tag::glyf));
+ LocaTablePtr loca_table = down_cast<LocaTable*>(font->GetTable(Tag::loca));
if (glyph_table == NULL || loca_table == NULL) {
#if defined (SFNTLY_NO_EXCEPTION)
return false;
@@ -52,11 +54,11 @@
}
GlyphTableBuilderPtr glyph_table_builder;
- glyph_table_builder.attach(down_cast<GlyphTable::Builder*>(
- font_builder->newTableBuilder(Tag::glyf)));
+ glyph_table_builder.Attach(down_cast<GlyphTable::Builder*>(
+ font_builder->NewTableBuilder(Tag::glyf)));
LocaTableBuilderPtr loca_table_builder;
- loca_table_builder.attach(down_cast<LocaTable::Builder*>(
- font_builder->newTableBuilder(Tag::loca)));
+ loca_table_builder.Attach(down_cast<LocaTable::Builder*>(
+ font_builder->NewTableBuilder(Tag::loca)));
if (glyph_table_builder == NULL || loca_table_builder == NULL) {
#if defined (SFNTLY_NO_EXCEPTION)
return false;
@@ -65,25 +67,25 @@
#endif
}
GlyphTable::GlyphBuilderList* glyph_builders =
- glyph_table_builder->glyphBuilders();
+ glyph_table_builder->GlyphBuilders();
for (IntegerList::iterator old_glyph_id = permutation_table->begin(),
old_glyph_id_end = permutation_table->end();
old_glyph_id != old_glyph_id_end; ++old_glyph_id) {
- int old_offset = loca_table->glyphOffset(*old_glyph_id);
- int old_length = loca_table->glyphLength(*old_glyph_id);
+ int old_offset = loca_table->GlyphOffset(*old_glyph_id);
+ int old_length = loca_table->GlyphLength(*old_glyph_id);
GlyphPtr glyph;
- glyph.attach(glyph_table->glyph(old_offset, old_length));
- ReadableFontDataPtr data = glyph->readFontData();
+ glyph.Attach(glyph_table->GetGlyph(old_offset, old_length));
+ ReadableFontDataPtr data = glyph->ReadFontData();
WritableFontDataPtr copy_data;
- copy_data.attach(font_builder->getNewData(data->length()));
- data->copyTo(copy_data);
+ copy_data.Attach(font_builder->GetNewData(data->Length()));
+ data->CopyTo(copy_data);
GlyphBuilderPtr glyph_builder;
- glyph_builder.attach(glyph_table_builder->glyphBuilder(copy_data));
+ glyph_builder.Attach(glyph_table_builder->GlyphBuilder(copy_data));
glyph_builders->push_back(glyph_builder);
}
IntegerList loca_list;
- glyph_table_builder->generateLocaList(&loca_list);
- loca_table_builder->setLocaList(&loca_list);
+ glyph_table_builder->GenerateLocaList(&loca_list);
+ loca_table_builder->SetLocaList(&loca_list);
return true;
}
diff --git a/sfntly/tools/subsetter/glyph_table_subsetter.h b/sfntly/tools/subsetter/glyph_table_subsetter.h
index 14e3c3d..3687e27 100644
--- a/sfntly/tools/subsetter/glyph_table_subsetter.h
+++ b/sfntly/tools/subsetter/glyph_table_subsetter.h
@@ -27,7 +27,8 @@
GlyphTableSubsetter();
virtual ~GlyphTableSubsetter();
- virtual bool subset(Subsetter* subsetter, Font* font,
+ virtual bool Subset(Subsetter* subsetter,
+ Font* font,
Font::Builder* font_builder);
};
diff --git a/sfntly/tools/subsetter/subsetter.h b/sfntly/tools/subsetter/subsetter.h
index 01308b5..df417ad 100644
--- a/sfntly/tools/subsetter/subsetter.h
+++ b/sfntly/tools/subsetter/subsetter.h
@@ -31,7 +31,7 @@
Subsetter(Font* font, FontFactory* font_factory);
virtual ~Subsetter();
- virtual void setGlyphs(IntegerList* glyphs);
+ virtual void SetGlyphs(IntegerList* glyphs);
// Set the cmaps to be used in the subsetted font. The cmaps are listed in
// order of priority and the number parameter gives a count of how many of the
@@ -49,12 +49,12 @@
// into the subsetted font.
// @param cmapIds the cmap ids to use for the subsetted font
// @param number the maximum number of cmaps to place in the subsetted font
- virtual void setCMaps(CMapIdList* cmap_ids, int32_t number);
+ virtual void SetCMaps(CMapIdList* cmap_ids, int32_t number);
- virtual void setRemoveTables(IntegerSet* remove_tables);
- virtual CALLER_ATTACH Font::Builder* subset();
- virtual IntegerList* glyphPermutationTable();
- virtual CMapIdList* cmapId();
+ virtual void SetRemoveTables(IntegerSet* remove_tables);
+ virtual CALLER_ATTACH Font::Builder* Subset();
+ virtual IntegerList* GlyphPermutationTable();
+ virtual CMapIdList* CMapId();
private:
FontPtr font_;
diff --git a/sfntly/tools/subsetter/table_subsetter.h b/sfntly/tools/subsetter/table_subsetter.h
index 9565da6..437705c 100644
--- a/sfntly/tools/subsetter/table_subsetter.h
+++ b/sfntly/tools/subsetter/table_subsetter.h
@@ -26,9 +26,9 @@
class Subsetter;
class TableSubsetter : virtual public RefCount {
public:
- virtual IntegerSet* tagsHandled() = 0;
- virtual bool tagHandled(int32_t tag) = 0;
- virtual bool subset(Subsetter* subsetter, Font* font,
+ virtual IntegerSet* TagsHandled() = 0;
+ virtual bool TagHandled(int32_t tag) = 0;
+ virtual bool Subset(Subsetter* subsetter, Font* font,
Font::Builder* font_builder) = 0;
};
typedef Ptr<TableSubsetter> TableSubsetterPtr;
diff --git a/sfntly/tools/subsetter/table_subsetter_impl.cc b/sfntly/tools/subsetter/table_subsetter_impl.cc
index 481f10f..f239c78 100644
--- a/sfntly/tools/subsetter/table_subsetter_impl.cc
+++ b/sfntly/tools/subsetter/table_subsetter_impl.cc
@@ -27,11 +27,11 @@
TableSubsetterImpl::~TableSubsetterImpl() {}
-bool TableSubsetterImpl::tagHandled(int32_t tag) {
+bool TableSubsetterImpl::TagHandled(int32_t tag) {
return tags_.find(tag) != tags_.end();
}
-IntegerSet* TableSubsetterImpl::tagsHandled() {
+IntegerSet* TableSubsetterImpl::TagsHandled() {
return &tags_;
}
diff --git a/sfntly/tools/subsetter/table_subsetter_impl.h b/sfntly/tools/subsetter/table_subsetter_impl.h
index 7fabba8..162464a 100644
--- a/sfntly/tools/subsetter/table_subsetter_impl.h
+++ b/sfntly/tools/subsetter/table_subsetter_impl.h
@@ -25,8 +25,8 @@
public:
TableSubsetterImpl(const int32_t* tags, size_t tags_length);
virtual ~TableSubsetterImpl();
- virtual bool tagHandled(int32_t tag);
- virtual IntegerSet* tagsHandled();
+ virtual bool TagHandled(int32_t tag);
+ virtual IntegerSet* TagsHandled();
protected:
IntegerSet tags_;
diff --git a/test/byte_array_test.cc b/test/byte_array_test.cc
index 7c6efa9..89478f4 100644
--- a/test/byte_array_test.cc
+++ b/test/byte_array_test.cc
@@ -27,50 +27,50 @@
const int32_t BYTE_ARRAY_SIZES[] =
{1, 7, 127, 128, 129, 255, 256, 257, 666, 1023, 10000, 0xffff, 0x10000};
-void fillTestByteArray(ByteArray* ba, int32_t size) {
+void FillTestByteArray(ByteArray* ba, int32_t size) {
for (int32_t i = 0; i < size; ++i) {
- ba->put(i, (byte_t)(i % 256));
+ ba->Put(i, (byte_t)(i % 256));
}
}
-void readByteArrayWithBuffer(ByteArray* ba, ByteVector* buffer, ByteVector* b) {
- b->resize(ba->length());
+void ReadByteArrayWithBuffer(ByteArray* ba, ByteVector* buffer, ByteVector* b) {
+ b->resize(ba->Length());
int32_t index = 0;
- while (index < ba->length()) {
- int32_t bytes_read = ba->get(index, buffer);
+ while (index < ba->Length()) {
+ int32_t bytes_read = ba->Get(index, buffer);
std::copy(buffer->begin(), buffer->begin() + bytes_read,
b->begin() + index);
index += bytes_read;
}
}
-void readByteArrayWithSlidingWindow(ByteArray* ba, int window_size,
+void ReadByteArrayWithSlidingWindow(ByteArray* ba, int window_size,
ByteVector* b) {
- b->resize(ba->length());
+ b->resize(ba->Length());
int32_t index = 0;
int32_t actual_window_size = window_size;
- while (index < ba->length()) {
+ while (index < ba->Length()) {
actual_window_size =
std::min<int32_t>(actual_window_size, b->size() - index);
- int32_t bytes_read = ba->get(index, b, index, actual_window_size);
+ int32_t bytes_read = ba->Get(index, b, index, actual_window_size);
index += bytes_read;
}
}
-bool readComparison(ByteArray* ba1, ByteArray* ba2) {
+bool ReadComparison(ByteArray* ba1, ByteArray* ba2) {
// single byte reads
- for (int i = 0; i < ba1->length(); ++i) {
- EXPECT_EQ(ba1->get(i), ba2->get(i));
+ for (int i = 0; i < ba1->Length(); ++i) {
+ EXPECT_EQ(ba1->Get(i), ba2->Get(i));
}
ByteVector b1, b2;
// buffer reads
- int increments = std::max<int32_t>(ba1->length() / 11, 1);
- for (int buffer_size = 1; buffer_size < ba1->length();
+ int increments = std::max<int32_t>(ba1->Length() / 11, 1);
+ for (int buffer_size = 1; buffer_size < ba1->Length();
buffer_size += increments) {
ByteVector buffer(buffer_size);
- readByteArrayWithBuffer(ba1, &buffer, &b1);
- readByteArrayWithBuffer(ba2, &buffer, &b2);
+ ReadByteArrayWithBuffer(ba1, &buffer, &b1);
+ ReadByteArrayWithBuffer(ba2, &buffer, &b2);
EXPECT_GT(b1.size(), static_cast<size_t>(0));
EXPECT_EQ(b1.size(), b2.size());
EXPECT_TRUE(std::equal(b1.begin(), b1.end(), b2.begin()));
@@ -79,10 +79,10 @@
// sliding window reads
b1.clear();
b2.clear();
- for (int window_size = 1; window_size < ba1->length();
+ for (int window_size = 1; window_size < ba1->Length();
window_size += increments) {
- readByteArrayWithSlidingWindow(ba1, window_size, &b1);
- readByteArrayWithSlidingWindow(ba2, window_size, &b2);
+ ReadByteArrayWithSlidingWindow(ba1, window_size, &b1);
+ ReadByteArrayWithSlidingWindow(ba2, window_size, &b2);
EXPECT_GT(b1.size(), static_cast<size_t>(0));
EXPECT_EQ(b1.size(), b2.size());
EXPECT_TRUE(std::equal(b1.begin(), b1.end(), b2.begin()));
@@ -91,46 +91,46 @@
return true;
}
-bool copyTest(ByteArray* ba) {
- ByteArrayPtr fixed_copy = new MemoryByteArray(ba->length());
- ba->copyTo(fixed_copy);
- EXPECT_EQ(ba->length(), fixed_copy->length());
- EXPECT_TRUE(readComparison(ba, fixed_copy));
+bool CopyTest(ByteArray* ba) {
+ ByteArrayPtr fixed_copy = new MemoryByteArray(ba->Length());
+ ba->CopyTo(fixed_copy);
+ EXPECT_EQ(ba->Length(), fixed_copy->Length());
+ EXPECT_TRUE(ReadComparison(ba, fixed_copy));
ByteArrayPtr growable_copy = new GrowableMemoryByteArray();
- ba->copyTo(growable_copy);
- EXPECT_EQ(ba->length(), growable_copy->length());
- EXPECT_TRUE(readComparison(ba, growable_copy));
+ ba->CopyTo(growable_copy);
+ EXPECT_EQ(ba->Length(), growable_copy->Length());
+ EXPECT_TRUE(ReadComparison(ba, growable_copy));
return true;
}
-bool byteArrayTester(ByteArray* ba) {
- return copyTest(ba);
+bool ByteArrayTester(ByteArray* ba) {
+ return CopyTest(ba);
}
} // namespace byte_array_test
-bool testMemoryByteArray() {
+bool TestMemoryByteArray() {
for (size_t i = 0;
i < sizeof(byte_array_test::BYTE_ARRAY_SIZES) / sizeof(int32_t); ++i) {
int32_t size = byte_array_test::BYTE_ARRAY_SIZES[i];
fprintf(stderr, "fixed mem: iteration %ld, size %d\n", i, size);
ByteArrayPtr ba = new MemoryByteArray(size);
- byte_array_test::fillTestByteArray(ba, size);
- EXPECT_TRUE(byte_array_test::byteArrayTester(ba));
+ byte_array_test::FillTestByteArray(ba, size);
+ EXPECT_TRUE(byte_array_test::ByteArrayTester(ba));
}
return true;
}
-bool testGrowableMemoryByteArray() {
+bool TestGrowableMemoryByteArray() {
for (size_t i = 0;
i < sizeof(byte_array_test::BYTE_ARRAY_SIZES) / sizeof(int32_t); ++i) {
int32_t size = byte_array_test::BYTE_ARRAY_SIZES[i];
fprintf(stderr, "growable mem: iteration %ld, size %d\n", i, size);
ByteArrayPtr ba = new GrowableMemoryByteArray();
- byte_array_test::fillTestByteArray(ba, size);
- EXPECT_TRUE(byte_array_test::byteArrayTester(ba));
+ byte_array_test::FillTestByteArray(ba, size);
+ EXPECT_TRUE(byte_array_test::ByteArrayTester(ba));
}
return true;
}
diff --git a/test/byte_array_test.h b/test/byte_array_test.h
index 0d67ca8..88e8ce8 100644
--- a/test/byte_array_test.h
+++ b/test/byte_array_test.h
@@ -19,8 +19,8 @@
namespace sfntly {
-bool testMemoryByteArray();
-bool testGrowableMemoryByteArray();
+bool TestMemoryByteArray();
+bool TestGrowableMemoryByteArray();
} // namespace sfntly
diff --git a/test/endian_test.cc b/test/endian_test.cc
index 887fed5..50beeeb 100644
--- a/test/endian_test.cc
+++ b/test/endian_test.cc
@@ -25,7 +25,7 @@
namespace sfntly {
-bool testEndian() {
+bool TestEndian() {
byte_t test_data[] = {
0x68, 0x65, 0x61, 0x64, // 0: head
0xca, 0xca, 0xca, 0xca, // 4: ubyte, byte, char
@@ -38,35 +38,35 @@
ByteArrayPtr ba1 = new GrowableMemoryByteArray();
for (size_t i = 0; i < sizeof(test_data); ++i) {
- ba1->put(i, test_data[i]);
+ ba1->Put(i, test_data[i]);
}
ReadableFontDataPtr rfd = new ReadableFontData(ba1);
- EXPECT_EQ(rfd->readULongAsInt(0), Tag::head);
- EXPECT_EQ(rfd->readUByte(4), 202);
- EXPECT_EQ(rfd->readByte(5), -54);
- EXPECT_EQ(rfd->readChar(6), 202);
- EXPECT_EQ(rfd->readUShort(8), 24);
- EXPECT_EQ(rfd->readShort(10), -32744);
- EXPECT_EQ(rfd->readUInt24(12), 24);
- EXPECT_EQ(rfd->readULong(16), 24);
- EXPECT_EQ(rfd->readLong(20), -256);
- EXPECT_EQ(rfd->readFixed(24), Fixed1616::fixed(1, 0));
+ EXPECT_EQ(rfd->ReadULongAsInt(0), Tag::head);
+ EXPECT_EQ(rfd->ReadUByte(4), 202);
+ EXPECT_EQ(rfd->ReadByte(5), -54);
+ EXPECT_EQ(rfd->ReadChar(6), 202);
+ EXPECT_EQ(rfd->ReadUShort(8), 24);
+ EXPECT_EQ(rfd->ReadShort(10), -32744);
+ EXPECT_EQ(rfd->ReadUInt24(12), 24);
+ EXPECT_EQ(rfd->ReadULong(16), 24);
+ EXPECT_EQ(rfd->ReadLong(20), -256);
+ EXPECT_EQ(rfd->ReadFixed(24), Fixed1616::Fixed(1, 0));
MemoryOutputStream os;
FontOutputStream fos(&os);
- fos.writeULong(Tag::head);
- fos.write(202);
- fos.write(202);
- fos.write(202);
- fos.write(202);
- fos.writeUShort(24);
- fos.writeShort(-32744);
- fos.writeUInt24(24);
- fos.writeChar(0);
- fos.writeULong(24);
- fos.writeLong(-256);
- fos.writeFixed(Fixed1616::fixed(1, 0));
- EXPECT_EQ(memcmp(os.get(), test_data, sizeof(test_data)), 0);
+ fos.WriteULong(Tag::head);
+ fos.Write(202);
+ fos.Write(202);
+ fos.Write(202);
+ fos.Write(202);
+ fos.WriteUShort(24);
+ fos.WriteShort(-32744);
+ fos.WriteUInt24(24);
+ fos.WriteChar(0);
+ fos.WriteULong(24);
+ fos.WriteLong(-256);
+ fos.WriteFixed(Fixed1616::Fixed(1, 0));
+ EXPECT_EQ(memcmp(os.Get(), test_data, sizeof(test_data)), 0);
return true;
}
diff --git a/test/endian_test.h b/test/endian_test.h
index ce96251..8fc36ff 100644
--- a/test/endian_test.h
+++ b/test/endian_test.h
@@ -19,7 +19,7 @@
namespace sfntly {
-bool testEndian();
+bool TestEndian();
} // namespace sfntly
diff --git a/test/file_io_test.cc b/test/file_io_test.cc
index 1c02b0a..6c48a27 100644
--- a/test/file_io_test.cc
+++ b/test/file_io_test.cc
@@ -23,7 +23,7 @@
namespace sfntly {
-bool testFileInputStream() {
+bool TestFileInputStream() {
FILE* file_handle = NULL;
#if defined (WIN32)
fopen_s(&file_handle, SAMPLE_TTF_FILE, "rb");
@@ -44,47 +44,47 @@
// Full file reading test
FileInputStream is;
- is.open(SAMPLE_TTF_FILE);
- EXPECT_EQ(length, (size_t)is.available());
+ is.Open(SAMPLE_TTF_FILE);
+ EXPECT_EQ(length, (size_t)is.Available());
ByteVector b2;
- is.read(&b2, 0, length);
- is.close();
+ is.Read(&b2, 0, length);
+ is.Close();
EXPECT_EQ(memcmp(&(b1[0]), &(b2[0]), length), 0);
b2.clear();
// Partial reading test
- is.open(SAMPLE_TTF_FILE);
- is.skip(89);
- is.read(&b2, 0, 100);
+ is.Open(SAMPLE_TTF_FILE);
+ is.Skip(89);
+ is.Read(&b2, 0, 100);
EXPECT_EQ(memcmp(&(b1[89]), &(b2[0]), 100), 0);
b2.clear();
// Skip test
- is.skip(-89);
- is.read(&b2, 0, 100);
+ is.Skip(-89);
+ is.Read(&b2, 0, 100);
EXPECT_EQ(memcmp(&(b1[100]), &(b2[0]), 100), 0);
b2.clear();
- is.skip(100);
- is.read(&b2, 0, 100);
+ is.Skip(100);
+ is.Read(&b2, 0, 100);
EXPECT_EQ(memcmp(&(b1[300]), &(b2[0]), 100), 0);
- is.skip(-400);
+ is.Skip(-400);
b2.clear();
// Offset test
- is.read(&b2, 0, 100);
- is.read(&b2, 100, 100);
+ is.Read(&b2, 0, 100);
+ is.Read(&b2, 100, 100);
EXPECT_EQ(memcmp(&(b1[0]), &(b2[0]), 200), 0);
// Unread test
ByteVector b3;
b3.resize(200);
- is.unread(&b3);
+ is.Unread(&b3);
EXPECT_EQ(memcmp(&(b3[0]), &(b2[0]), 200), 0);
return true;
}
-bool testFontInputStreamBasic() {
+bool TestFontInputStreamBasic() {
FILE* file_handle = NULL;
#if defined (WIN32)
fopen_s(&file_handle, SAMPLE_TTF_FILE, "rb");
@@ -104,47 +104,47 @@
fclose(file_handle);
FileInputStream is;
- is.open(SAMPLE_TTF_FILE);
+ is.Open(SAMPLE_TTF_FILE);
FontInputStream font_is1(&is);
- EXPECT_EQ((size_t)font_is1.available(), length);
+ EXPECT_EQ((size_t)font_is1.Available(), length);
ByteVector b2;
- font_is1.read(&b2, 0, length);
- font_is1.close();
+ font_is1.Read(&b2, 0, length);
+ font_is1.Close();
EXPECT_EQ(memcmp(&(b1[0]), &(b2[0]), length), 0);
b2.clear();
- is.open(SAMPLE_TTF_FILE);
- is.skip(89);
+ is.Open(SAMPLE_TTF_FILE);
+ is.Skip(89);
FontInputStream font_is2(&is, 200);
- font_is2.read(&b2, 0, 100);
+ font_is2.Read(&b2, 0, 100);
EXPECT_EQ(memcmp(&(b1[89]), &(b2[0]), 100), 0);
- font_is2.read(&b2, 100, 100);
+ font_is2.Read(&b2, 100, 100);
EXPECT_EQ(memcmp(&(b1[89]), &(b2[0]), 200), 0);
b2.clear();
- font_is2.skip(-200);
- font_is2.read(&b2, 0, 100);
+ font_is2.Skip(-200);
+ font_is2.Read(&b2, 0, 100);
EXPECT_EQ(memcmp(&(b1[89]), &(b2[0]), 100), 0);
return true;
}
-bool testFontInputStreamTableLoading() {
+bool TestFontInputStreamTableLoading() {
FileInputStream is;
- is.open(SAMPLE_TTF_FILE);
+ is.Open(SAMPLE_TTF_FILE);
FontInputStream font_is(&is);
- font_is.skip(TTF_OFFSET[SAMPLE_TTF_GDEF]);
+ font_is.Skip(TTF_OFFSET[SAMPLE_TTF_GDEF]);
FontInputStream gdef_is(&font_is, TTF_LENGTH[SAMPLE_TTF_GDEF]);
ByteVector gdef_data;
- gdef_is.read(&gdef_data, 0, TTF_LENGTH[SAMPLE_TTF_GDEF]);
+ gdef_is.Read(&gdef_data, 0, TTF_LENGTH[SAMPLE_TTF_GDEF]);
EXPECT_EQ(memcmp(&(gdef_data[0]), TTF_GDEF_DATA,
TTF_LENGTH[SAMPLE_TTF_GDEF]), 0);
- font_is.skip(TTF_OFFSET[SAMPLE_TTF_HEAD] - font_is.position());
+ font_is.Skip(TTF_OFFSET[SAMPLE_TTF_HEAD] - font_is.position());
FontInputStream head_is(&font_is, TTF_LENGTH[SAMPLE_TTF_HEAD]);
ByteVector head_data;
- head_is.read(&head_data, 0, TTF_LENGTH[SAMPLE_TTF_HEAD]);
+ head_is.Read(&head_data, 0, TTF_LENGTH[SAMPLE_TTF_HEAD]);
EXPECT_EQ(memcmp(&(head_data[0]), TTF_HEAD_DATA,
TTF_LENGTH[SAMPLE_TTF_HEAD]), 0);
diff --git a/test/file_io_test.h b/test/file_io_test.h
index ab5c109..9ff1972 100644
--- a/test/file_io_test.h
+++ b/test/file_io_test.h
@@ -19,9 +19,9 @@
namespace sfntly {
-bool testFileInputStream();
-bool testFontInputStreamBasic();
-bool testFontInputStreamTableLoading();
+bool TestFileInputStream();
+bool TestFontInputStreamBasic();
+bool TestFontInputStreamTableLoading();
} // namespace sfntly
diff --git a/test/font_data_test.cc b/test/font_data_test.cc
index ad30522..3686856 100644
--- a/test/font_data_test.cc
+++ b/test/font_data_test.cc
@@ -28,87 +28,91 @@
const int32_t BYTE_ARRAY_SIZES[] =
{1, 7, 127, 128, 129, 255, 256, 257, 666, 1023, 0x10000};
-void fillTestByteArray(ByteArray* ba, int32_t size) {
+void FillTestByteArray(ByteArray* ba, int32_t size) {
for (int32_t i = 0; i < size; ++i) {
- ba->put(i, (byte_t)(i % 256));
+ ba->Put(i, (byte_t)(i % 256));
}
}
-void readFontDataWithSingleByte(ReadableFontData* rfd, ByteVector* buffer) {
- buffer->resize(rfd->length());
- for (int32_t index = 0; index < rfd->length(); ++index) {
- (*buffer)[index] = (byte_t)(rfd->readByte(index));
+void ReadFontDataWithSingleByte(ReadableFontData* rfd, ByteVector* buffer) {
+ buffer->resize(rfd->Length());
+ for (int32_t index = 0; index < rfd->Length(); ++index) {
+ (*buffer)[index] = (byte_t)(rfd->ReadByte(index));
}
}
-void readFontDataWithBuffer(ReadableFontData* rfd, int32_t buffer_size,
+void ReadFontDataWithBuffer(ReadableFontData* rfd,
+ int32_t buffer_size,
ByteVector* b) {
ByteVector buffer(buffer_size);
- b->resize(rfd->length());
+ b->resize(rfd->Length());
int32_t index = 0;
- while (index < rfd->length()) {
- int32_t bytes_read = rfd->readBytes(index, &buffer, 0, buffer.size());
+ while (index < rfd->Length()) {
+ int32_t bytes_read = rfd->ReadBytes(index, &buffer, 0, buffer.size());
EXPECT_GE(bytes_read, 0);
std::copy(buffer.begin(), buffer.begin() + bytes_read, b->begin() + index);
index += bytes_read;
}
}
-void readFontDataWithSlidingWindow(ReadableFontData* rfd, int32_t window_size,
+void ReadFontDataWithSlidingWindow(ReadableFontData* rfd, int32_t window_size,
ByteVector* b) {
- b->resize(rfd->length());
+ b->resize(rfd->Length());
int32_t index = 0;
- while (index < rfd->length()) {
+ while (index < rfd->Length()) {
int32_t actual_window_size =
std::min<int32_t>(window_size, b->size() - index);
- int32_t bytes_read = rfd->readBytes(index, b, index, actual_window_size);
+ int32_t bytes_read = rfd->ReadBytes(index, b, index, actual_window_size);
EXPECT_GE(bytes_read, 0);
index += bytes_read;
}
}
-void writeFontDataWithSingleByte(ReadableFontData* rfd, WritableFontData* wfd) {
- for (int32_t index = 0; index < rfd->length(); ++index) {
- byte_t b = (byte_t)(rfd->readByte(index));
- wfd->writeByte(index, b);
+void WriteFontDataWithSingleByte(ReadableFontData* rfd, WritableFontData* wfd) {
+ for (int32_t index = 0; index < rfd->Length(); ++index) {
+ byte_t b = (byte_t)(rfd->ReadByte(index));
+ wfd->WriteByte(index, b);
}
}
-void writeFontDataWithBuffer(ReadableFontData* rfd, WritableFontData* wfd,
+void WriteFontDataWithBuffer(ReadableFontData* rfd,
+ WritableFontData* wfd,
int32_t buffer_size) {
ByteVector buffer(buffer_size);
int32_t index = 0;
- while (index < rfd->length()) {
- int32_t bytesRead = rfd->readBytes(index, &buffer, 0, buffer.size());
- wfd->writeBytes(index, &buffer, 0, buffer.size());
+ while (index < rfd->Length()) {
+ int32_t bytesRead = rfd->ReadBytes(index, &buffer, 0, buffer.size());
+ wfd->WriteBytes(index, &buffer, 0, buffer.size());
index += bytesRead;
}
}
-void writeFontDataWithSlidingWindow(ReadableFontData* rfd,
+void WriteFontDataWithSlidingWindow(ReadableFontData* rfd,
WritableFontData* wfd,
int32_t window_size) {
- ByteVector b(rfd->length());
+ ByteVector b(rfd->Length());
int32_t index = 0;
- while (index < rfd->length()) {
+ while (index < rfd->Length()) {
int32_t sliding_size = std::min<int32_t>(window_size, b.size() - index);
- int32_t bytes_read = rfd->readBytes(index, &b, index, sliding_size);
- wfd->writeBytes(index, &b, index, sliding_size);
+ int32_t bytes_read = rfd->ReadBytes(index, &b, index, sliding_size);
+ wfd->WriteBytes(index, &b, index, sliding_size);
index += bytes_read;
}
}
-bool readComparison(int32_t offset, int32_t length, ReadableFontData* rfd1,
+bool ReadComparison(int32_t offset,
+ int32_t length,
+ ReadableFontData* rfd1,
ReadableFontData* rfd2) {
- EXPECT_TRUE(length == rfd2->length());
+ EXPECT_TRUE(length == rfd2->Length());
ByteVector b1, b2;
b1.resize(length);
b2.resize(length);
// single byte reads
- readFontDataWithSingleByte(rfd1, &b1);
- readFontDataWithSingleByte(rfd2, &b2);
+ ReadFontDataWithSingleByte(rfd1, &b1);
+ ReadFontDataWithSingleByte(rfd2, &b2);
EXPECT_EQ(memcmp(&(b1[offset]), &(b2[0]), length), 0);
// buffer reads
@@ -119,8 +123,8 @@
b2.clear();
b1.resize(length);
b2.resize(length);
- readFontDataWithBuffer(rfd1, buffer_size, &b1);
- readFontDataWithBuffer(rfd2, buffer_size, &b2);
+ ReadFontDataWithBuffer(rfd1, buffer_size, &b1);
+ ReadFontDataWithBuffer(rfd2, buffer_size, &b2);
int result = memcmp(&(b1[offset]), &(b2[0]), length);
EXPECT_EQ(result, 0);
}
@@ -132,80 +136,80 @@
b2.clear();
b1.resize(length);
b2.resize(length);
- readFontDataWithSlidingWindow(rfd1, window_size, &b1);
- readFontDataWithSlidingWindow(rfd2, window_size, &b2);
+ ReadFontDataWithSlidingWindow(rfd1, window_size, &b1);
+ ReadFontDataWithSlidingWindow(rfd2, window_size, &b2);
int result = memcmp(&(b1[offset]), &(b2[0]), length);
EXPECT_EQ(result, 0);
}
return true;
}
-void slicingReadTest(ReadableFontData* rfd) {
- for (int32_t trim = 0; trim < (rfd->length() / 2) + 1;
- trim += (rfd->length() / 21) + 1) {
+void SlicingReadTest(ReadableFontData* rfd) {
+ for (int32_t trim = 0; trim < (rfd->Length() / 2) + 1;
+ trim += (rfd->Length() / 21) + 1) {
fprintf(stderr, "\tread - trim = %d\n", trim);
- int32_t length = rfd->length() - 2 * trim;
+ int32_t length = rfd->Length() - 2 * trim;
ReadableFontDataPtr slice;
- slice.attach(down_cast<ReadableFontData*>(rfd->slice(trim, length)));
- EXPECT_TRUE(readComparison(trim, length, rfd, slice));
+ slice.Attach(down_cast<ReadableFontData*>(rfd->Slice(trim, length)));
+ EXPECT_TRUE(ReadComparison(trim, length, rfd, slice));
}
}
-void slicingWriteTest(ReadableFontData* rfd, WritableFontData* wfd) {
- for (int32_t trim = 0; trim < (rfd->length() / 2) + 1;
- trim += (rfd->length() / 21) + 1) {
+void SlicingWriteTest(ReadableFontData* rfd, WritableFontData* wfd) {
+ for (int32_t trim = 0; trim < (rfd->Length() / 2) + 1;
+ trim += (rfd->Length() / 21) + 1) {
fprintf(stderr, "\twrite - trim = %d\n", trim);
- int32_t length = rfd->length() - 2 * trim;
+ int32_t length = rfd->Length() - 2 * trim;
WritableFontDataPtr w_slice;
ReadableFontDataPtr r_slice;
// single byte writes
- w_slice.attach(down_cast<WritableFontData*>(wfd->slice(trim, length)));
- r_slice.attach(down_cast<ReadableFontData*>(rfd->slice(trim, length)));
- writeFontDataWithSingleByte(r_slice, w_slice);
- EXPECT_TRUE(readComparison(trim, length, rfd, w_slice));
+ w_slice.Attach(down_cast<WritableFontData*>(wfd->Slice(trim, length)));
+ r_slice.Attach(down_cast<ReadableFontData*>(rfd->Slice(trim, length)));
+ WriteFontDataWithSingleByte(r_slice, w_slice);
+ EXPECT_TRUE(ReadComparison(trim, length, rfd, w_slice));
// buffer writes
int32_t increments = std::max<int32_t>(length / 11, 1);
for (int32_t buffer_size = 1; buffer_size < length;
buffer_size += increments) {
- w_slice.attach(down_cast<WritableFontData*>(wfd->slice(trim, length)));
- r_slice.attach(down_cast<ReadableFontData*>(rfd->slice(trim, length)));
- writeFontDataWithBuffer(r_slice, w_slice, buffer_size);
- EXPECT_TRUE(readComparison(trim, length, rfd, w_slice));
+ w_slice.Attach(down_cast<WritableFontData*>(wfd->Slice(trim, length)));
+ r_slice.Attach(down_cast<ReadableFontData*>(rfd->Slice(trim, length)));
+ WriteFontDataWithBuffer(r_slice, w_slice, buffer_size);
+ EXPECT_TRUE(ReadComparison(trim, length, rfd, w_slice));
}
// sliding window writes
for (int window_size = 1; window_size < length; window_size += increments) {
- w_slice.attach(down_cast<WritableFontData*>(wfd->slice(trim, length)));
- r_slice.attach(down_cast<ReadableFontData*>(rfd->slice(trim, length)));
- writeFontDataWithSlidingWindow(r_slice, w_slice, window_size);
- EXPECT_TRUE(readComparison(trim, length, rfd, w_slice));
+ w_slice.Attach(down_cast<WritableFontData*>(wfd->Slice(trim, length)));
+ r_slice.Attach(down_cast<ReadableFontData*>(rfd->Slice(trim, length)));
+ WriteFontDataWithSlidingWindow(r_slice, w_slice, window_size);
+ EXPECT_TRUE(ReadComparison(trim, length, rfd, w_slice));
}
}
}
-bool testReadableFontData() {
+bool TestReadableFontData() {
for (size_t i = 0; i < sizeof(BYTE_ARRAY_SIZES) / sizeof(int32_t); ++i) {
int32_t size = BYTE_ARRAY_SIZES[i];
ByteArrayPtr ba = new MemoryByteArray(size);
- fillTestByteArray(ba, size);
+ FillTestByteArray(ba, size);
ReadableFontDataPtr rfd = new ReadableFontData(ba);
- slicingReadTest(rfd);
+ SlicingReadTest(rfd);
}
return true;
}
-bool testWritableFontData() {
+bool TestWritableFontData() {
for (size_t i = 0; i < sizeof(BYTE_ARRAY_SIZES) / sizeof(int32_t); ++i) {
int32_t size = BYTE_ARRAY_SIZES[i];
ByteArrayPtr ba = new MemoryByteArray(size);
- fillTestByteArray(ba, size);
+ FillTestByteArray(ba, size);
WritableFontDataPtr wfd = new WritableFontData(ba);
- slicingReadTest(wfd);
+ SlicingReadTest(wfd);
ByteArrayPtr temp = new MemoryByteArray(size);
WritableFontDataPtr wfd_copy = new WritableFontData(temp);
- slicingWriteTest(wfd, wfd_copy);
+ SlicingWriteTest(wfd, wfd_copy);
}
return true;
}
diff --git a/test/font_data_test.h b/test/font_data_test.h
index 78e910d..bca1924 100644
--- a/test/font_data_test.h
+++ b/test/font_data_test.h
@@ -18,8 +18,8 @@
#define TYPOGRAPHY_FONT_SFNTLY_SRC_TEST_FONT_DATA_TEST_H_
namespace sfntly {
- bool testReadableFontData();
- bool testWritableFontData();
+ bool TestReadableFontData();
+ bool TestWritableFontData();
}
#endif // TYPOGRAPHY_FONT_SFNTLY_SRC_TEST_FONT_DATA_TEST_H_
diff --git a/test/font_parsing_test.cc b/test/font_parsing_test.cc
index 3c9f732..71446ec 100644
--- a/test/font_parsing_test.cc
+++ b/test/font_parsing_test.cc
@@ -30,52 +30,52 @@
namespace sfntly {
-bool testFontParsing() {
+bool TestFontParsing() {
ByteVector input_buffer;
- loadFile(SAMPLE_TTF_FILE, &input_buffer);
+ LoadFile(SAMPLE_TTF_FILE, &input_buffer);
ByteArrayPtr ba = new MemoryByteArray(&(input_buffer[0]),
input_buffer.size());
- FontFactoryPtr factory = FontFactory::getInstance();
+ FontFactoryPtr factory = FontFactory::GetInstance();
// File based
FontBuilderArray font_builder_array;
- builderForFontFile(SAMPLE_TTF_FILE, factory, &font_builder_array);
+ BuilderForFontFile(SAMPLE_TTF_FILE, factory, &font_builder_array);
FontBuilderPtr font_builder = font_builder_array[0];
// Memory based
FontBuilderArray font_builder_array2;
- factory->loadFontsForBuilding(ba, &font_builder_array2);
+ factory->LoadFontsForBuilding(ba, &font_builder_array2);
FontBuilderPtr font_builder2 = font_builder_array2[0];
for (size_t i = 0; i < SAMPLE_TTF_KNOWN_TAGS; ++i) {
- EXPECT_TRUE(font_builder->hasTableBuilder(TTF_KNOWN_TAGS[i]));
- EXPECT_TRUE(font_builder2->hasTableBuilder(TTF_KNOWN_TAGS[i]));
+ EXPECT_TRUE(font_builder->HasTableBuilder(TTF_KNOWN_TAGS[i]));
+ EXPECT_TRUE(font_builder2->HasTableBuilder(TTF_KNOWN_TAGS[i]));
}
// Generic table
Ptr<Table::GenericTableBuilder> gdef_builder =
down_cast<Table::GenericTableBuilder*>(
- font_builder->getTableBuilder(Tag::GDEF));
+ font_builder->GetTableBuilder(Tag::GDEF));
Ptr<Table::Header> gdef_header = gdef_builder->header();
EXPECT_EQ(gdef_header->length(), TTF_LENGTH[SAMPLE_TTF_GDEF]);
EXPECT_EQ(gdef_header->offset(), TTF_OFFSET[SAMPLE_TTF_GDEF]);
EXPECT_EQ(gdef_header->checksum(), TTF_CHECKSUM[SAMPLE_TTF_GDEF]);
- EXPECT_TRUE(gdef_header->checksumValid());
+ EXPECT_TRUE(gdef_header->checksum_valid());
- WritableFontDataPtr wfd = gdef_builder->data();
+ WritableFontDataPtr wfd = gdef_builder->Data();
ByteVector b;
b.resize(TTF_LENGTH[SAMPLE_TTF_GDEF]);
- wfd->readBytes(0, &b, 0, TTF_LENGTH[SAMPLE_TTF_GDEF]);
+ wfd->ReadBytes(0, &b, 0, TTF_LENGTH[SAMPLE_TTF_GDEF]);
EXPECT_EQ(memcmp(&(b[0]), TTF_GDEF_DATA, TTF_LENGTH[SAMPLE_TTF_GDEF]), 0);
// Header table
FontHeaderTableBuilderPtr header_builder =
down_cast<FontHeaderTable::Builder*>(
- font_builder->getTableBuilder(Tag::head));
+ font_builder->GetTableBuilder(Tag::head));
Ptr<Table::Header> header_header = header_builder->header();
EXPECT_EQ(header_header->length(), TTF_LENGTH[SAMPLE_TTF_HEAD]);
EXPECT_EQ(header_header->offset(), TTF_OFFSET[SAMPLE_TTF_HEAD]);
EXPECT_EQ(header_header->checksum(), TTF_CHECKSUM[SAMPLE_TTF_HEAD]);
- EXPECT_TRUE(header_header->checksumValid());
+ EXPECT_TRUE(header_header->checksum_valid());
// Data conformance
for (size_t i = 0; i < SAMPLE_TTF_KNOWN_TAGS; ++i) {
@@ -83,46 +83,46 @@
b1.resize(TTF_LENGTH[i]);
b2.resize(TTF_LENGTH[i]);
TableBuilderPtr builder1 =
- font_builder->getTableBuilder(TTF_KNOWN_TAGS[i]);
+ font_builder->GetTableBuilder(TTF_KNOWN_TAGS[i]);
TableBuilderPtr builder2 =
- font_builder2->getTableBuilder(TTF_KNOWN_TAGS[i]);
- WritableFontDataPtr wfd1 = builder1->data();
- WritableFontDataPtr wfd2 = builder2->data();
- wfd1->readBytes(0, &b1, 0, TTF_LENGTH[i]);
- wfd2->readBytes(0, &b2, 0, TTF_LENGTH[i]);
+ font_builder2->GetTableBuilder(TTF_KNOWN_TAGS[i]);
+ WritableFontDataPtr wfd1 = builder1->Data();
+ WritableFontDataPtr wfd2 = builder2->Data();
+ wfd1->ReadBytes(0, &b1, 0, TTF_LENGTH[i]);
+ wfd2->ReadBytes(0, &b2, 0, TTF_LENGTH[i]);
EXPECT_EQ(memcmp(&(b1[0]), &(b2[0]), TTF_LENGTH[i]), 0);
}
return true;
}
-bool testTTFReadWrite() {
- FontFactoryPtr factory = FontFactory::getInstance();
+bool TestTTFReadWrite() {
+ FontFactoryPtr factory = FontFactory::GetInstance();
FontBuilderArray font_builder_array;
- builderForFontFile(SAMPLE_TTF_FILE, factory, &font_builder_array);
+ BuilderForFontFile(SAMPLE_TTF_FILE, factory, &font_builder_array);
FontBuilderPtr font_builder = font_builder_array[0];
- FontPtr font = font_builder->build();
+ FontPtr font = font_builder->Build();
MemoryOutputStream output_stream;
- factory->serializeFont(font, &output_stream);
- EXPECT_GE(output_stream.size(), SAMPLE_TTF_SIZE);
+ factory->SerializeFont(font, &output_stream);
+ EXPECT_GE(output_stream.Size(), SAMPLE_TTF_SIZE);
return true;
}
-bool testTTFMemoryBasedReadWrite() {
+bool TestTTFMemoryBasedReadWrite() {
ByteVector input_buffer;
- loadFile(SAMPLE_TTF_FILE, &input_buffer);
+ LoadFile(SAMPLE_TTF_FILE, &input_buffer);
- FontFactoryPtr factory = FontFactory::getInstance();
+ FontFactoryPtr factory = FontFactory::GetInstance();
FontBuilderArray font_builder_array;
ByteArrayPtr ba = new MemoryByteArray(&(input_buffer[0]),
input_buffer.size());
- factory->loadFontsForBuilding(ba, &font_builder_array);
+ factory->LoadFontsForBuilding(ba, &font_builder_array);
FontBuilderPtr font_builder = font_builder_array[0];
- FontPtr font = font_builder->build();
+ FontPtr font = font_builder->Build();
MemoryOutputStream output_stream;
- factory->serializeFont(font, &output_stream);
- EXPECT_GE(output_stream.size(), input_buffer.size());
+ factory->SerializeFont(font, &output_stream);
+ EXPECT_GE(output_stream.Size(), input_buffer.size());
return true;
}
diff --git a/test/font_parsing_test.h b/test/font_parsing_test.h
index d66689f..7b69a27 100644
--- a/test/font_parsing_test.h
+++ b/test/font_parsing_test.h
@@ -19,9 +19,9 @@
namespace sfntly {
-bool testFontParsing();
-bool testTTFReadWrite();
-bool testTTFMemoryBasedReadWrite();
+bool TestFontParsing();
+bool TestTTFReadWrite();
+bool TestTTFMemoryBasedReadWrite();
} // namespace sfntly
diff --git a/test/main.cc b/test/main.cc
index 0838b94..2c77eda 100644
--- a/test/main.cc
+++ b/test/main.cc
@@ -35,60 +35,60 @@
namespace sfntly {
TEST(SmartPointer, All) {
- EXPECT_TRUE(testSmartPointer());
+ EXPECT_TRUE(TestSmartPointer());
}
TEST(Endian, All) {
- EXPECT_TRUE(sfntly::testEndian());
+ EXPECT_TRUE(sfntly::TestEndian());
}
#if defined RUN_LENGTHY_TESTS
TEST(ByteArray, All) {
- EXPECT_TRUE(sfntly::testMemoryByteArray());
- EXPECT_TRUE(sfntly::testGrowableMemoryByteArray());
+ EXPECT_TRUE(sfntly::TestMemoryByteArray());
+ EXPECT_TRUE(sfntly::TestGrowableMemoryByteArray());
}
#endif
#if defined RUN_LENGTHY_TESTS
TEST(FontData, All) {
- EXPECT_TRUE(sfntly::testReadableFontData());
- EXPECT_TRUE(sfntly::testWritableFontData());
+ EXPECT_TRUE(sfntly::TestReadableFontData());
+ EXPECT_TRUE(sfntly::TestWritableFontData());
}
#endif
TEST(FileIO, All) {
- EXPECT_TRUE(sfntly::testFileInputStream());
- EXPECT_TRUE(sfntly::testFontInputStreamBasic());
- EXPECT_TRUE(sfntly::testFontInputStreamTableLoading());
+ EXPECT_TRUE(sfntly::TestFileInputStream());
+ EXPECT_TRUE(sfntly::TestFontInputStreamBasic());
+ EXPECT_TRUE(sfntly::TestFontInputStreamTableLoading());
}
TEST(OpenTypeData, All) {
- EXPECT_TRUE(sfntly::testOTFRead());
- EXPECT_TRUE(sfntly::testOTFCopy());
+ EXPECT_TRUE(sfntly::TestOTFRead());
+ EXPECT_TRUE(sfntly::TestOTFCopy());
}
TEST(FontParsing, All) {
- EXPECT_TRUE(sfntly::testFontParsing());
- EXPECT_TRUE(sfntly::testTTFReadWrite());
- EXPECT_TRUE(sfntly::testTTFMemoryBasedReadWrite());
+ EXPECT_TRUE(sfntly::TestFontParsing());
+ EXPECT_TRUE(sfntly::TestTTFReadWrite());
+ EXPECT_TRUE(sfntly::TestTTFMemoryBasedReadWrite());
}
TEST(OTFBasicEditing, All) {
- EXPECT_TRUE(sfntly::testOTFBasicEditing());
+ EXPECT_TRUE(sfntly::TestOTFBasicEditing());
}
TEST(NameEditing, All) {
- EXPECT_TRUE(sfntly::testChangeOneName());
- EXPECT_TRUE(sfntly::testModifyNameTableAndRevert());
- EXPECT_TRUE(sfntly::testRemoveOneName());
+ EXPECT_TRUE(sfntly::TestChangeOneName());
+ EXPECT_TRUE(sfntly::TestModifyNameTableAndRevert());
+ EXPECT_TRUE(sfntly::TestRemoveOneName());
}
TEST(TestUtils, Extension) {
- EXPECT_TRUE(sfntly::testExtension());
+ EXPECT_TRUE(sfntly::TestExtension());
}
TEST(TestUtils, Encoding) {
- EXPECT_TRUE(sfntly::testEncoding());
+ EXPECT_TRUE(sfntly::TestEncoding());
}
} // namespace sfntly
diff --git a/test/name_editing_test.cc b/test/name_editing_test.cc
index 7b87b78..6822bf0 100644
--- a/test/name_editing_test.cc
+++ b/test/name_editing_test.cc
@@ -36,49 +36,49 @@
static ByteVector input_buffer;
static ByteArrayPtr ba;
-void loadTestFile(FontFactory* factory, FontBuilderArray* font_builders) {
+void LoadTestFile(FontFactory* factory, FontBuilderArray* font_builders) {
assert(factory);
assert(font_builders);
if (ba == NULL) {
- loadFile(SAMPLE_TTF_FILE, &input_buffer);
+ LoadFile(SAMPLE_TTF_FILE, &input_buffer);
ba = new MemoryByteArray(&(input_buffer[0]), input_buffer.size());
}
- factory->loadFontsForBuilding(ba, font_builders);
+ factory->LoadFontsForBuilding(ba, font_builders);
}
-bool testChangeOneName() {
- FontFactoryPtr factory = FontFactory::getInstance();
+bool TestChangeOneName() {
+ FontFactoryPtr factory = FontFactory::GetInstance();
FontBuilderArray font_builder_array;
- loadTestFile(factory, &font_builder_array);
+ LoadTestFile(factory, &font_builder_array);
FontBuilderPtr font_builder = font_builder_array[0];
NameTableBuilderPtr name_builder = down_cast<NameTable::Builder*>(
- font_builder->getTableBuilder(Tag::name));
+ font_builder->GetTableBuilder(Tag::name));
// Change the font name.
NameEntryBuilderPtr neb =
- name_builder->nameBuilder(PlatformId::kWindows,
+ name_builder->NameBuilder(PlatformId::kWindows,
WindowsEncodingId::kUnicodeUCS2,
WindowsLanguageId::kEnglish_UnitedStates,
NameId::kFontFamilyName);
U_STRING_DECL(new_name, "Timothy", 7);
- neb->setName(new_name);
+ neb->SetName(new_name);
// Build the font.
- FontPtr font = font_builder->build();
+ FontPtr font = font_builder->Build();
// Serialize and reload the serialized font.
MemoryOutputStream os;
- factory->serializeFont(font, &os);
+ factory->SerializeFont(font, &os);
FontArray font_array;
- ByteArrayPtr new_ba = new MemoryByteArray(os.get(), os.size());
- factory->loadFonts(new_ba, &font_array);
+ ByteArrayPtr new_ba = new MemoryByteArray(os.Get(), os.Size());
+ factory->LoadFonts(new_ba, &font_array);
FontPtr new_font = font_array[0];
// Check the font name.
- NameTablePtr name_table = down_cast<NameTable*>(font->table(Tag::name));
- UChar* name = name_table->name(PlatformId::kWindows,
+ NameTablePtr name_table = down_cast<NameTable*>(font->GetTable(Tag::name));
+ UChar* name = name_table->Name(PlatformId::kWindows,
WindowsEncodingId::kUnicodeUCS2,
WindowsLanguageId::kEnglish_UnitedStates,
NameId::kFontFamilyName);
@@ -88,86 +88,86 @@
return true;
}
-bool testModifyNameTableAndRevert() {
- FontFactoryPtr factory = FontFactory::getInstance();
+bool TestModifyNameTableAndRevert() {
+ FontFactoryPtr factory = FontFactory::GetInstance();
FontBuilderArray font_builder_array;
- loadTestFile(factory, &font_builder_array);
+ LoadTestFile(factory, &font_builder_array);
FontBuilderPtr font_builder = font_builder_array[0];
NameTableBuilderPtr name_builder = down_cast<NameTable::Builder*>(
- font_builder->getTableBuilder(Tag::name));
+ font_builder->GetTableBuilder(Tag::name));
// Change the font name.
NameEntryBuilderPtr neb =
- name_builder->nameBuilder(PlatformId::kWindows,
+ name_builder->NameBuilder(PlatformId::kWindows,
WindowsEncodingId::kUnicodeUCS2,
WindowsLanguageId::kEnglish_UnitedStates,
NameId::kFontFamilyName);
- NameTable::NameEntry* neb_entry = neb->entry();
- UChar* original_name = neb_entry->name();
+ NameTable::NameEntry* neb_entry = neb->name_entry();
+ UChar* original_name = neb_entry->Name();
EXPECT_TRUE(original_name != NULL);
U_STRING_DECL(new_name, "Timothy", 7);
- neb->setName(new_name);
- name_builder->revertNames();
+ neb->SetName(new_name);
+ name_builder->RevertNames();
// Build the font.
- FontPtr font = font_builder->build();
+ FontPtr font = font_builder->Build();
// Serialize and reload the serialized font.
MemoryOutputStream os;
- factory->serializeFont(font, &os);
+ factory->SerializeFont(font, &os);
FontArray font_array;
- ByteArrayPtr new_ba = new MemoryByteArray(os.get(), os.size());
- factory->loadFonts(new_ba, &font_array);
+ ByteArrayPtr new_ba = new MemoryByteArray(os.Get(), os.Size());
+ factory->LoadFonts(new_ba, &font_array);
FontPtr new_font = font_array[0];
// Check the font name.
- NameTablePtr name_table = down_cast<NameTable*>(font->table(Tag::name));
- UChar* name = name_table->name(PlatformId::kWindows,
+ NameTablePtr name_table = down_cast<NameTable*>(font->GetTable(Tag::name));
+ UChar* name = name_table->Name(PlatformId::kWindows,
WindowsEncodingId::kUnicodeUCS2,
WindowsLanguageId::kEnglish_UnitedStates,
NameId::kFontFamilyName);
EXPECT_EQ(u_strcmp(name, original_name), 0);
- delete name;
- delete original_name;
+ delete[] name;
+ delete[] original_name;
return true;
}
-bool testRemoveOneName() {
- FontFactoryPtr factory = FontFactory::getInstance();
+bool TestRemoveOneName() {
+ FontFactoryPtr factory = FontFactory::GetInstance();
FontBuilderArray font_builder_array;
- loadTestFile(factory, &font_builder_array);
+ LoadTestFile(factory, &font_builder_array);
FontBuilderPtr font_builder = font_builder_array[0];
NameTableBuilderPtr name_builder = down_cast<NameTable::Builder*>(
- font_builder->getTableBuilder(Tag::name));
+ font_builder->GetTableBuilder(Tag::name));
- EXPECT_TRUE(name_builder->has(PlatformId::kWindows,
+ EXPECT_TRUE(name_builder->Has(PlatformId::kWindows,
WindowsEncodingId::kUnicodeUCS2,
WindowsLanguageId::kEnglish_UnitedStates,
NameId::kFontFamilyName));
- EXPECT_TRUE(name_builder->remove(PlatformId::kWindows,
+ EXPECT_TRUE(name_builder->Remove(PlatformId::kWindows,
WindowsEncodingId::kUnicodeUCS2,
WindowsLanguageId::kEnglish_UnitedStates,
NameId::kFontFamilyName));
// Build the font.
- FontPtr font = font_builder->build();
+ FontPtr font = font_builder->Build();
// Serialize and reload the serialized font.
MemoryOutputStream os;
- factory->serializeFont(font, &os);
+ factory->SerializeFont(font, &os);
FontArray font_array;
- ByteArrayPtr new_ba = new MemoryByteArray(os.get(), os.size());
- factory->loadFonts(new_ba, &font_array);
+ ByteArrayPtr new_ba = new MemoryByteArray(os.Get(), os.Size());
+ factory->LoadFonts(new_ba, &font_array);
FontPtr new_font = font_array[0];
// Check the font name.
- NameTablePtr name_table = down_cast<NameTable*>(font->table(Tag::name));
- UChar* name = name_table->name(PlatformId::kWindows,
+ NameTablePtr name_table = down_cast<NameTable*>(font->GetTable(Tag::name));
+ UChar* name = name_table->Name(PlatformId::kWindows,
WindowsEncodingId::kUnicodeUCS2,
WindowsLanguageId::kEnglish_UnitedStates,
NameId::kFontFamilyName);
@@ -179,14 +179,14 @@
// Note: Function is not implemented but the test case is built. Uncomment
// when NameTable::clear() is implemented.
/*
-bool testClearAllNamesAndSetOne() {
- FontFactoryPtr factory = FontFactory::getInstance();
+bool TestClearAllNamesAndSetOne() {
+ FontFactoryPtr factory = FontFactory::GetInstance();
FontBuilderArray font_builder_array;
- loadTestFile(factory, &font_builder_array);
+ LoadTestFile(factory, &font_builder_array);
FontBuilderPtr font_builder = font_builder_array[0];
NameTableBuilderPtr name_builder = down_cast<NameTable::Builder*>(
- font_builder->getTableBuilder(Tag::name));
+ font_builder->GetTableBuilder(Tag::name));
EXPECT_GT(name_builder->builderCount(), 0);
name_builder->clear();
@@ -194,32 +194,34 @@
// Change the font name.
NameEntryBuilderPtr neb =
- name_builder->nameBuilder(PlatformId::kWindows,
+ name_builder->NameBuilder(PlatformId::kWindows,
WindowsEncodingId::kUnicodeUCS2,
WindowsLanguageId::kEnglish_UnitedStates,
NameId::kFontFamilyName);
U_STRING_DECL(new_name, "Fred", 4);
- neb->setName(new_name);
+ neb->SetName(new_name);
// Build the font.
- FontPtr font = font_builder->build();
+ FontPtr font = font_builder->Build();
// Serialize and reload the serialized font.
MemoryOutputStream os;
- factory->serializeFont(font, &os);
+ factory->SerializeFont(font, &os);
FontArray font_array;
- ByteArrayPtr new_ba = new MemoryByteArray(os.get(), os.size());
- factory->loadFonts(new_ba, &font_array);
+ ByteArrayPtr new_ba = new MemoryByteArray(os.Get(), os.Size());
+ factory->LoadFonts(new_ba, &font_array);
FontPtr new_font = font_array[0];
// Check the font name.
NameTablePtr name_table = down_cast<NameTable*>(font->table(Tag::name));
- UChar* name = name_table->name(PlatformId::kWindows,
+ UChar* name = name_table->Name(PlatformId::kWindows,
WindowsEncodingId::kUnicodeUCS2,
WindowsLanguageId::kEnglish_UnitedStates,
NameId::kFontFamilyName);
- EXPECT_EQ(name_table->nameCount(), 1);
+ EXPECT_EQ(name_table->NameCount(), 1);
EXPECT_EQ(u_strcmp(name, new_name), 0);
+
+ delete[] name;
return true;
}
*/
diff --git a/test/name_editing_test.h b/test/name_editing_test.h
index b5edf0f..dff38d8 100644
--- a/test/name_editing_test.h
+++ b/test/name_editing_test.h
@@ -19,12 +19,12 @@
namespace sfntly {
-bool testChangeOneName();
-bool testModifyNameTableAndRevert();
-bool testRemoveOneName();
+bool TestChangeOneName();
+bool TestModifyNameTableAndRevert();
+bool TestRemoveOneName();
// Note: Function is not implemented but the test case is built. Uncomment
// when NameTable::clear() is implemented.
-// bool testClearAllNamesAndSetOne();
+// bool TestClearAllNamesAndSetOne();
} // namespace sfntly
diff --git a/test/open_type_data_test.cc b/test/open_type_data_test.cc
index ef1d390..da07e69 100644
--- a/test/open_type_data_test.cc
+++ b/test/open_type_data_test.cc
@@ -24,7 +24,7 @@
const byte_t TEST_OTF_DATA[] =
{0xff, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01};
-bool testOTFRead() {
+bool TestOTFRead() {
ByteVector bytes;
for (size_t i = 0; i < sizeof(TEST_OTF_DATA) / sizeof(byte_t); ++i) {
bytes.push_back(TEST_OTF_DATA[i]);
@@ -32,18 +32,18 @@
ByteArrayPtr array = new MemoryByteArray(&(bytes[0]), bytes.size());
ReadableFontDataPtr data = new ReadableFontData(array);
- EXPECT_EQ(-1, data->readByte(0));
- EXPECT_EQ(0xff, data->readUByte(0));
- EXPECT_EQ(0x01, data->readByte(1));
- EXPECT_EQ(65281, data->readUShort(0));
- EXPECT_EQ(-255, data->readShort(0));
- EXPECT_EQ(16711937, data->readUInt24(0));
- EXPECT_EQ(4278255873LL, data->readULong(0));
- EXPECT_EQ(-16711423, data->readLong(0));
+ EXPECT_EQ(-1, data->ReadByte(0));
+ EXPECT_EQ(0xff, data->ReadUByte(0));
+ EXPECT_EQ(0x01, data->ReadByte(1));
+ EXPECT_EQ(65281, data->ReadUShort(0));
+ EXPECT_EQ(-255, data->ReadShort(0));
+ EXPECT_EQ(16711937, data->ReadUInt24(0));
+ EXPECT_EQ(4278255873LL, data->ReadULong(0));
+ EXPECT_EQ(-16711423, data->ReadLong(0));
return true;
}
-bool testOTFCopy() {
+bool TestOTFCopy() {
ByteVector source_bytes(1024);
for (size_t i = 0; i < source_bytes.size(); ++i) {
source_bytes[i] = (byte_t)(i & 0xff);
@@ -56,7 +56,7 @@
new MemoryByteArray(&(destination_bytes[0]), 1024);
WritableFontDataPtr destination = new WritableFontData(destination_array);
- int32_t length = source->copyTo(destination);
+ int32_t length = source->CopyTo(destination);
EXPECT_EQ(1024, length);
EXPECT_TRUE(std::equal(source_bytes.begin(), source_bytes.end(),
destination_bytes.begin()));
diff --git a/test/open_type_data_test.h b/test/open_type_data_test.h
index 99bd422..30d8a54 100644
--- a/test/open_type_data_test.h
+++ b/test/open_type_data_test.h
@@ -19,8 +19,8 @@
namespace sfntly {
-bool testOTFRead();
-bool testOTFCopy();
+bool TestOTFRead();
+bool TestOTFCopy();
} // namespace sfntly
diff --git a/test/otf_basic_editing_test.cc b/test/otf_basic_editing_test.cc
index 6c8bde9..e9f4bcd 100644
--- a/test/otf_basic_editing_test.cc
+++ b/test/otf_basic_editing_test.cc
@@ -29,39 +29,39 @@
namespace sfntly {
-bool testOTFBasicEditing() {
- FontFactoryPtr factory = FontFactory::getInstance();
+bool TestOTFBasicEditing() {
+ FontFactoryPtr factory = FontFactory::GetInstance();
FontBuilderArray font_builder_array;
- builderForFontFile(SAMPLE_TTF_FILE, factory, &font_builder_array);
+ BuilderForFontFile(SAMPLE_TTF_FILE, factory, &font_builder_array);
FontBuilderPtr font_builder = font_builder_array[0];
// ensure the builder is not bogus
EXPECT_TRUE(font_builder != NULL);
- TableBuilderMap* builder_map = font_builder->tableBuilders();
+ TableBuilderMap* builder_map = font_builder->table_builders();
EXPECT_TRUE(builder_map != NULL);
for (TableBuilderMap::iterator i = builder_map->begin(),
e = builder_map->end(); i != e; ++i) {
EXPECT_TRUE(i->second != NULL);
if (i->second == NULL) {
char tag[5] = {0};
- int32_t value = toBE32(i->first);
+ int32_t value = ToBE32(i->first);
memcpy(tag, &value, 4);
fprintf(stderr, "tag %s does not have valid builder\n", tag);
}
}
IntegerSet builder_tags;
- font_builder->tableBuilderTags(&builder_tags);
+ font_builder->TableBuilderTags(&builder_tags);
FontHeaderTableBuilderPtr header_builder =
down_cast<FontHeaderTable::Builder*>(
- font_builder->getTableBuilder(Tag::head));
- int64_t mod_date = header_builder->modified();
- header_builder->setModified(mod_date + 1);
+ font_builder->GetTableBuilder(Tag::head));
+ int64_t mod_date = header_builder->Modified();
+ header_builder->SetModified(mod_date + 1);
FontPtr font;
- font.attach(font_builder->build());
+ font.Attach(font_builder->Build());
// ensure every table had a builder
- TableMap* table_map = font->tables();
+ TableMap* table_map = font->Tables();
for (TableMap::iterator i = table_map->begin(), e = table_map->end();
i != e; ++i) {
TablePtr table = (*i).second;
@@ -71,9 +71,9 @@
}
EXPECT_TRUE(builder_tags.empty());
- FontHeaderTablePtr header = down_cast<FontHeaderTable*>(
- font->table(Tag::head));
- int64_t after_mod_date = header->modified();
+ FontHeaderTablePtr header =
+ down_cast<FontHeaderTable*>(font->GetTable(Tag::head));
+ int64_t after_mod_date = header->Modified();
EXPECT_EQ(mod_date + 1, after_mod_date);
return true;
}
diff --git a/test/otf_basic_editing_test.h b/test/otf_basic_editing_test.h
index b3abfad..483ed90 100644
--- a/test/otf_basic_editing_test.h
+++ b/test/otf_basic_editing_test.h
@@ -19,7 +19,7 @@
namespace sfntly {
-bool testOTFBasicEditing();
+bool TestOTFBasicEditing();
} // namespace sfntly
diff --git a/test/smart_pointer_test.cc b/test/smart_pointer_test.cc
index a35e289..7eac019 100644
--- a/test/smart_pointer_test.cc
+++ b/test/smart_pointer_test.cc
@@ -28,7 +28,7 @@
int foo() { return foo_; }
};
-bool testSmartPointer() {
+bool TestSmartPointer() {
// scope out allocation
{
Ptr<Foo> p1;
@@ -55,7 +55,7 @@
EXPECT_EQ(size_t(2), p3->ref_count_);
EXPECT_EQ(size_t(2), RefCounted<Foo>::object_counter_);
- p3.release();
+ p3.Release();
EXPECT_EQ(size_t(1), p1->ref_count_);
EXPECT_EQ(NULL, p3.p_);
EXPECT_EQ(size_t(2), RefCounted<Foo>::object_counter_);
diff --git a/test/smart_pointer_test.h b/test/smart_pointer_test.h
index ebc0a1f..b57f614 100644
--- a/test/smart_pointer_test.h
+++ b/test/smart_pointer_test.h
@@ -17,6 +17,6 @@
#ifndef TYPOGRAPHY_FONT_SFNTLY_SRC_TEST_SMART_POINTER_TEST_H_
#define TYPOGRAPHY_FONT_SFNTLY_SRC_TEST_SMART_POINTER_TEST_H_
-bool testSmartPointer();
+bool TestSmartPointer();
#endif // TYPOGRAPHY_FONT_SFNTLY_SRC_TEST_SMART_POINTER_TEST_H_
diff --git a/test/test_font_utils.cc b/test/test_font_utils.cc
index 830f96e..2c7e1fe 100644
--- a/test/test_font_utils.cc
+++ b/test/test_font_utils.cc
@@ -23,32 +23,32 @@
namespace sfntly {
-void builderForFontFile(const char* font_path, FontFactory* factory,
+void BuilderForFontFile(const char* font_path, FontFactory* factory,
FontBuilderArray* builders) {
assert(factory);
FileInputStream is;
- is.open(font_path);
- factory->loadFontsForBuilding(&is, builders);
+ is.Open(font_path);
+ factory->LoadFontsForBuilding(&is, builders);
EXPECT_GT(builders->size(), static_cast<size_t>(0));
}
-void serializeFont(const char* font_path, FontFactory* factory, Font* font) {
+void SerializeFont(const char* font_path, FontFactory* factory, Font* font) {
assert(font_path);
assert(factory);
assert(font);
MemoryOutputStream output_stream;
- factory->serializeFont(font, &output_stream);
- serializeToFile(&output_stream, font_path);
+ factory->SerializeFont(font, &output_stream);
+ SerializeToFile(&output_stream, font_path);
}
-void loadFont(const char* font_path, FontFactory* factory, FontArray* fonts) {
+void LoadFont(const char* font_path, FontFactory* factory, FontArray* fonts) {
FileInputStream is;
- is.open(font_path);
- factory->loadFonts(&is, fonts);
- is.close();
+ is.Open(font_path);
+ factory->LoadFonts(&is, fonts);
+ is.Close();
}
-void loadFile(const char* input_file_path, ByteVector* input_buffer) {
+void LoadFile(const char* input_file_path, ByteVector* input_buffer) {
assert(input_file_path);
assert(input_buffer);
@@ -68,7 +68,7 @@
fclose(input_file);
}
-void serializeToFile(MemoryOutputStream* output_stream, const char* file_path) {
+void SerializeToFile(MemoryOutputStream* output_stream, const char* file_path) {
assert(file_path);
assert(output_stream);
@@ -79,12 +79,12 @@
output_file = fopen(file_path, "wb");
#endif
EXPECT_NE(output_file, reinterpret_cast<FILE*>(NULL));
- fwrite(output_stream->get(), 1, output_stream->size(), output_file);
+ fwrite(output_stream->Get(), 1, output_stream->Size(), output_file);
fflush(output_file);
fclose(output_file);
}
-void hexDump(const unsigned char* byte_data, size_t length) {
+void HexDump(const unsigned char* byte_data, size_t length) {
if (byte_data == NULL || length == 0) {
fprintf(stderr, "<NULL>\n");
return;
diff --git a/test/test_font_utils.h b/test/test_font_utils.h
index b0c5696..6c70edc 100644
--- a/test/test_font_utils.h
+++ b/test/test_font_utils.h
@@ -23,15 +23,15 @@
namespace sfntly {
-void builderForFontFile(const char* font_path, FontFactory* factory,
+void BuilderForFontFile(const char* font_path, FontFactory* factory,
FontBuilderArray* builders);
-void serializeFont(const char* font_path, FontFactory* factory, Font* font);
-void loadFont(const char* font_path, FontFactory* factory, FontArray* fonts);
+void SerializeFont(const char* font_path, FontFactory* factory, Font* font);
+void LoadFont(const char* font_path, FontFactory* factory, FontArray* fonts);
-void loadFile(const char* input_file_path, ByteVector* input_buffer);
-void serializeToFile(MemoryOutputStream* output_stream, const char* file_path);
+void LoadFile(const char* input_file_path, ByteVector* input_buffer);
+void SerializeToFile(MemoryOutputStream* output_stream, const char* file_path);
-void hexDump(const unsigned char* byte_data, size_t length);
+void HexDump(const unsigned char* byte_data, size_t length);
} // namespace sfntly
diff --git a/test/test_utils.cc b/test/test_utils.cc
index 4b4644e..4751b92 100644
--- a/test/test_utils.cc
+++ b/test/test_utils.cc
@@ -30,15 +30,15 @@
TestUtils::TestUtils() {}
// static
-// OutputStream createOutputStream(const char *file_path) {
+// OutputStream CreateOutputStream(const char *file_path) {
// }
// static
-// void TestUtils::createNewFile(const char* file_path) {
+// void TestUtils::CreateNewFile(const char* file_path) {
// }
// static
-int32_t TestUtils::encodeOneChar(UConverter* encoder, int16_t uchar) {
+int32_t TestUtils::EncodeOneChar(UConverter* encoder, int16_t uchar) {
char* target = new char[ucnv_getMaxCharSize(encoder) * 2];
char* target_end;
UChar* source = new UChar[2];
@@ -69,7 +69,7 @@
}
// static
-UConverter* TestUtils::getEncoder(const char* charset_name) {
+UConverter* TestUtils::GetEncoder(const char* charset_name) {
if (charset_name == NULL || strcmp(charset_name, "") == 0)
return NULL;
UErrorCode status = U_ZERO_ERROR;
@@ -81,7 +81,7 @@
// Get a file's extension
// static
-const char* TestUtils::extension(const char* file_path) {
+const char* TestUtils::Extension(const char* file_path) {
if (!file_path)
return NULL;
return strrchr(file_path, EXTENSION_SEPARATOR);
diff --git a/test/test_utils.h b/test/test_utils.h
index 6aa4d99..4d692e1 100644
--- a/test/test_utils.h
+++ b/test/test_utils.h
@@ -40,8 +40,10 @@
// @param length the length of the byte arrays to compare
// @return true if the array segments are equal; false otherwise
// TODO(dfilimon): implement
- static bool equals(ByteArray* b1, int32_t offset1,
- ByteArray* b2, int32_t offset2);
+ static bool Equals(ByteArray* b1,
+ int32_t offset1,
+ ByteArray* b2,
+ int32_t offset2);
// @param offset1 offset to start comparing the first ByteArray from
// @param ba1 the first ByteArray
@@ -50,8 +52,11 @@
// @param length the number of bytes to compare
// @return true if all bytes in the ranges given are equal; false otherwise
// TODO(dfilimon): implement
- static bool equals(ByteArray* b1, int32_t offset1,
- ByteArray* b2, int32_t offset2, int32_t length);
+ static bool Equals(ByteArray* b1,
+ int32_t offset1,
+ ByteArray* b2,
+ int32_t offset2,
+ int32_t length);
// TODO(dfilimon): implement FileOutputStream in port/file_output_stream.*
// static OutputStream createOutputStream(const char* file_path);
@@ -62,13 +67,13 @@
// Creates a new file including deleting an already existing file with the
// same path and name and creating any needed directories.
// TODO(dfilimon): implement
- static void createNewFile(const char* file_path);
+ static void CreateNewFile(const char* file_path);
// Converts an integer into a 4 character string using the ASCII encoding.
// @param i the value to convert
// @return the String based on the number
// TODO(dfilimon): implement
- static void dumpLongAsString(int32_t i, std::string* result);
+ static void DumpLongAsString(int32_t i, std::string* result);
// Calculate an OpenType checksum from the array.
// @param b the array to calculate checksum on
@@ -76,20 +81,20 @@
// @param length the number of bytes to check; must be a multiple of 4
// @return checksum
// TODO(dfilimon): implement
- static int64_t checkSum(ByteArray* b, int32_t offset, int32_t length);
+ static int64_t CheckSum(ByteArray* b, int32_t offset, int32_t length);
// Encode a single character in UTF-16.
// We only support the BMP for now
// @param encoder the encoder to use for the encoding
// @param uchar the Unicode character to encode
// @return the encoded character
- static int32_t encodeOneChar(UConverter* encoder, int16_t uchar);
+ static int32_t EncodeOneChar(UConverter* encoder, int16_t uchar);
// Get an encoder for the charset name.
// If the name is null or the empty string then just return null.
// @param charsetName the charset to get an encoder for
// @return an encoder or null if no encoder available for charset name
- static UConverter* getEncoder(const char* charsetName);
+ static UConverter* GetEncoder(const char* charsetName);
private:
static const char EXTENSION_SEPARATOR = '.';
@@ -99,7 +104,7 @@
// @param file the whose name to process
// @return string containing the extension or an empty string if
// there is no extension
- static const char* extension(const char* file_path);
+ static const char* Extension(const char* file_path);
};
}
#endif // TYPOGRAPHY_FONT_SFNTLY_SRC_TEST_TEST_UTILS_H_
diff --git a/test/test_utils_test.cc b/test/test_utils_test.cc
index 12c5512..41ba905 100644
--- a/test/test_utils_test.cc
+++ b/test/test_utils_test.cc
@@ -27,8 +27,8 @@
// Check if proper encoding is being performed
// Conversion is done from UTF16 to UTF8, SJIS
-bool testEncoding() {
- UConverter* conv = TestUtils::getEncoder("utf8");
+bool TestEncoding() {
+ UConverter* conv = TestUtils::GetEncoder("utf8");
EXPECT_TRUE(conv != NULL);
// Ūnĭcōde̽
UChar from[8] = {0x016A, 0x006E, 0x012D, 0x0063, 0x014D, 0x0064, 0x0065,
@@ -37,7 +37,7 @@
0x65, 0xcc, 0xbd};
int32_t i, j = 0;
for (i = 0; i < 7; ++i) {
- int32_t encoded = TestUtils::encodeOneChar(conv, (int16_t)from[i]);
+ int32_t encoded = TestUtils::EncodeOneChar(conv, (int16_t)from[i]);
for (; encoded; encoded <<= 8) {
byte_t b = (encoded & 0xff000000) >> 24;
if (!b)
@@ -54,22 +54,22 @@
}
// Check if the proper extension is obtained
-bool testExtension() {
+bool TestExtension() {
// usual file name
const char *result;
- result = TestUtils::extension("../data/ext/arial.ttf");
+ result = TestUtils::Extension("../data/ext/tuffy.ttf");
EXPECT_EQ(strcmp(result, ".ttf"), 0);
// more than one 'extension'
- result = TestUtils::extension("arial.ttf.fake");
+ result = TestUtils::Extension("tuffy.ttf.fake");
EXPECT_EQ(strcmp(result, ".fake"), 0);
// no extension
- result = TestUtils::extension("arial");
+ result = TestUtils::Extension("tuffy");
EXPECT_STREQ(result, NULL);
// bogus extension
- result = TestUtils::extension("arial.");
+ result = TestUtils::Extension("tuffy.");
EXPECT_EQ(strcmp(result, "."), 0);
return true;
diff --git a/test/test_utils_test.h b/test/test_utils_test.h
index 1b4649e..c830ed1 100644
--- a/test/test_utils_test.h
+++ b/test/test_utils_test.h
@@ -21,9 +21,9 @@
namespace sfntly {
-bool testEncoding();
-bool testExtension();
-bool testReadFile();
+bool TestEncoding();
+bool TestExtension();
+bool TestReadFile();
} // namespace sfntly
