1 // THIS FILE IS AUTOGENERATED. 2 // Any changes to this file will be overwritten. 3 // For more information about how codegen works, see font-codegen/README.md 4 5 #[allow(unused_imports)] 6 use crate::codegen_prelude::*; 7 8 #[derive(Debug, Clone, Copy)] 9 #[doc(hidden)] 10 pub struct KindsOfOffsetsMarker { 11 versioned_nullable_record_array_offset_byte_start: Option<usize>, 12 versioned_nonnullable_offset_byte_start: Option<usize>, 13 versioned_nullable_offset_byte_start: Option<usize>, 14 } 15 16 impl KindsOfOffsetsMarker { version_byte_range(&self) -> Range<usize>17 fn version_byte_range(&self) -> Range<usize> { 18 let start = 0; 19 start..start + MajorMinor::RAW_BYTE_LEN 20 } nonnullable_offset_byte_range(&self) -> Range<usize>21 fn nonnullable_offset_byte_range(&self) -> Range<usize> { 22 let start = self.version_byte_range().end; 23 start..start + Offset16::RAW_BYTE_LEN 24 } nullable_offset_byte_range(&self) -> Range<usize>25 fn nullable_offset_byte_range(&self) -> Range<usize> { 26 let start = self.nonnullable_offset_byte_range().end; 27 start..start + Offset16::RAW_BYTE_LEN 28 } array_offset_count_byte_range(&self) -> Range<usize>29 fn array_offset_count_byte_range(&self) -> Range<usize> { 30 let start = self.nullable_offset_byte_range().end; 31 start..start + u16::RAW_BYTE_LEN 32 } array_offset_byte_range(&self) -> Range<usize>33 fn array_offset_byte_range(&self) -> Range<usize> { 34 let start = self.array_offset_count_byte_range().end; 35 start..start + Offset16::RAW_BYTE_LEN 36 } record_array_offset_byte_range(&self) -> Range<usize>37 fn record_array_offset_byte_range(&self) -> Range<usize> { 38 let start = self.array_offset_byte_range().end; 39 start..start + Offset16::RAW_BYTE_LEN 40 } versioned_nullable_record_array_offset_byte_range(&self) -> Option<Range<usize>>41 fn versioned_nullable_record_array_offset_byte_range(&self) -> Option<Range<usize>> { 42 let start = self.versioned_nullable_record_array_offset_byte_start?; 43 Some(start..start + Offset16::RAW_BYTE_LEN) 44 } versioned_nonnullable_offset_byte_range(&self) -> Option<Range<usize>>45 fn versioned_nonnullable_offset_byte_range(&self) -> Option<Range<usize>> { 46 let start = self.versioned_nonnullable_offset_byte_start?; 47 Some(start..start + Offset16::RAW_BYTE_LEN) 48 } versioned_nullable_offset_byte_range(&self) -> Option<Range<usize>>49 fn versioned_nullable_offset_byte_range(&self) -> Option<Range<usize>> { 50 let start = self.versioned_nullable_offset_byte_start?; 51 Some(start..start + Offset32::RAW_BYTE_LEN) 52 } 53 } 54 55 impl<'a> FontRead<'a> for KindsOfOffsets<'a> { read(data: FontData<'a>) -> Result<Self, ReadError>56 fn read(data: FontData<'a>) -> Result<Self, ReadError> { 57 let mut cursor = data.cursor(); 58 let version: MajorMinor = cursor.read()?; 59 cursor.advance::<Offset16>(); 60 cursor.advance::<Offset16>(); 61 cursor.advance::<u16>(); 62 cursor.advance::<Offset16>(); 63 cursor.advance::<Offset16>(); 64 let versioned_nullable_record_array_offset_byte_start = version 65 .compatible((1, 1)) 66 .then(|| cursor.position()) 67 .transpose()?; 68 version 69 .compatible((1, 1)) 70 .then(|| cursor.advance::<Offset16>()); 71 let versioned_nonnullable_offset_byte_start = version 72 .compatible((1, 1)) 73 .then(|| cursor.position()) 74 .transpose()?; 75 version 76 .compatible((1, 1)) 77 .then(|| cursor.advance::<Offset16>()); 78 let versioned_nullable_offset_byte_start = version 79 .compatible((1, 1)) 80 .then(|| cursor.position()) 81 .transpose()?; 82 version 83 .compatible((1, 1)) 84 .then(|| cursor.advance::<Offset32>()); 85 cursor.finish(KindsOfOffsetsMarker { 86 versioned_nullable_record_array_offset_byte_start, 87 versioned_nonnullable_offset_byte_start, 88 versioned_nullable_offset_byte_start, 89 }) 90 } 91 } 92 93 pub type KindsOfOffsets<'a> = TableRef<'a, KindsOfOffsetsMarker>; 94 95 impl<'a> KindsOfOffsets<'a> { 96 /// The major/minor version of the GDEF table version(&self) -> MajorMinor97 pub fn version(&self) -> MajorMinor { 98 let range = self.shape.version_byte_range(); 99 self.data.read_at(range.start).unwrap() 100 } 101 102 /// A normal offset nonnullable_offset(&self) -> Offset16103 pub fn nonnullable_offset(&self) -> Offset16 { 104 let range = self.shape.nonnullable_offset_byte_range(); 105 self.data.read_at(range.start).unwrap() 106 } 107 108 /// Attempt to resolve [`nonnullable_offset`][Self::nonnullable_offset]. nonnullable(&self) -> Result<Dummy<'a>, ReadError>109 pub fn nonnullable(&self) -> Result<Dummy<'a>, ReadError> { 110 let data = self.data; 111 self.nonnullable_offset().resolve(data) 112 } 113 114 /// An offset that is nullable, but always present nullable_offset(&self) -> Nullable<Offset16>115 pub fn nullable_offset(&self) -> Nullable<Offset16> { 116 let range = self.shape.nullable_offset_byte_range(); 117 self.data.read_at(range.start).unwrap() 118 } 119 120 /// Attempt to resolve [`nullable_offset`][Self::nullable_offset]. nullable(&self) -> Option<Result<Dummy<'a>, ReadError>>121 pub fn nullable(&self) -> Option<Result<Dummy<'a>, ReadError>> { 122 let data = self.data; 123 self.nullable_offset().resolve(data) 124 } 125 126 /// count of the array at array_offset array_offset_count(&self) -> u16127 pub fn array_offset_count(&self) -> u16 { 128 let range = self.shape.array_offset_count_byte_range(); 129 self.data.read_at(range.start).unwrap() 130 } 131 132 /// An offset to an array: array_offset(&self) -> Offset16133 pub fn array_offset(&self) -> Offset16 { 134 let range = self.shape.array_offset_byte_range(); 135 self.data.read_at(range.start).unwrap() 136 } 137 138 /// Attempt to resolve [`array_offset`][Self::array_offset]. array(&self) -> Result<&'a [BigEndian<u16>], ReadError>139 pub fn array(&self) -> Result<&'a [BigEndian<u16>], ReadError> { 140 let data = self.data; 141 let args = self.array_offset_count(); 142 self.array_offset().resolve_with_args(data, &args) 143 } 144 145 /// An offset to an array of records record_array_offset(&self) -> Offset16146 pub fn record_array_offset(&self) -> Offset16 { 147 let range = self.shape.record_array_offset_byte_range(); 148 self.data.read_at(range.start).unwrap() 149 } 150 151 /// Attempt to resolve [`record_array_offset`][Self::record_array_offset]. record_array(&self) -> Result<&'a [Shmecord], ReadError>152 pub fn record_array(&self) -> Result<&'a [Shmecord], ReadError> { 153 let data = self.data; 154 let args = self.array_offset_count(); 155 self.record_array_offset().resolve_with_args(data, &args) 156 } 157 158 /// A nullable, versioned offset to an array of records versioned_nullable_record_array_offset(&self) -> Option<Nullable<Offset16>>159 pub fn versioned_nullable_record_array_offset(&self) -> Option<Nullable<Offset16>> { 160 let range = self 161 .shape 162 .versioned_nullable_record_array_offset_byte_range()?; 163 Some(self.data.read_at(range.start).unwrap()) 164 } 165 166 /// Attempt to resolve [`versioned_nullable_record_array_offset`][Self::versioned_nullable_record_array_offset]. versioned_nullable_record_array(&self) -> Option<Result<&'a [Shmecord], ReadError>>167 pub fn versioned_nullable_record_array(&self) -> Option<Result<&'a [Shmecord], ReadError>> { 168 let data = self.data; 169 let args = self.array_offset_count(); 170 self.versioned_nullable_record_array_offset() 171 .map(|x| x.resolve_with_args(data, &args))? 172 } 173 174 /// A normal offset that is versioned versioned_nonnullable_offset(&self) -> Option<Offset16>175 pub fn versioned_nonnullable_offset(&self) -> Option<Offset16> { 176 let range = self.shape.versioned_nonnullable_offset_byte_range()?; 177 Some(self.data.read_at(range.start).unwrap()) 178 } 179 180 /// Attempt to resolve [`versioned_nonnullable_offset`][Self::versioned_nonnullable_offset]. versioned_nonnullable(&self) -> Option<Result<Dummy<'a>, ReadError>>181 pub fn versioned_nonnullable(&self) -> Option<Result<Dummy<'a>, ReadError>> { 182 let data = self.data; 183 self.versioned_nonnullable_offset().map(|x| x.resolve(data)) 184 } 185 186 /// An offset that is nullable and versioned versioned_nullable_offset(&self) -> Option<Nullable<Offset32>>187 pub fn versioned_nullable_offset(&self) -> Option<Nullable<Offset32>> { 188 let range = self.shape.versioned_nullable_offset_byte_range()?; 189 Some(self.data.read_at(range.start).unwrap()) 190 } 191 192 /// Attempt to resolve [`versioned_nullable_offset`][Self::versioned_nullable_offset]. versioned_nullable(&self) -> Option<Result<Dummy<'a>, ReadError>>193 pub fn versioned_nullable(&self) -> Option<Result<Dummy<'a>, ReadError>> { 194 let data = self.data; 195 self.versioned_nullable_offset().map(|x| x.resolve(data))? 196 } 197 } 198 199 #[cfg(feature = "traversal")] 200 impl<'a> SomeTable<'a> for KindsOfOffsets<'a> { type_name(&self) -> &str201 fn type_name(&self) -> &str { 202 "KindsOfOffsets" 203 } get_field(&self, idx: usize) -> Option<Field<'a>>204 fn get_field(&self, idx: usize) -> Option<Field<'a>> { 205 let version = self.version(); 206 match idx { 207 0usize => Some(Field::new("version", self.version())), 208 1usize => Some(Field::new( 209 "nonnullable_offset", 210 FieldType::offset(self.nonnullable_offset(), self.nonnullable()), 211 )), 212 2usize => Some(Field::new( 213 "nullable_offset", 214 FieldType::offset(self.nullable_offset(), self.nullable()), 215 )), 216 3usize => Some(Field::new("array_offset_count", self.array_offset_count())), 217 4usize => Some(Field::new( 218 "array_offset", 219 FieldType::offset_to_array_of_scalars(self.array_offset(), self.array()), 220 )), 221 5usize => Some(Field::new( 222 "record_array_offset", 223 traversal::FieldType::offset_to_array_of_records( 224 self.record_array_offset(), 225 self.record_array(), 226 stringify!(Shmecord), 227 self.offset_data(), 228 ), 229 )), 230 6usize if version.compatible((1, 1)) => Some(Field::new( 231 "versioned_nullable_record_array_offset", 232 traversal::FieldType::offset_to_array_of_records( 233 self.versioned_nullable_record_array_offset().unwrap(), 234 self.versioned_nullable_record_array().unwrap(), 235 stringify!(Shmecord), 236 self.offset_data(), 237 ), 238 )), 239 7usize if version.compatible((1, 1)) => Some(Field::new( 240 "versioned_nonnullable_offset", 241 FieldType::offset( 242 self.versioned_nonnullable_offset().unwrap(), 243 self.versioned_nonnullable().unwrap(), 244 ), 245 )), 246 8usize if version.compatible((1, 1)) => Some(Field::new( 247 "versioned_nullable_offset", 248 FieldType::offset( 249 self.versioned_nullable_offset().unwrap(), 250 self.versioned_nullable().unwrap(), 251 ), 252 )), 253 _ => None, 254 } 255 } 256 } 257 258 #[cfg(feature = "traversal")] 259 impl<'a> std::fmt::Debug for KindsOfOffsets<'a> { fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result260 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { 261 (self as &dyn SomeTable<'a>).fmt(f) 262 } 263 } 264 265 #[derive(Debug, Clone, Copy)] 266 #[doc(hidden)] 267 pub struct KindsOfArraysOfOffsetsMarker { 268 nonnullable_offsets_byte_len: usize, 269 nullable_offsets_byte_len: usize, 270 versioned_nonnullable_offsets_byte_start: Option<usize>, 271 versioned_nonnullable_offsets_byte_len: Option<usize>, 272 versioned_nullable_offsets_byte_start: Option<usize>, 273 versioned_nullable_offsets_byte_len: Option<usize>, 274 } 275 276 impl KindsOfArraysOfOffsetsMarker { version_byte_range(&self) -> Range<usize>277 fn version_byte_range(&self) -> Range<usize> { 278 let start = 0; 279 start..start + MajorMinor::RAW_BYTE_LEN 280 } count_byte_range(&self) -> Range<usize>281 fn count_byte_range(&self) -> Range<usize> { 282 let start = self.version_byte_range().end; 283 start..start + u16::RAW_BYTE_LEN 284 } nonnullable_offsets_byte_range(&self) -> Range<usize>285 fn nonnullable_offsets_byte_range(&self) -> Range<usize> { 286 let start = self.count_byte_range().end; 287 start..start + self.nonnullable_offsets_byte_len 288 } nullable_offsets_byte_range(&self) -> Range<usize>289 fn nullable_offsets_byte_range(&self) -> Range<usize> { 290 let start = self.nonnullable_offsets_byte_range().end; 291 start..start + self.nullable_offsets_byte_len 292 } versioned_nonnullable_offsets_byte_range(&self) -> Option<Range<usize>>293 fn versioned_nonnullable_offsets_byte_range(&self) -> Option<Range<usize>> { 294 let start = self.versioned_nonnullable_offsets_byte_start?; 295 Some(start..start + self.versioned_nonnullable_offsets_byte_len?) 296 } versioned_nullable_offsets_byte_range(&self) -> Option<Range<usize>>297 fn versioned_nullable_offsets_byte_range(&self) -> Option<Range<usize>> { 298 let start = self.versioned_nullable_offsets_byte_start?; 299 Some(start..start + self.versioned_nullable_offsets_byte_len?) 300 } 301 } 302 303 impl<'a> FontRead<'a> for KindsOfArraysOfOffsets<'a> { read(data: FontData<'a>) -> Result<Self, ReadError>304 fn read(data: FontData<'a>) -> Result<Self, ReadError> { 305 let mut cursor = data.cursor(); 306 let version: MajorMinor = cursor.read()?; 307 let count: u16 = cursor.read()?; 308 let nonnullable_offsets_byte_len = count as usize * Offset16::RAW_BYTE_LEN; 309 cursor.advance_by(nonnullable_offsets_byte_len); 310 let nullable_offsets_byte_len = count as usize * Offset16::RAW_BYTE_LEN; 311 cursor.advance_by(nullable_offsets_byte_len); 312 let versioned_nonnullable_offsets_byte_start = version 313 .compatible((1, 1)) 314 .then(|| cursor.position()) 315 .transpose()?; 316 let versioned_nonnullable_offsets_byte_len = version 317 .compatible((1, 1)) 318 .then_some(count as usize * Offset16::RAW_BYTE_LEN); 319 if let Some(value) = versioned_nonnullable_offsets_byte_len { 320 cursor.advance_by(value); 321 } 322 let versioned_nullable_offsets_byte_start = version 323 .compatible((1, 1)) 324 .then(|| cursor.position()) 325 .transpose()?; 326 let versioned_nullable_offsets_byte_len = version 327 .compatible((1, 1)) 328 .then_some(count as usize * Offset16::RAW_BYTE_LEN); 329 if let Some(value) = versioned_nullable_offsets_byte_len { 330 cursor.advance_by(value); 331 } 332 cursor.finish(KindsOfArraysOfOffsetsMarker { 333 nonnullable_offsets_byte_len, 334 nullable_offsets_byte_len, 335 versioned_nonnullable_offsets_byte_start, 336 versioned_nonnullable_offsets_byte_len, 337 versioned_nullable_offsets_byte_start, 338 versioned_nullable_offsets_byte_len, 339 }) 340 } 341 } 342 343 pub type KindsOfArraysOfOffsets<'a> = TableRef<'a, KindsOfArraysOfOffsetsMarker>; 344 345 impl<'a> KindsOfArraysOfOffsets<'a> { 346 /// The version version(&self) -> MajorMinor347 pub fn version(&self) -> MajorMinor { 348 let range = self.shape.version_byte_range(); 349 self.data.read_at(range.start).unwrap() 350 } 351 352 /// The number of items in each array count(&self) -> u16353 pub fn count(&self) -> u16 { 354 let range = self.shape.count_byte_range(); 355 self.data.read_at(range.start).unwrap() 356 } 357 358 /// A normal array offset nonnullable_offsets(&self) -> &'a [BigEndian<Offset16>]359 pub fn nonnullable_offsets(&self) -> &'a [BigEndian<Offset16>] { 360 let range = self.shape.nonnullable_offsets_byte_range(); 361 self.data.read_array(range).unwrap() 362 } 363 364 /// A dynamically resolving wrapper for [`nonnullable_offsets`][Self::nonnullable_offsets]. nonnullables(&self) -> ArrayOfOffsets<'a, Dummy<'a>, Offset16>365 pub fn nonnullables(&self) -> ArrayOfOffsets<'a, Dummy<'a>, Offset16> { 366 let data = self.data; 367 let offsets = self.nonnullable_offsets(); 368 ArrayOfOffsets::new(offsets, data, ()) 369 } 370 371 /// An offset that is nullable, but always present nullable_offsets(&self) -> &'a [BigEndian<Nullable<Offset16>>]372 pub fn nullable_offsets(&self) -> &'a [BigEndian<Nullable<Offset16>>] { 373 let range = self.shape.nullable_offsets_byte_range(); 374 self.data.read_array(range).unwrap() 375 } 376 377 /// A dynamically resolving wrapper for [`nullable_offsets`][Self::nullable_offsets]. nullables(&self) -> ArrayOfNullableOffsets<'a, Dummy<'a>, Offset16>378 pub fn nullables(&self) -> ArrayOfNullableOffsets<'a, Dummy<'a>, Offset16> { 379 let data = self.data; 380 let offsets = self.nullable_offsets(); 381 ArrayOfNullableOffsets::new(offsets, data, ()) 382 } 383 384 /// A normal offset that is versioned versioned_nonnullable_offsets(&self) -> Option<&'a [BigEndian<Offset16>]>385 pub fn versioned_nonnullable_offsets(&self) -> Option<&'a [BigEndian<Offset16>]> { 386 let range = self.shape.versioned_nonnullable_offsets_byte_range()?; 387 Some(self.data.read_array(range).unwrap()) 388 } 389 390 /// A dynamically resolving wrapper for [`versioned_nonnullable_offsets`][Self::versioned_nonnullable_offsets]. versioned_nonnullables(&self) -> Option<ArrayOfOffsets<'a, Dummy<'a>, Offset16>>391 pub fn versioned_nonnullables(&self) -> Option<ArrayOfOffsets<'a, Dummy<'a>, Offset16>> { 392 let data = self.data; 393 let offsets = self.versioned_nonnullable_offsets(); 394 offsets.map(|offsets| ArrayOfOffsets::new(offsets, data, ())) 395 } 396 397 /// An offset that is nullable and versioned versioned_nullable_offsets(&self) -> Option<&'a [BigEndian<Nullable<Offset16>>]>398 pub fn versioned_nullable_offsets(&self) -> Option<&'a [BigEndian<Nullable<Offset16>>]> { 399 let range = self.shape.versioned_nullable_offsets_byte_range()?; 400 Some(self.data.read_array(range).unwrap()) 401 } 402 403 /// A dynamically resolving wrapper for [`versioned_nullable_offsets`][Self::versioned_nullable_offsets]. versioned_nullables(&self) -> Option<ArrayOfNullableOffsets<'a, Dummy<'a>, Offset16>>404 pub fn versioned_nullables(&self) -> Option<ArrayOfNullableOffsets<'a, Dummy<'a>, Offset16>> { 405 let data = self.data; 406 let offsets = self.versioned_nullable_offsets(); 407 offsets.map(|offsets| ArrayOfNullableOffsets::new(offsets, data, ())) 408 } 409 } 410 411 #[cfg(feature = "traversal")] 412 impl<'a> SomeTable<'a> for KindsOfArraysOfOffsets<'a> { type_name(&self) -> &str413 fn type_name(&self) -> &str { 414 "KindsOfArraysOfOffsets" 415 } get_field(&self, idx: usize) -> Option<Field<'a>>416 fn get_field(&self, idx: usize) -> Option<Field<'a>> { 417 let version = self.version(); 418 match idx { 419 0usize => Some(Field::new("version", self.version())), 420 1usize => Some(Field::new("count", self.count())), 421 2usize => Some({ 422 let data = self.data; 423 Field::new( 424 "nonnullable_offsets", 425 FieldType::array_of_offsets( 426 better_type_name::<Dummy>(), 427 self.nonnullable_offsets(), 428 move |off| { 429 let target = off.get().resolve::<Dummy>(data); 430 FieldType::offset(off.get(), target) 431 }, 432 ), 433 ) 434 }), 435 3usize => Some({ 436 let data = self.data; 437 Field::new( 438 "nullable_offsets", 439 FieldType::array_of_offsets( 440 better_type_name::<Dummy>(), 441 self.nullable_offsets(), 442 move |off| { 443 let target = off.get().resolve::<Dummy>(data); 444 FieldType::offset(off.get(), target) 445 }, 446 ), 447 ) 448 }), 449 4usize if version.compatible((1, 1)) => Some({ 450 let data = self.data; 451 Field::new( 452 "versioned_nonnullable_offsets", 453 FieldType::array_of_offsets( 454 better_type_name::<Dummy>(), 455 self.versioned_nonnullable_offsets().unwrap(), 456 move |off| { 457 let target = off.get().resolve::<Dummy>(data); 458 FieldType::offset(off.get(), target) 459 }, 460 ), 461 ) 462 }), 463 5usize if version.compatible((1, 1)) => Some({ 464 let data = self.data; 465 Field::new( 466 "versioned_nullable_offsets", 467 FieldType::array_of_offsets( 468 better_type_name::<Dummy>(), 469 self.versioned_nullable_offsets().unwrap(), 470 move |off| { 471 let target = off.get().resolve::<Dummy>(data); 472 FieldType::offset(off.get(), target) 473 }, 474 ), 475 ) 476 }), 477 _ => None, 478 } 479 } 480 } 481 482 #[cfg(feature = "traversal")] 483 impl<'a> std::fmt::Debug for KindsOfArraysOfOffsets<'a> { fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result484 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { 485 (self as &dyn SomeTable<'a>).fmt(f) 486 } 487 } 488 489 #[derive(Debug, Clone, Copy)] 490 #[doc(hidden)] 491 pub struct KindsOfArraysMarker { 492 scalars_byte_len: usize, 493 records_byte_len: usize, 494 versioned_scalars_byte_start: Option<usize>, 495 versioned_scalars_byte_len: Option<usize>, 496 versioned_records_byte_start: Option<usize>, 497 versioned_records_byte_len: Option<usize>, 498 } 499 500 impl KindsOfArraysMarker { version_byte_range(&self) -> Range<usize>501 fn version_byte_range(&self) -> Range<usize> { 502 let start = 0; 503 start..start + u16::RAW_BYTE_LEN 504 } count_byte_range(&self) -> Range<usize>505 fn count_byte_range(&self) -> Range<usize> { 506 let start = self.version_byte_range().end; 507 start..start + u16::RAW_BYTE_LEN 508 } scalars_byte_range(&self) -> Range<usize>509 fn scalars_byte_range(&self) -> Range<usize> { 510 let start = self.count_byte_range().end; 511 start..start + self.scalars_byte_len 512 } records_byte_range(&self) -> Range<usize>513 fn records_byte_range(&self) -> Range<usize> { 514 let start = self.scalars_byte_range().end; 515 start..start + self.records_byte_len 516 } versioned_scalars_byte_range(&self) -> Option<Range<usize>>517 fn versioned_scalars_byte_range(&self) -> Option<Range<usize>> { 518 let start = self.versioned_scalars_byte_start?; 519 Some(start..start + self.versioned_scalars_byte_len?) 520 } versioned_records_byte_range(&self) -> Option<Range<usize>>521 fn versioned_records_byte_range(&self) -> Option<Range<usize>> { 522 let start = self.versioned_records_byte_start?; 523 Some(start..start + self.versioned_records_byte_len?) 524 } 525 } 526 527 impl<'a> FontRead<'a> for KindsOfArrays<'a> { read(data: FontData<'a>) -> Result<Self, ReadError>528 fn read(data: FontData<'a>) -> Result<Self, ReadError> { 529 let mut cursor = data.cursor(); 530 let version: u16 = cursor.read()?; 531 let count: u16 = cursor.read()?; 532 let scalars_byte_len = count as usize * u16::RAW_BYTE_LEN; 533 cursor.advance_by(scalars_byte_len); 534 let records_byte_len = count as usize * Shmecord::RAW_BYTE_LEN; 535 cursor.advance_by(records_byte_len); 536 let versioned_scalars_byte_start = version 537 .compatible(1) 538 .then(|| cursor.position()) 539 .transpose()?; 540 let versioned_scalars_byte_len = version 541 .compatible(1) 542 .then_some(count as usize * u16::RAW_BYTE_LEN); 543 if let Some(value) = versioned_scalars_byte_len { 544 cursor.advance_by(value); 545 } 546 let versioned_records_byte_start = version 547 .compatible(1) 548 .then(|| cursor.position()) 549 .transpose()?; 550 let versioned_records_byte_len = version 551 .compatible(1) 552 .then_some(count as usize * Shmecord::RAW_BYTE_LEN); 553 if let Some(value) = versioned_records_byte_len { 554 cursor.advance_by(value); 555 } 556 cursor.finish(KindsOfArraysMarker { 557 scalars_byte_len, 558 records_byte_len, 559 versioned_scalars_byte_start, 560 versioned_scalars_byte_len, 561 versioned_records_byte_start, 562 versioned_records_byte_len, 563 }) 564 } 565 } 566 567 pub type KindsOfArrays<'a> = TableRef<'a, KindsOfArraysMarker>; 568 569 impl<'a> KindsOfArrays<'a> { version(&self) -> u16570 pub fn version(&self) -> u16 { 571 let range = self.shape.version_byte_range(); 572 self.data.read_at(range.start).unwrap() 573 } 574 575 /// the number of items in each array count(&self) -> u16576 pub fn count(&self) -> u16 { 577 let range = self.shape.count_byte_range(); 578 self.data.read_at(range.start).unwrap() 579 } 580 581 /// an array of scalars scalars(&self) -> &'a [BigEndian<u16>]582 pub fn scalars(&self) -> &'a [BigEndian<u16>] { 583 let range = self.shape.scalars_byte_range(); 584 self.data.read_array(range).unwrap() 585 } 586 587 /// an array of records records(&self) -> &'a [Shmecord]588 pub fn records(&self) -> &'a [Shmecord] { 589 let range = self.shape.records_byte_range(); 590 self.data.read_array(range).unwrap() 591 } 592 593 /// a versioned array of scalars versioned_scalars(&self) -> Option<&'a [BigEndian<u16>]>594 pub fn versioned_scalars(&self) -> Option<&'a [BigEndian<u16>]> { 595 let range = self.shape.versioned_scalars_byte_range()?; 596 Some(self.data.read_array(range).unwrap()) 597 } 598 599 /// a versioned array of scalars versioned_records(&self) -> Option<&'a [Shmecord]>600 pub fn versioned_records(&self) -> Option<&'a [Shmecord]> { 601 let range = self.shape.versioned_records_byte_range()?; 602 Some(self.data.read_array(range).unwrap()) 603 } 604 } 605 606 #[cfg(feature = "traversal")] 607 impl<'a> SomeTable<'a> for KindsOfArrays<'a> { type_name(&self) -> &str608 fn type_name(&self) -> &str { 609 "KindsOfArrays" 610 } get_field(&self, idx: usize) -> Option<Field<'a>>611 fn get_field(&self, idx: usize) -> Option<Field<'a>> { 612 let version = self.version(); 613 match idx { 614 0usize => Some(Field::new("version", self.version())), 615 1usize => Some(Field::new("count", self.count())), 616 2usize => Some(Field::new("scalars", self.scalars())), 617 3usize => Some(Field::new( 618 "records", 619 traversal::FieldType::array_of_records( 620 stringify!(Shmecord), 621 self.records(), 622 self.offset_data(), 623 ), 624 )), 625 4usize if version.compatible(1) => Some(Field::new( 626 "versioned_scalars", 627 self.versioned_scalars().unwrap(), 628 )), 629 5usize if version.compatible(1) => Some(Field::new( 630 "versioned_records", 631 traversal::FieldType::array_of_records( 632 stringify!(Shmecord), 633 self.versioned_records().unwrap(), 634 self.offset_data(), 635 ), 636 )), 637 _ => None, 638 } 639 } 640 } 641 642 #[cfg(feature = "traversal")] 643 impl<'a> std::fmt::Debug for KindsOfArrays<'a> { fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result644 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { 645 (self as &dyn SomeTable<'a>).fmt(f) 646 } 647 } 648 649 #[derive(Debug, Clone, Copy)] 650 #[doc(hidden)] 651 pub struct DummyMarker {} 652 653 impl DummyMarker { value_byte_range(&self) -> Range<usize>654 fn value_byte_range(&self) -> Range<usize> { 655 let start = 0; 656 start..start + u16::RAW_BYTE_LEN 657 } _reserved_byte_range(&self) -> Range<usize>658 fn _reserved_byte_range(&self) -> Range<usize> { 659 let start = self.value_byte_range().end; 660 start..start + u16::RAW_BYTE_LEN 661 } 662 } 663 664 impl<'a> FontRead<'a> for Dummy<'a> { read(data: FontData<'a>) -> Result<Self, ReadError>665 fn read(data: FontData<'a>) -> Result<Self, ReadError> { 666 let mut cursor = data.cursor(); 667 cursor.advance::<u16>(); 668 cursor.advance::<u16>(); 669 cursor.finish(DummyMarker {}) 670 } 671 } 672 673 pub type Dummy<'a> = TableRef<'a, DummyMarker>; 674 675 impl<'a> Dummy<'a> { value(&self) -> u16676 pub fn value(&self) -> u16 { 677 let range = self.shape.value_byte_range(); 678 self.data.read_at(range.start).unwrap() 679 } 680 } 681 682 #[cfg(feature = "traversal")] 683 impl<'a> SomeTable<'a> for Dummy<'a> { type_name(&self) -> &str684 fn type_name(&self) -> &str { 685 "Dummy" 686 } get_field(&self, idx: usize) -> Option<Field<'a>>687 fn get_field(&self, idx: usize) -> Option<Field<'a>> { 688 match idx { 689 0usize => Some(Field::new("value", self.value())), 690 _ => None, 691 } 692 } 693 } 694 695 #[cfg(feature = "traversal")] 696 impl<'a> std::fmt::Debug for Dummy<'a> { fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result697 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { 698 (self as &dyn SomeTable<'a>).fmt(f) 699 } 700 } 701 702 #[derive(Clone, Debug, PartialEq, Eq, PartialOrd, Ord, Hash)] 703 #[repr(C)] 704 #[repr(packed)] 705 pub struct Shmecord { 706 pub length: BigEndian<u16>, 707 pub breadth: BigEndian<u32>, 708 } 709 710 impl Shmecord { length(&self) -> u16711 pub fn length(&self) -> u16 { 712 self.length.get() 713 } 714 breadth(&self) -> u32715 pub fn breadth(&self) -> u32 { 716 self.breadth.get() 717 } 718 } 719 720 impl FixedSize for Shmecord { 721 const RAW_BYTE_LEN: usize = u16::RAW_BYTE_LEN + u32::RAW_BYTE_LEN; 722 } 723 724 impl sealed::Sealed for Shmecord {} 725 726 /// SAFETY: see the [`FromBytes`] trait documentation. 727 unsafe impl FromBytes for Shmecord { this_trait_should_only_be_implemented_in_generated_code()728 fn this_trait_should_only_be_implemented_in_generated_code() {} 729 } 730 731 #[cfg(feature = "traversal")] 732 impl<'a> SomeRecord<'a> for Shmecord { traverse(self, data: FontData<'a>) -> RecordResolver<'a>733 fn traverse(self, data: FontData<'a>) -> RecordResolver<'a> { 734 RecordResolver { 735 name: "Shmecord", 736 get_field: Box::new(move |idx, _data| match idx { 737 0usize => Some(Field::new("length", self.length())), 738 1usize => Some(Field::new("breadth", self.breadth())), 739 _ => None, 740 }), 741 data, 742 } 743 } 744 } 745