| <?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. |
| */ |
| |
| namespace Apache\Ignite\Internal\Binary; |
| |
| use Ds\Map; |
| use Ds\Set; |
| use Brick\Math\BigDecimal; |
| use Brick\Math\BigInteger; |
| use Apache\Ignite\Exception\ClientException; |
| use Apache\Ignite\Type\ObjectType; |
| use Apache\Ignite\Type\MapObjectType; |
| use Apache\Ignite\Type\CollectionObjectType; |
| use Apache\Ignite\Type\ComplexObjectType; |
| use Apache\Ignite\Type\ObjectArrayType; |
| use Apache\Ignite\Data\Date; |
| use Apache\Ignite\Data\Time; |
| use Apache\Ignite\Data\Timestamp; |
| use Apache\Ignite\Data\EnumItem; |
| use Apache\Ignite\Data\BinaryObject; |
| use Apache\Ignite\Internal\Utils\ArgumentChecker; |
| |
| class BinaryUtils |
| { |
| const FLOAT_EPSILON = 0.00001; |
| public static $is32BitInt = PHP_INT_MAX === TypeInfo::MAX_INT_VALUE; |
| |
| public static function getSize(int $typeCode): int |
| { |
| return TypeInfo::getTypeInfo($typeCode)->getSize(); |
| } |
| |
| public static function checkCompatibility($value, $type): void |
| { |
| if (!$type) { |
| return; |
| } |
| $typeCode = BinaryUtils::getTypeCode($type); |
| if ($value === null) { |
| if (!TypeInfo::getTypeInfo($typeCode)->isNullable()) { |
| BinaryUtils::typeCastError(ObjectType::NULL, $typeCode); |
| } |
| return; |
| } elseif (BinaryUtils::isStandardType($typeCode)) { |
| BinaryUtils::checkStandardTypeCompatibility($value, $typeCode, $type); |
| return; |
| } |
| $valueTypeCode = BinaryUtils::getTypeCode(BinaryUtils::calcObjectType($value)); |
| if ($typeCode !== $valueTypeCode) { |
| BinaryUtils::typeCastError($valueTypeCode, $typeCode); |
| } |
| } |
| |
| public static function isStandardType($typeCode): bool |
| { |
| return $typeCode !== ObjectType::BINARY_OBJECT && |
| $typeCode !== ObjectType::COMPLEX_OBJECT; |
| } |
| |
| public static function checkStandardTypeCompatibility($value, $typeCode, $type = null, $signed = true) |
| { |
| $valueType = BinaryUtils::getPhpTypeName($value); |
| switch ($typeCode) { |
| case ObjectType::BYTE: |
| case ObjectType::SHORT: |
| case ObjectType::INTEGER: |
| if (!is_integer($value)) { |
| BinaryUtils::valueCastError($value, $typeCode); |
| } |
| $typeInfo = TypeInfo::getTypeInfo($typeCode); |
| $min = $typeInfo->getMinValue(); |
| $max = $typeInfo->getMaxValue(); |
| if ($signed && ($min && $value < $min || $max && $value > $max) || |
| !$signed && ($value < 0 || $value > $max - $min)) { |
| BinaryUtils::valueCastError($value, $typeCode); |
| } |
| return; |
| case ObjectType::LONG: |
| case ObjectType::FLOAT: |
| case ObjectType::DOUBLE: |
| if (!is_integer($value) && !is_float($value)) { |
| BinaryUtils::valueCastError($value, $typeCode); |
| } |
| return; |
| case ObjectType::CHAR: |
| if (!is_string($value) || mb_strlen($value) !== 1) { |
| BinaryUtils::valueCastError($value, $typeCode); |
| } |
| return; |
| case ObjectType::BOOLEAN: |
| if (!is_bool($value)) { |
| BinaryUtils::valueCastError($value, $typeCode); |
| } |
| return; |
| case ObjectType::STRING: |
| if (!is_string($value)) { |
| BinaryUtils::valueCastError($value, $typeCode); |
| } |
| return; |
| case ObjectType::UUID: |
| if (!BinaryUtils::isIndexedArray($value) || |
| count($value) !== BinaryUtils::getSize(ObjectType::UUID)) { |
| BinaryUtils::valueCastError($value, $typeCode); |
| } |
| foreach ($value as $element) { |
| BinaryUtils::checkStandardTypeCompatibility($element, ObjectType::BYTE, null, false); |
| } |
| return; |
| case ObjectType::DATE: |
| if (!($value instanceof Date)) { |
| BinaryUtils::valueCastError($value, $typeCode); |
| } |
| return; |
| case ObjectType::ENUM: |
| if (!($value instanceof EnumItem)) { |
| BinaryUtils::valueCastError($value, $typeCode); |
| } |
| return; |
| case ObjectType::DECIMAL: |
| if (!($value instanceof BigDecimal)) { |
| BinaryUtils::valueCastError($value, $typeCode); |
| } |
| return; |
| case ObjectType::TIMESTAMP: |
| if (!($value instanceof Timestamp)) { |
| BinaryUtils::valueCastError($value, $typeCode); |
| } |
| return; |
| case ObjectType::TIME: |
| if (!($value instanceof Time)) { |
| BinaryUtils::valueCastError($value, $typeCode); |
| } |
| return; |
| case ObjectType::BYTE_ARRAY: |
| case ObjectType::SHORT_ARRAY: |
| case ObjectType::INTEGER_ARRAY: |
| case ObjectType::LONG_ARRAY: |
| case ObjectType::FLOAT_ARRAY: |
| case ObjectType::DOUBLE_ARRAY: |
| case ObjectType::CHAR_ARRAY: |
| case ObjectType::BOOLEAN_ARRAY: |
| case ObjectType::STRING_ARRAY: |
| case ObjectType::UUID_ARRAY: |
| case ObjectType::DATE_ARRAY: |
| case ObjectType::OBJECT_ARRAY: |
| case ObjectType::ENUM_ARRAY: |
| case ObjectType::DECIMAL_ARRAY: |
| case ObjectType::TIMESTAMP_ARRAY: |
| case ObjectType::TIME_ARRAY: |
| if (!BinaryUtils::isIndexedArray($value)) { |
| BinaryUtils::typeCastError($valueType, $typeCode); |
| } |
| return; |
| case ObjectType::MAP: |
| if (!($value instanceof Map) && !is_array($value)) { |
| BinaryUtils::typeCastError($valueType, $typeCode); |
| } |
| return; |
| case ObjectType::COLLECTION: |
| $isSet = $type && CollectionObjectType::isSet($type->getSubType()); |
| if (!($isSet && $value instanceof Set || BinaryUtils::isIndexedArray($value))) { |
| BinaryUtils::typeCastError($valueType, $isSet ? 'set' : $typeCode); |
| } |
| return; |
| case ObjectType::NULL: |
| if ($value !== null) { |
| BinaryUtils::typeCastError('not null', $typeCode); |
| } |
| return; |
| default: |
| $valueTypeCode = BinaryUtils::getTypeCode(BinaryUtils::calcObjectType($value)); |
| if ($valueTypeCode === ObjectType::BINARY_OBJECT) { |
| BinaryUtils::typeCastError($valueTypeCode, $typeCode); |
| } |
| return; |
| } |
| } |
| |
| public static function checkTypesCompatibility($expectedType, int $actualTypeCode): void |
| { |
| if ($expectedType === null) { |
| return; |
| } |
| $expectedTypeCode = BinaryUtils::getTypeCode($expectedType); |
| if ($actualTypeCode === ObjectType::NULL) { |
| return; |
| } elseif ($expectedTypeCode === ObjectType::BINARY_OBJECT || |
| $actualTypeCode === ObjectType::BINARY_OBJECT && |
| $expectedTypeCode === ObjectType::COMPLEX_OBJECT) { |
| return; |
| } elseif ($actualTypeCode !== $expectedTypeCode) { |
| BinaryUtils::typeCastError($actualTypeCode, $expectedTypeCode); |
| } |
| } |
| |
| public static function calcObjectType($object) |
| { |
| if (is_integer($object)) { |
| return ObjectType::INTEGER; |
| } elseif (is_float($object)) { |
| return ObjectType::DOUBLE; |
| } elseif (is_string($object)) { |
| return ObjectType::STRING; |
| } elseif (is_bool($object)) { |
| return ObjectType::BOOLEAN; |
| } elseif (is_array($object)) { |
| if (count($object) > 0) { |
| if (BinaryUtils::isIndexedArray($object)) { |
| if ($object[0] !== null) { |
| // indexed array |
| return BinaryUtils::getArrayType(BinaryUtils::calcObjectType($object[0])); |
| } |
| } else { |
| // associative array |
| return new MapObjectType(); |
| } |
| } else { |
| BinaryUtils::noDefaultMapping("empty array"); |
| } |
| } elseif ($object instanceof Time) { |
| return ObjectType::TIME; |
| } elseif ($object instanceof Timestamp) { |
| return ObjectType::TIMESTAMP; |
| } elseif ($object instanceof Date) { |
| return ObjectType::DATE; |
| } elseif ($object instanceof EnumItem) { |
| return ObjectType::ENUM; |
| } elseif ($object instanceof BigDecimal) { |
| return ObjectType::DECIMAL; |
| } elseif ($object instanceof Set) { |
| return new CollectionObjectType(CollectionObjectType::HASH_SET); |
| } elseif ($object instanceof Map) { |
| return new MapObjectType(); |
| } elseif ($object instanceof BinaryObject) { |
| return ObjectType::BINARY_OBJECT; |
| } elseif (is_object($object)) { |
| return new ComplexObjectType(); |
| } |
| BinaryUtils::noDefaultMapping(BinaryUtils::getPhpTypeName($object)); |
| return null; |
| } |
| |
| public static function getArrayType($elementType) |
| { |
| switch (BinaryUtils::getTypeCode($elementType)) { |
| case ObjectType::BYTE: |
| return ObjectType::BYTE_ARRAY; |
| case ObjectType::SHORT: |
| return ObjectType::SHORT_ARRAY; |
| case ObjectType::INTEGER: |
| return ObjectType::INTEGER_ARRAY; |
| case ObjectType::LONG: |
| return ObjectType::LONG_ARRAY; |
| case ObjectType::FLOAT: |
| return ObjectType::FLOAT_ARRAY; |
| case ObjectType::DOUBLE: |
| return ObjectType::DOUBLE_ARRAY; |
| case ObjectType::CHAR: |
| return ObjectType::CHAR_ARRAY; |
| case ObjectType::BOOLEAN: |
| return ObjectType::BOOLEAN_ARRAY; |
| case ObjectType::STRING: |
| return ObjectType::STRING_ARRAY; |
| case ObjectType::UUID: |
| return ObjectType::UUID_ARRAY; |
| case ObjectType::DATE: |
| return ObjectType::DATE_ARRAY; |
| case ObjectType::ENUM: |
| return ObjectType::ENUM_ARRAY; |
| case ObjectType::DECIMAL: |
| return ObjectType::DECIMAL_ARRAY; |
| case ObjectType::TIMESTAMP: |
| return ObjectType::TIMESTAMP_ARRAY; |
| case ObjectType::TIME: |
| return ObjectType::TIME_ARRAY; |
| case ObjectType::BINARY_OBJECT: |
| return new ObjectArrayType(); |
| default: |
| return new ObjectArrayType($elementType); |
| } |
| } |
| |
| public static function getArrayElementType($arrayType) |
| { |
| if ($arrayType instanceof ObjectArrayType) { |
| return $arrayType->getElementType(); |
| } elseif ($arrayType === ObjectType::OBJECT_ARRAY) { |
| return null; |
| } |
| $info = TypeInfo::getTypeInfo($arrayType); |
| if (!$info || !$info->getElementTypeCode()) { |
| BinaryUtils::internalError(); |
| } |
| return $info->getElementTypeCode(); |
| } |
| |
| public static function getTypeCode($objectType): int |
| { |
| return $objectType instanceof ObjectType ? $objectType->getTypeCode() : $objectType; |
| } |
| |
| public static function getTypeName($objectType): string |
| { |
| if (is_string($objectType)) { |
| return $objectType; |
| } |
| $typeCode = BinaryUtils::getTypeCode($objectType); |
| $info = TypeInfo::getTypeInfo($typeCode); |
| return $info ? $info->getName() : 'type code ' . $typeCode; |
| } |
| |
| public static function getPhpTypeName($object): string |
| { |
| if (is_array($object) && !BinaryUtils::isIndexedArray($object)) { |
| return 'associative array'; |
| } |
| return gettype($object); |
| } |
| |
| public static function checkObjectType($type, string $argName): void |
| { |
| if ($type === null || $type instanceof ObjectType) { |
| return; |
| } |
| ArgumentChecker::hasValueFrom($type, $argName, false, TypeInfo::getPrimitiveTypes()); |
| } |
| |
| public static function floatEquals(float $val1, float $val2): bool |
| { |
| return abs($val1 - $val2) < BinaryUtils::FLOAT_EPSILON; |
| } |
| |
| public static function getLongHex(BigInteger $value, bool $isNegative): string |
| { |
| $size = TypeInfo::getTypeInfo(ObjectType::LONG)->getSize(); |
| if ($isNegative) { |
| $value = BigInteger::parse(str_pad('1', $size * 2 + 1, '0'), 16)->minus($value); |
| } |
| return str_pad($value->toBase(16), $size * 2, '0', STR_PAD_LEFT); |
| } |
| |
| public static function hashCode(?string $str): int |
| { |
| $hash = 0; |
| $length = strlen($str); |
| if ($str && $length > 0) { |
| for ($i = 0; $i < $length; $i++) { |
| $hash = (($hash << 5) - $hash) + ord($str[$i]); |
| $hash &= 0xFFFFFFFF; // Convert to 32bit integer |
| } |
| } |
| return BinaryUtils::intVal32($hash); |
| } |
| |
| public static function hashCodeLowerCase(?string $str): int |
| { |
| return BinaryUtils::hashCode($str ? strtolower($str) : $str); |
| } |
| |
| public static function contentHashCode(MessageBuffer $buffer, int $startPos, int $endPos): int |
| { |
| $hash = 1; |
| $length = $endPos - $startPos + 1; |
| $content = $buffer->getSlice($startPos, $length); |
| for ($i = 0; $i < $length; $i++) { |
| $hash = 31 * $hash + ord($content[$i]); |
| $hash &= 0xFFFFFFFF; // Convert to 32bit integer |
| } |
| return BinaryUtils::intVal32($hash); |
| } |
| |
| public static function intVal32(int $value): int |
| { |
| if (!BinaryUtils::$is32BitInt) { |
| $value = ($value & 0xFFFFFFFF); |
| if ($value & 0x80000000) { |
| $value = -((~$value & 0xFFFFFFFF) + 1); |
| } |
| } |
| return $value; |
| } |
| |
| public static function internalError(string $message = null): void |
| { |
| throw new ClientException($message ? $message : 'Internal library error'); |
| } |
| |
| public static function unsupportedType($type): void |
| { |
| throw new ClientException(sprintf('Type %s is not supported', BinaryUtils::getTypeName($type))); |
| } |
| |
| public static function noDefaultMapping($type): void |
| { |
| throw new ClientException(sprintf('%s has no default type mapping', BinaryUtils::getTypeName($type))); |
| } |
| |
| public static function serializationError(bool $serialize, string $message = null): void |
| { |
| $msg = $serialize ? 'Complex object can not be serialized' : 'Complex object can not be deserialized'; |
| if ($message) { |
| $msg = $msg . ': ' . $message; |
| } |
| throw new ClientException($msg); |
| } |
| |
| public static function typeCastError($fromType, $toType): void |
| { |
| throw new ClientException(sprintf('Type "%s" can not be cast to %s', |
| BinaryUtils::getTypeName($fromType), BinaryUtils::getTypeName($toType))); |
| } |
| |
| public static function valueCastError($value, $toType): void |
| { |
| throw new ClientException(sprintf('Value "%s" can not be cast to %s', |
| print_r($value, true), BinaryUtils::getTypeName($toType))); |
| } |
| |
| private static function isIndexedArray(array $object): bool |
| { |
| return $object === array_values($object); |
| } |
| } |
