diff options
Diffstat (limited to 'vendor/wikimedia/avro/lib/avro/datum.php')
| -rw-r--r-- | vendor/wikimedia/avro/lib/avro/datum.php | 984 |
1 files changed, 984 insertions, 0 deletions
diff --git a/vendor/wikimedia/avro/lib/avro/datum.php b/vendor/wikimedia/avro/lib/avro/datum.php new file mode 100644 index 00000000..ea275faf --- /dev/null +++ b/vendor/wikimedia/avro/lib/avro/datum.php @@ -0,0 +1,984 @@ +<?php +/** + * Licensed to the Apache Software Foundation (ASF) under one + * or more contributor license agreements. See the NOTICE file + * distributed with this work for additional information + * regarding copyright ownership. The ASF licenses this file + * to you under the Apache License, Version 2.0 (the + * "License"); you may not use this file except in compliance + * with the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +/** + * Classes for reading and writing Avro data to AvroIO objects. + * + * @package Avro + * + * @todo Implement JSON encoding, as is required by the Avro spec. + */ + +/** + * Exceptions arising from writing or reading Avro data. + * + * @package Avro + */ +class AvroIOTypeException extends AvroException +{ + /** + * @param AvroSchema $expected_schema + * @param mixed $datum + */ + public function __construct($expected_schema, $datum) + { + parent::__construct(sprintf('The datum %s is not an example of schema %s', + var_export($datum, true), $expected_schema)); + } +} + +/** + * Exceptions arising from incompatibility between + * reader and writer schemas. + * + * @package Avro + */ +class AvroIOSchemaMatchException extends AvroException +{ + /** + * @param AvroSchema $writers_schema + * @param AvroSchema $readers_schema + */ + function __construct($writers_schema, $readers_schema) + { + parent::__construct( + sprintf("Writer's schema %s and Reader's schema %s do not match.", + $writers_schema, $readers_schema)); + } +} + +/** + * Handles schema-specific writing of data to the encoder. + * + * Ensures that each datum written is consistent with the writer's schema. + * + * @package Avro + */ +class AvroIODatumWriter +{ + /** + * Schema used by this instance to write Avro data. + * @var AvroSchema + */ + private $writers_schema; + + /** + * @param AvroSchema $writers_schema + */ + function __construct($writers_schema=null) + { + $this->writers_schema = $writers_schema; + } + + /** + * @param AvroSchema $writers_schema + * @param $datum + * @param AvroIOBinaryEncoder $encoder + * @returns mixed + * + * @throws AvroIOTypeException if $datum is invalid for $writers_schema + */ + function write_data($writers_schema, $datum, $encoder) + { + if (!AvroSchema::is_valid_datum($writers_schema, $datum)) + throw new AvroIOTypeException($writers_schema, $datum); + + switch ($writers_schema->type()) + { + case AvroSchema::NULL_TYPE: + return $encoder->write_null($datum); + case AvroSchema::BOOLEAN_TYPE: + return $encoder->write_boolean($datum); + case AvroSchema::INT_TYPE: + return $encoder->write_int($datum); + case AvroSchema::LONG_TYPE: + return $encoder->write_long($datum); + case AvroSchema::FLOAT_TYPE: + return $encoder->write_float($datum); + case AvroSchema::DOUBLE_TYPE: + return $encoder->write_double($datum); + case AvroSchema::STRING_TYPE: + return $encoder->write_string($datum); + case AvroSchema::BYTES_TYPE: + return $encoder->write_bytes($datum); + case AvroSchema::ARRAY_SCHEMA: + return $this->write_array($writers_schema, $datum, $encoder); + case AvroSchema::MAP_SCHEMA: + return $this->write_map($writers_schema, $datum, $encoder); + case AvroSchema::FIXED_SCHEMA: + return $this->write_fixed($writers_schema, $datum, $encoder); + case AvroSchema::ENUM_SCHEMA: + return $this->write_enum($writers_schema, $datum, $encoder); + case AvroSchema::RECORD_SCHEMA: + case AvroSchema::ERROR_SCHEMA: + case AvroSchema::REQUEST_SCHEMA: + return $this->write_record($writers_schema, $datum, $encoder); + case AvroSchema::UNION_SCHEMA: + return $this->write_union($writers_schema, $datum, $encoder); + default: + throw new AvroException(sprintf('Uknown type: %s', + $writers_schema->type)); + } + } + + /** + * @param $datum + * @param AvroIOBinaryEncoder $encoder + */ + function write($datum, $encoder) + { + $this->write_data($this->writers_schema, $datum, $encoder); + } + + /**#@+ + * @param AvroSchema $writers_schema + * @param null|boolean|int|float|string|array $datum item to be written + * @param AvroIOBinaryEncoder $encoder + */ + private function write_array($writers_schema, $datum, $encoder) + { + $datum_count = count($datum); + if (0 < $datum_count) + { + $encoder->write_long($datum_count); + $items = $writers_schema->items(); + foreach ($datum as $item) + $this->write_data($items, $item, $encoder); + } + return $encoder->write_long(0); + } + + private function write_map($writers_schema, $datum, $encoder) + { + $datum_count = count($datum); + if ($datum_count > 0) + { + $encoder->write_long($datum_count); + foreach ($datum as $k => $v) + { + $encoder->write_string($k); + $this->write_data($writers_schema->values(), $v, $encoder); + } + } + $encoder->write_long(0); + } + + private function write_union($writers_schema, $datum, $encoder) + { + $datum_schema_index = -1; + $datum_schema = null; + foreach ($writers_schema->schemas() as $index => $schema) + if (AvroSchema::is_valid_datum($schema, $datum)) + { + $datum_schema_index = $index; + $datum_schema = $schema; + break; + } + + if (is_null($datum_schema)) + throw new AvroIOTypeException($writers_schema, $datum); + + $encoder->write_long($datum_schema_index); + $this->write_data($datum_schema, $datum, $encoder); + } + + private function write_enum($writers_schema, $datum, $encoder) + { + $datum_index = $writers_schema->symbol_index($datum); + return $encoder->write_int($datum_index); + } + + private function write_fixed($writers_schema, $datum, $encoder) + { + /** + * NOTE Unused $writers_schema parameter included for consistency + * with other write_* methods. + */ + return $encoder->write($datum); + } + + private function write_record($writers_schema, $datum, $encoder) + { + foreach ($writers_schema->fields() as $field) + $this->write_data($field->type(), $datum[$field->name()], $encoder); + } + + /**#@-*/ +} + +/** + * Encodes and writes Avro data to an AvroIO object using + * Avro binary encoding. + * + * @package Avro + */ +class AvroIOBinaryEncoder +{ + /** + * Performs encoding of the given float value to a binary string + * + * XXX: This is <b>not</b> endian-aware! The {@link Avro::check_platform()} + * called in {@link AvroIOBinaryEncoder::__construct()} should ensure the + * library is only used on little-endian platforms, which ensure the little-endian + * encoding required by the Avro spec. + * + * @param float $float + * @returns string bytes + * @see Avro::check_platform() + */ + static function float_to_int_bits($float) + { + return pack('f', (float) $float); + } + + /** + * Performs encoding of the given double value to a binary string + * + * XXX: This is <b>not</b> endian-aware! See comments in + * {@link AvroIOBinaryEncoder::float_to_int_bits()} for details. + * + * @param double $double + * @returns string bytes + */ + static function double_to_long_bits($double) + { + return pack('d', (double) $double); + } + + /** + * @param int|string $n + * @returns string long $n encoded as bytes + * @internal This relies on 64-bit PHP. + */ + static public function encode_long($n) + { + $n = (int) $n; + $n = ($n << 1) ^ ($n >> 63); + $str = ''; + while (0 != ($n & ~0x7F)) + { + $str .= chr(($n & 0x7F) | 0x80); + $n >>= 7; + } + $str .= chr($n); + return $str; + } + + /** + * @var AvroIO + */ + private $io; + + /** + * @param AvroIO $io object to which data is to be written. + * + */ + function __construct($io) + { + Avro::check_platform(); + $this->io = $io; + } + + /** + * @param null $datum actual value is ignored + */ + function write_null($datum) { return null; } + + /** + * @param boolean $datum + */ + function write_boolean($datum) + { + $byte = $datum ? chr(1) : chr(0); + $this->write($byte); + } + + /** + * @param int $datum + */ + function write_int($datum) { $this->write_long($datum); } + + /** + * @param int $n + */ + function write_long($n) + { + if (Avro::uses_gmp()) + $this->write(AvroGMP::encode_long($n)); + else + $this->write(self::encode_long($n)); + } + + /** + * @param float $datum + * @uses self::float_to_int_bits() + */ + public function write_float($datum) + { + $this->write(self::float_to_int_bits($datum)); + } + + /** + * @param float $datum + * @uses self::double_to_long_bits() + */ + public function write_double($datum) + { + $this->write(self::double_to_long_bits($datum)); + } + + /** + * @param string $str + * @uses self::write_bytes() + */ + function write_string($str) { $this->write_bytes($str); } + + /** + * @param string $bytes + */ + function write_bytes($bytes) + { + $this->write_long(strlen($bytes)); + $this->write($bytes); + } + + /** + * @param string $datum + */ + function write($datum) { $this->io->write($datum); } +} + +/** + * Handles schema-specifc reading of data from the decoder. + * + * Also handles schema resolution between the reader and writer + * schemas (if a writer's schema is provided). + * + * @package Avro + */ +class AvroIODatumReader +{ + /** + * + * @param AvroSchema $writers_schema + * @param AvroSchema $readers_schema + * @returns boolean true if the schemas are consistent with + * each other and false otherwise. + */ + static function schemas_match($writers_schema, $readers_schema) + { + $writers_schema_type = $writers_schema->type; + $readers_schema_type = $readers_schema->type; + + if (AvroSchema::UNION_SCHEMA == $writers_schema_type + || AvroSchema::UNION_SCHEMA == $readers_schema_type) + return true; + + if ($writers_schema_type == $readers_schema_type) + { + if (AvroSchema::is_primitive_type($writers_schema_type)) + return true; + + switch ($readers_schema_type) + { + case AvroSchema::MAP_SCHEMA: + return self::attributes_match($writers_schema->values(), + $readers_schema->values(), + array(AvroSchema::TYPE_ATTR)); + case AvroSchema::ARRAY_SCHEMA: + return self::attributes_match($writers_schema->items(), + $readers_schema->items(), + array(AvroSchema::TYPE_ATTR)); + case AvroSchema::ENUM_SCHEMA: + return self::attributes_match($writers_schema, $readers_schema, + array(AvroSchema::FULLNAME_ATTR)); + case AvroSchema::FIXED_SCHEMA: + return self::attributes_match($writers_schema, $readers_schema, + array(AvroSchema::FULLNAME_ATTR, + AvroSchema::SIZE_ATTR)); + case AvroSchema::RECORD_SCHEMA: + case AvroSchema::ERROR_SCHEMA: + return self::attributes_match($writers_schema, $readers_schema, + array(AvroSchema::FULLNAME_ATTR)); + case AvroSchema::REQUEST_SCHEMA: + // XXX: This seems wrong + return true; + // XXX: no default + } + + if (AvroSchema::INT_TYPE == $writers_schema_type + && in_array($readers_schema_type, array(AvroSchema::LONG_TYPE, + AvroSchema::FLOAT_TYPE, + AvroSchema::DOUBLE_TYPE))) + return true; + + if (AvroSchema::LONG_TYPE == $writers_schema_type + && in_array($readers_schema_type, array(AvroSchema::FLOAT_TYPE, + AvroSchema::DOUBLE_TYPE))) + return true; + + if (AvroSchema::FLOAT_TYPE == $writers_schema_type + && AvroSchema::DOUBLE_TYPE == $readers_schema_type) + return true; + + return false; + } + + } + + /** + * Checks equivalence of the given attributes of the two given schemas. + * + * @param AvroSchema $schema_one + * @param AvroSchema $schema_two + * @param string[] $attribute_names array of string attribute names to compare + * + * @returns boolean true if the attributes match and false otherwise. + */ + static function attributes_match($schema_one, $schema_two, $attribute_names) + { + foreach ($attribute_names as $attribute_name) + if ($schema_one->attribute($attribute_name) + != $schema_two->attribute($attribute_name)) + return false; + return true; + } + + /** + * @var AvroSchema + */ + private $writers_schema; + + /** + * @var AvroSchema + */ + private $readers_schema; + + /** + * @param AvroSchema $writers_schema + * @param AvroSchema $readers_schema + */ + function __construct($writers_schema=null, $readers_schema=null) + { + $this->writers_schema = $writers_schema; + $this->readers_schema = $readers_schema; + } + + /** + * @param AvroSchema $readers_schema + */ + public function set_writers_schema($readers_schema) + { + $this->writers_schema = $readers_schema; + } + + /** + * @param AvroIOBinaryDecoder $decoder + * @returns string + */ + public function read($decoder) + { + if (is_null($this->readers_schema)) + $this->readers_schema = $this->writers_schema; + return $this->read_data($this->writers_schema, $this->readers_schema, + $decoder); + } + + /**#@+ + * @param AvroSchema $writers_schema + * @param AvroSchema $readers_schema + * @param AvroIOBinaryDecoder $decoder + */ + /** + * @returns mixed + */ + public function read_data($writers_schema, $readers_schema, $decoder) + { + if (!self::schemas_match($writers_schema, $readers_schema)) + throw new AvroIOSchemaMatchException($writers_schema, $readers_schema); + + // Schema resolution: reader's schema is a union, writer's schema is not + if (AvroSchema::UNION_SCHEMA == $readers_schema->type() + && AvroSchema::UNION_SCHEMA != $writers_schema->type()) + { + foreach ($readers_schema->schemas() as $schema) + if (self::schemas_match($writers_schema, $schema)) + return $this->read_data($writers_schema, $schema, $decoder); + throw new AvroIOSchemaMatchException($writers_schema, $readers_schema); + } + + switch ($writers_schema->type()) + { + case AvroSchema::NULL_TYPE: + return $decoder->read_null(); + case AvroSchema::BOOLEAN_TYPE: + return $decoder->read_boolean(); + case AvroSchema::INT_TYPE: + return $decoder->read_int(); + case AvroSchema::LONG_TYPE: + return $decoder->read_long(); + case AvroSchema::FLOAT_TYPE: + return $decoder->read_float(); + case AvroSchema::DOUBLE_TYPE: + return $decoder->read_double(); + case AvroSchema::STRING_TYPE: + return $decoder->read_string(); + case AvroSchema::BYTES_TYPE: + return $decoder->read_bytes(); + case AvroSchema::ARRAY_SCHEMA: + return $this->read_array($writers_schema, $readers_schema, $decoder); + case AvroSchema::MAP_SCHEMA: + return $this->read_map($writers_schema, $readers_schema, $decoder); + case AvroSchema::UNION_SCHEMA: + return $this->read_union($writers_schema, $readers_schema, $decoder); + case AvroSchema::ENUM_SCHEMA: + return $this->read_enum($writers_schema, $readers_schema, $decoder); + case AvroSchema::FIXED_SCHEMA: + return $this->read_fixed($writers_schema, $readers_schema, $decoder); + case AvroSchema::RECORD_SCHEMA: + case AvroSchema::ERROR_SCHEMA: + case AvroSchema::REQUEST_SCHEMA: + return $this->read_record($writers_schema, $readers_schema, $decoder); + default: + throw new AvroException(sprintf("Cannot read unknown schema type: %s", + $writers_schema->type())); + } + } + + /** + * @returns array + */ + public function read_array($writers_schema, $readers_schema, $decoder) + { + $items = array(); + $block_count = $decoder->read_long(); + while (0 != $block_count) + { + if ($block_count < 0) + { + $block_count = -$block_count; + $block_size = $decoder->read_long(); // Read (and ignore) block size + } + for ($i = 0; $i < $block_count; $i++) + $items []= $this->read_data($writers_schema->items(), + $readers_schema->items(), + $decoder); + $block_count = $decoder->read_long(); + } + return $items; + } + + /** + * @returns array + */ + public function read_map($writers_schema, $readers_schema, $decoder) + { + $items = array(); + $pair_count = $decoder->read_long(); + while (0 != $pair_count) + { + if ($pair_count < 0) + { + $pair_count = -$pair_count; + // Note: we're not doing anything with block_size other than skipping it + $block_size = $decoder->read_long(); + } + + for ($i = 0; $i < $pair_count; $i++) + { + $key = $decoder->read_string(); + $items[$key] = $this->read_data($writers_schema->values(), + $readers_schema->values(), + $decoder); + } + $pair_count = $decoder->read_long(); + } + return $items; + } + + /** + * @returns mixed + */ + public function read_union($writers_schema, $readers_schema, $decoder) + { + $schema_index = $decoder->read_long(); + $selected_writers_schema = $writers_schema->schema_by_index($schema_index); + return $this->read_data($selected_writers_schema, $readers_schema, $decoder); + } + + /** + * @returns string + */ + public function read_enum($writers_schema, $readers_schema, $decoder) + { + $symbol_index = $decoder->read_int(); + $symbol = $writers_schema->symbol_by_index($symbol_index); + if (!$readers_schema->has_symbol($symbol)) + null; // FIXME: unset wrt schema resolution + return $symbol; + } + + /** + * @returns string + */ + public function read_fixed($writers_schema, $readers_schema, $decoder) + { + return $decoder->read($writers_schema->size()); + } + + /** + * @returns array + */ + public function read_record($writers_schema, $readers_schema, $decoder) + { + $readers_fields = $readers_schema->fields_hash(); + $record = array(); + foreach ($writers_schema->fields() as $writers_field) + { + $type = $writers_field->type(); + if (isset($readers_fields[$writers_field->name()])) + $record[$writers_field->name()] + = $this->read_data($type, + $readers_fields[$writers_field->name()]->type(), + $decoder); + else + $this->skip_data($type, $decoder); + } + // Fill in default values + if (count($readers_fields) > count($record)) + { + $writers_fields = $writers_schema->fields_hash(); + foreach ($readers_fields as $field_name => $field) + { + if (!isset($writers_fields[$field_name])) + { + if ($field->has_default_value()) + $record[$field->name()] + = $this->read_default_value($field->type(), + $field->default_value()); + else + null; // FIXME: unset + } + } + } + + return $record; + } + /**#@-*/ + + /** + * @param AvroSchema $field_schema + * @param null|boolean|int|float|string|array $default_value + * @returns null|boolean|int|float|string|array + * + * @throws AvroException if $field_schema type is unknown. + */ + public function read_default_value($field_schema, $default_value) + { + switch($field_schema->type()) + { + case AvroSchema::NULL_TYPE: + return null; + case AvroSchema::BOOLEAN_TYPE: + return $default_value; + case AvroSchema::INT_TYPE: + case AvroSchema::LONG_TYPE: + return (int) $default_value; + case AvroSchema::FLOAT_TYPE: + case AvroSchema::DOUBLE_TYPE: + return (float) $default_value; + case AvroSchema::STRING_TYPE: + case AvroSchema::BYTES_TYPE: + return $default_value; + case AvroSchema::ARRAY_SCHEMA: + $array = array(); + foreach ($default_value as $json_val) + { + $val = $this->read_default_value($field_schema->items(), $json_val); + $array []= $val; + } + return $array; + case AvroSchema::MAP_SCHEMA: + $map = array(); + foreach ($default_value as $key => $json_val) + $map[$key] = $this->read_default_value($field_schema->values(), + $json_val); + return $map; + case AvroSchema::UNION_SCHEMA: + return $this->read_default_value($field_schema->schema_by_index(0), + $default_value); + case AvroSchema::ENUM_SCHEMA: + case AvroSchema::FIXED_SCHEMA: + return $default_value; + case AvroSchema::RECORD_SCHEMA: + $record = array(); + foreach ($field_schema->fields() as $field) + { + $field_name = $field->name(); + if (!$json_val = $default_value[$field_name]) + $json_val = $field->default_value(); + + $record[$field_name] = $this->read_default_value($field->type(), + $json_val); + } + return $record; + default: + throw new AvroException(sprintf('Unknown type: %s', $field_schema->type())); + } + } + + /** + * @param AvroSchema $writers_schema + * @param AvroIOBinaryDecoder $decoder + */ + private function skip_data($writers_schema, $decoder) + { + switch ($writers_schema->type()) + { + case AvroSchema::NULL_TYPE: + return $decoder->skip_null(); + case AvroSchema::BOOLEAN_TYPE: + return $decoder->skip_boolean(); + case AvroSchema::INT_TYPE: + return $decoder->skip_int(); + case AvroSchema::LONG_TYPE: + return $decoder->skip_long(); + case AvroSchema::FLOAT_TYPE: + return $decoder->skip_float(); + case AvroSchema::DOUBLE_TYPE: + return $decoder->skip_double(); + case AvroSchema::STRING_TYPE: + return $decoder->skip_string(); + case AvroSchema::BYTES_TYPE: + return $decoder->skip_bytes(); + case AvroSchema::ARRAY_SCHEMA: + return $decoder->skip_array($writers_schema, $decoder); + case AvroSchema::MAP_SCHEMA: + return $decoder->skip_map($writers_schema, $decoder); + case AvroSchema::UNION_SCHEMA: + return $decoder->skip_union($writers_schema, $decoder); + case AvroSchema::ENUM_SCHEMA: + return $decoder->skip_enum($writers_schema, $decoder); + case AvroSchema::FIXED_SCHEMA: + return $decoder->skip_fixed($writers_schema, $decoder); + case AvroSchema::RECORD_SCHEMA: + case AvroSchema::ERROR_SCHEMA: + case AvroSchema::REQUEST_SCHEMA: + return $decoder->skip_record($writers_schema, $decoder); + default: + throw new AvroException(sprintf('Uknown schema type: %s', + $writers_schema->type())); + } + } +} + +/** + * Decodes and reads Avro data from an AvroIO object encoded using + * Avro binary encoding. + * + * @package Avro + */ +class AvroIOBinaryDecoder +{ + + /** + * @param int[] array of byte ascii values + * @returns long decoded value + * @internal Requires 64-bit platform + */ + public static function decode_long_from_array($bytes) + { + $b = array_shift($bytes); + $n = $b & 0x7f; + $shift = 7; + while (0 != ($b & 0x80)) + { + $b = array_shift($bytes); + $n |= (($b & 0x7f) << $shift); + $shift += 7; + } + return (($n >> 1) ^ -($n & 1)); + } + + /** + * Performs decoding of the binary string to a float value. + * + * XXX: This is <b>not</b> endian-aware! See comments in + * {@link AvroIOBinaryEncoder::float_to_int_bits()} for details. + * + * @param string $bits + * @returns float + */ + static public function int_bits_to_float($bits) + { + $float = unpack('f', $bits); + return (float) $float[1]; + } + + /** + * Performs decoding of the binary string to a double value. + * + * XXX: This is <b>not</b> endian-aware! See comments in + * {@link AvroIOBinaryEncoder::float_to_int_bits()} for details. + * + * @param string $bits + * @returns float + */ + static public function long_bits_to_double($bits) + { + $double = unpack('d', $bits); + return (double) $double[1]; + } + + /** + * @var AvroIO + */ + private $io; + + /** + * @param AvroIO $io object from which to read. + */ + public function __construct($io) + { + Avro::check_platform(); + $this->io = $io; + } + + /** + * @returns string the next byte from $this->io. + * @throws AvroException if the next byte cannot be read. + */ + private function next_byte() { return $this->read(1); } + + /** + * @returns null + */ + public function read_null() { return null; } + + /** + * @returns boolean + */ + public function read_boolean() + { + return (boolean) (1 == ord($this->next_byte())); + } + + /** + * @returns int + */ + public function read_int() { return (int) $this->read_long(); } + + /** + * @returns long + */ + public function read_long() + { + $byte = ord($this->next_byte()); + $bytes = array($byte); + while (0 != ($byte & 0x80)) + { + $byte = ord($this->next_byte()); + $bytes []= $byte; + } + + if (Avro::uses_gmp()) + return AvroGMP::decode_long_from_array($bytes); + + return self::decode_long_from_array($bytes); + } + + /** + * @returns float + */ + public function read_float() + { + return self::int_bits_to_float($this->read(4)); + } + + /** + * @returns double + */ + public function read_double() + { + return self::long_bits_to_double($this->read(8)); + } + + /** + * A string is encoded as a long followed by that many bytes + * of UTF-8 encoded character data. + * @returns string + */ + public function read_string() { return $this->read_bytes(); } + + /** + * @returns string + */ + public function read_bytes() { return $this->read($this->read_long()); } + + /** + * @param int $len count of bytes to read + * @returns string + */ + public function read($len) { return $this->io->read($len); } + + public function skip_null() { return null; } + + public function skip_boolean() { return $this->skip(1); } + + public function skip_int() { return $this->skip_long(); } + + protected function skip_long() + { + $b = $this->next_byte(); + while (0 != ($b & 0x80)) + $b = $this->next_byte(); + } + + public function skip_float() { return $this->skip(4); } + + public function skip_double() { return $this->skip(8); } + + public function skip_bytes() { return $this->skip($this->read_long()); } + + public function skip_string() { return $this->skip_bytes(); } + + /** + * @param int $len count of bytes to skip + * @uses AvroIO::seek() + */ + public function skip($len) { $this->seek($len, AvroIO::SEEK_CUR); } + + /** + * @returns int position of pointer in AvroIO instance + * @uses AvroIO::tell() + */ + private function tell() { return $this->io->tell(); } + + /** + * @param int $offset + * @param int $whence + * @returns boolean true upon success + * @uses AvroIO::seek() + */ + private function seek($offset, $whence) + { + return $this->io->seek($offset, $whence); + } +} + |