| <?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\Cache; |
| |
| use Apache\Ignite\Type\ObjectType; |
| use Apache\Ignite\Type\ObjectArrayType; |
| use Apache\Ignite\Type\ComplexObjectType; |
| use Apache\Ignite\Exception\ClientException; |
| use Apache\Ignite\Internal\Binary\MessageBuffer; |
| use Apache\Ignite\Internal\Binary\BinaryUtils; |
| use Apache\Ignite\Internal\Binary\BinaryCommunicator; |
| use Apache\Ignite\Internal\Utils\ArgumentChecker; |
| |
| /** |
| * Class representing Ignite cache configuration on a server. |
| * |
| * All configuration settings are optional and have defaults which are defined on a server side. |
| * |
| * See Apache Ignite documentation for details of every configuration setting. |
| */ |
| class CacheConfiguration |
| { |
| const PROP_NAME = 0; |
| const PROP_CACHE_MODE = 1; |
| const PROP_ATOMICITY_MODE = 2; |
| const PROP_BACKUPS = 3; |
| const PROP_WRITE_SYNCHRONIZATION_MODE = 4; |
| const PROP_COPY_ON_READ = 5; |
| const PROP_READ_FROM_BACKUP = 6; |
| const PROP_DATA_REGION_NAME = 100; |
| const PROP_IS_ONHEAP_CACHE_ENABLED = 101; |
| const PROP_QUERY_ENTITY = 200; |
| const PROP_QUERY_PARALLELISM = 201; |
| const PROP_QUERY_DETAIL_METRICS_SIZE = 202; |
| const PROP_SQL_SCHEMA = 203; |
| const PROP_SQL_INDEX_INLINE_MAX_SIZE = 204; |
| const PROP_SQL_ESCAPE_ALL = 205; |
| const PROP_MAX_QUERY_ITERATORS = 206; |
| const PROP_REBALANCE_MODE = 300; |
| const PROP_REBALANCE_DELAY = 301; |
| const PROP_REBALANCE_TIMEOUT = 302; |
| const PROP_REBALANCE_BATCH_SIZE = 303; |
| const PROP_REBALANCE_BATCHES_PREFETCH_COUNT = 304; |
| const PROP_REBALANCE_ORDER = 305; |
| const PROP_REBALANCE_THROTTLE = 306; |
| const PROP_GROUP_NAME = 400; |
| const PROP_CACHE_KEY_CONFIGURATION = 401; |
| const PROP_DEFAULT_LOCK_TIMEOUT = 402; |
| const PROP_MAX_CONCURRENT_ASYNC_OPS = 403; |
| const PROP_PARTITION_LOSS_POLICY = 404; |
| const PROP_EAGER_TTL = 405; |
| const PROP_STATISTICS_ENABLED = 406; |
| |
| /** @name AtomicityMode |
| * @anchor AtomicityMode |
| * @{ |
| */ |
| const ATOMICITY_MODE_TRANSACTIONAL = 0; |
| const ATOMICITY_MODE_ATOMIC = 1; |
| /** @} */ // end of AtomicityMode |
| |
| /** @name CacheMode |
| * @anchor CacheMode |
| * @{ |
| */ |
| const CACHE_MODE_LOCAL = 0; |
| const CACHE_MODE_REPLICATED = 1; |
| const CACHE_MODE_PARTITIONED = 2; |
| /** @} */ // end of CacheMode |
| |
| /** @name PartitionLossPolicy |
| * @anchor PartitionLossPolicy |
| * @{ |
| */ |
| const PARTITION_LOSS_POLICY_READ_ONLY_SAFE = 0; |
| const PARTITION_LOSS_POLICY_READ_ONLY_ALL = 1; |
| const PARTITION_LOSS_POLICY_READ_WRITE_SAFE = 2; |
| const PARTITION_LOSS_POLICY_READ_WRITE_ALL = 3; |
| const PARTITION_LOSS_POLICY_IGNORE = 4; |
| /** @} */ // end of PartitionLossPolicy |
| |
| /** @name RebalanceMode |
| * @anchor RebalanceMode |
| * @{ |
| */ |
| const REABALANCE_MODE_SYNC = 0; |
| const REABALANCE_MODE_ASYNC = 1; |
| const REABALANCE_MODE_NONE = 2; |
| /** @} */ // end of RebalanceMode |
| |
| /** @name WriteSynchronizationMode |
| * @anchor WriteSynchronizationMode |
| * @{ |
| */ |
| const WRITE_SYNC_MODE_FULL_SYNC = 0; |
| const WRITE_SYNC_MODE_FULL_ASYNC = 1; |
| const WRITE_SYNC_MODE_PRIMARY_SYNC = 2; |
| /** @} */ // end of WriteSynchronizationMode |
| |
| private $properties; |
| private static $propInfo; |
| |
| /** |
| * Public CacheConfiguration constructor. |
| */ |
| public function __construct() |
| { |
| $this->properties = []; |
| } |
| |
| /** |
| * |
| * |
| * @param string $name |
| * |
| * @return CacheConfiguration the same instance of the CacheConfiguration. |
| */ |
| public function setName(string $name): CacheConfiguration |
| { |
| $this->properties[self::PROP_NAME] = $name; |
| return $this; |
| } |
| |
| /** |
| * |
| * |
| * @return string|null |
| */ |
| public function getName(): ?string |
| { |
| return $this->getProperty(self::PROP_NAME); |
| } |
| |
| /** |
| * |
| * |
| * @param int $atomicityMode one of @ref AtomicityMode constants. |
| * |
| * @return CacheConfiguration the same instance of the CacheConfiguration. |
| * |
| * @throws ClientException if error. |
| */ |
| public function setAtomicityMode(int $atomicityMode): CacheConfiguration |
| { |
| ArgumentChecker::hasValueFrom( |
| $atomicityMode, 'atomicityMode', false, [self::ATOMICITY_MODE_TRANSACTIONAL, self::ATOMICITY_MODE_ATOMIC]); |
| $this->properties[self::PROP_ATOMICITY_MODE] = $atomicityMode; |
| return $this; |
| } |
| |
| /** |
| * |
| * |
| * @return int|null |
| */ |
| public function getAtomicityMode(): ?int |
| { |
| return $this->getProperty(self::PROP_ATOMICITY_MODE); |
| } |
| |
| /** |
| * |
| * |
| * @param int $backups |
| * |
| * @return CacheConfiguration the same instance of the CacheConfiguration. |
| */ |
| public function setBackups(int $backups): CacheConfiguration |
| { |
| $this->properties[self::PROP_BACKUPS] = $backups; |
| return $this; |
| } |
| |
| /** |
| * |
| * |
| * @return int|null |
| */ |
| public function getBackups(): ?int |
| { |
| return $this->getProperty(self::PROP_BACKUPS); |
| } |
| |
| /** |
| * |
| * |
| * @param int $cacheMode one of @ref CacheMode constants. |
| * |
| * @return CacheConfiguration the same instance of the CacheConfiguration. |
| * |
| * @throws ClientException if error. |
| */ |
| public function setCacheMode(int $cacheMode): CacheConfiguration |
| { |
| ArgumentChecker::hasValueFrom( |
| $cacheMode, |
| 'cacheMode', |
| false, |
| [self::CACHE_MODE_LOCAL, self::CACHE_MODE_REPLICATED, self::CACHE_MODE_PARTITIONED]); |
| $this->properties[self::PROP_CACHE_MODE] = $cacheMode; |
| return $this; |
| } |
| |
| /** |
| * |
| * |
| * @return int|null |
| */ |
| public function getCacheMode(): ?int |
| { |
| return $this->getProperty(self::PROP_CACHE_MODE); |
| } |
| |
| /** |
| * |
| * |
| * @param bool $copyOnRead |
| * |
| * @return CacheConfiguration the same instance of the CacheConfiguration. |
| */ |
| public function setCopyOnRead(bool $copyOnRead): CacheConfiguration |
| { |
| $this->properties[self::PROP_COPY_ON_READ] = $copyOnRead; |
| return $this; |
| } |
| |
| /** |
| * |
| * |
| * @return bool|null |
| */ |
| public function getCopyOnRead(): ?bool |
| { |
| return $this->getProperty(self::PROP_COPY_ON_READ); |
| } |
| |
| /** |
| * |
| * |
| * @param string|null $dataRegionName |
| * |
| * @return CacheConfiguration the same instance of the CacheConfiguration. |
| */ |
| public function setDataRegionName(?string $dataRegionName): CacheConfiguration |
| { |
| $this->properties[self::PROP_DATA_REGION_NAME] = $dataRegionName; |
| return $this; |
| } |
| |
| /** |
| * |
| * |
| * @return string|null |
| */ |
| public function getDataRegionName(): ?string |
| { |
| return $this->getProperty(self::PROP_DATA_REGION_NAME); |
| } |
| |
| /** |
| * |
| * |
| * @param bool $eagerTtl |
| * |
| * @return CacheConfiguration the same instance of the CacheConfiguration. |
| */ |
| public function setEagerTtl(bool $eagerTtl): CacheConfiguration |
| { |
| $this->properties[self::PROP_EAGER_TTL] = $eagerTtl; |
| return $this; |
| } |
| |
| /** |
| * |
| * |
| * @return bool|null |
| */ |
| public function getEagerTtl(): ?bool |
| { |
| return $this->getProperty(self::PROP_EAGER_TTL); |
| } |
| |
| /** |
| * |
| * |
| * @param bool $statisticsEnabled |
| * |
| * @return CacheConfiguration the same instance of the CacheConfiguration. |
| */ |
| public function setStatisticsEnabled(bool $statisticsEnabled): CacheConfiguration |
| { |
| $this->properties[self::PROP_STATISTICS_ENABLED] = $statisticsEnabled; |
| return $this; |
| } |
| |
| /** |
| * |
| * |
| * @return bool|null |
| */ |
| public function getStatisticsEnabled(): ?bool |
| { |
| return $this->getProperty(self::PROP_STATISTICS_ENABLED); |
| } |
| |
| /** |
| * |
| * |
| * @param string|null $groupName |
| * |
| * @return CacheConfiguration the same instance of the CacheConfiguration. |
| */ |
| public function setGroupName(?string $groupName): CacheConfiguration |
| { |
| $this->properties[self::PROP_GROUP_NAME] = $groupName; |
| return $this; |
| } |
| |
| /** |
| * |
| * |
| * @return string|null |
| */ |
| public function getGroupName(): ?string |
| { |
| return $this->getProperty(self::PROP_GROUP_NAME); |
| } |
| |
| /** |
| * |
| * |
| * @param float $lockTimeout |
| * |
| * @return CacheConfiguration the same instance of the CacheConfiguration. |
| */ |
| public function setDefaultLockTimeout(float $lockTimeout): CacheConfiguration |
| { |
| $this->properties[self::PROP_DEFAULT_LOCK_TIMEOUT] = $lockTimeout; |
| return $this; |
| } |
| |
| /** |
| * |
| * |
| * @return float|null |
| */ |
| public function getDefaultLockTimeout(): ?float |
| { |
| return $this->getProperty(self::PROP_DEFAULT_LOCK_TIMEOUT); |
| } |
| |
| /** |
| * |
| * |
| * @param int $maxConcurrentAsyncOperations |
| * |
| * @return CacheConfiguration the same instance of the CacheConfiguration. |
| */ |
| public function setMaxConcurrentAsyncOperations(int $maxConcurrentAsyncOperations): CacheConfiguration |
| { |
| $this->properties[self::PROP_MAX_CONCURRENT_ASYNC_OPS] = $maxConcurrentAsyncOperations; |
| return $this; |
| } |
| |
| /** |
| * |
| * |
| * @return int|null |
| */ |
| public function getMaxConcurrentAsyncOperations(): ?int |
| { |
| return $this->getProperty(self::PROP_MAX_CONCURRENT_ASYNC_OPS); |
| } |
| |
| /** |
| * |
| * |
| * @param int $maxQueryIterators |
| * |
| * @return CacheConfiguration the same instance of the CacheConfiguration. |
| */ |
| public function setMaxQueryIterators(int $maxQueryIterators): CacheConfiguration |
| { |
| $this->properties[self::PROP_MAX_QUERY_ITERATORS] = $maxQueryIterators; |
| return $this; |
| } |
| |
| /** |
| * |
| * |
| * @return int|null |
| */ |
| public function getMaxQueryIterators(): ?int |
| { |
| return $this->getProperty(self::PROP_MAX_QUERY_ITERATORS); |
| } |
| |
| /** |
| * |
| * |
| * @param bool $isOnheapCacheEnabled |
| * |
| * @return CacheConfiguration the same instance of the CacheConfiguration. |
| */ |
| public function setIsOnheapCacheEnabled(bool $isOnheapCacheEnabled): CacheConfiguration |
| { |
| $this->properties[self::PROP_IS_ONHEAP_CACHE_ENABLED] = $isOnheapCacheEnabled; |
| return $this; |
| } |
| |
| /** |
| * |
| * |
| * @return bool|null |
| */ |
| public function getIsOnheapCacheEnabled(): ?bool |
| { |
| return $this->getProperty(self::PROP_IS_ONHEAP_CACHE_ENABLED); |
| } |
| |
| /** |
| * |
| * |
| * @param int $partitionLossPolicy one of @ref PartitionLossPolicy constants. |
| * |
| * @return CacheConfiguration the same instance of the CacheConfiguration. |
| * |
| * @throws ClientException if error. |
| */ |
| public function setPartitionLossPolicy(int $partitionLossPolicy): CacheConfiguration |
| { |
| ArgumentChecker::hasValueFrom( |
| $partitionLossPolicy, |
| 'partitionLossPolicy', |
| false, |
| [ |
| self::PARTITION_LOSS_POLICY_READ_ONLY_SAFE, |
| self::PARTITION_LOSS_POLICY_READ_ONLY_ALL, |
| self::PARTITION_LOSS_POLICY_READ_WRITE_SAFE, |
| self::PARTITION_LOSS_POLICY_READ_WRITE_ALL, |
| self::PARTITION_LOSS_POLICY_IGNORE |
| ]); |
| $this->properties[self::PROP_PARTITION_LOSS_POLICY] = $partitionLossPolicy; |
| return $this; |
| } |
| |
| /** |
| * |
| * |
| * @return int|null |
| */ |
| public function getPartitionLossPolicy(): ?int |
| { |
| return $this->getProperty(self::PROP_PARTITION_LOSS_POLICY); |
| } |
| |
| /** |
| * |
| * |
| * @param int $queryDetailMetricsSize |
| * |
| * @return CacheConfiguration the same instance of the CacheConfiguration. |
| */ |
| public function setQueryDetailMetricsSize(int $queryDetailMetricsSize): CacheConfiguration |
| { |
| $this->properties[self::PROP_QUERY_DETAIL_METRICS_SIZE] = $queryDetailMetricsSize; |
| return $this; |
| } |
| |
| /** |
| * |
| * |
| * @return int|null |
| */ |
| public function getQueryDetailMetricsSize(): ?int |
| { |
| return $this->getProperty(self::PROP_QUERY_DETAIL_METRICS_SIZE); |
| } |
| |
| /** |
| * |
| * |
| * @param int $queryParallelism |
| * |
| * @return CacheConfiguration the same instance of the CacheConfiguration. |
| */ |
| public function setQueryParallelism(int $queryParallelism): CacheConfiguration |
| { |
| $this->properties[self::PROP_QUERY_PARALLELISM] = $queryParallelism; |
| return $this; |
| } |
| |
| /** |
| * |
| * |
| * @return int|null |
| */ |
| public function getQueryParallelism(): ?int |
| { |
| return $this->getProperty(self::PROP_QUERY_PARALLELISM); |
| } |
| |
| /** |
| * |
| * |
| * @param bool $readFromBackup |
| * |
| * @return CacheConfiguration the same instance of the CacheConfiguration. |
| */ |
| public function setReadFromBackup(bool $readFromBackup): CacheConfiguration |
| { |
| $this->properties[self::PROP_READ_FROM_BACKUP] = $readFromBackup; |
| return $this; |
| } |
| |
| /** |
| * |
| * |
| * @return bool|null |
| */ |
| public function getReadFromBackup(): ?bool |
| { |
| return $this->getProperty(self::PROP_READ_FROM_BACKUP); |
| } |
| |
| /** |
| * |
| * |
| * @param int $rebalanceBatchSize |
| * |
| * @return CacheConfiguration the same instance of the CacheConfiguration. |
| */ |
| public function setRebalanceBatchSize(int $rebalanceBatchSize): CacheConfiguration |
| { |
| $this->properties[self::PROP_REBALANCE_BATCH_SIZE] = $rebalanceBatchSize; |
| return $this; |
| } |
| |
| /** |
| * |
| * |
| * @return int|null |
| */ |
| public function getRebalanceBatchSize(): ?int |
| { |
| return $this->getProperty(self::PROP_REBALANCE_BATCH_SIZE); |
| } |
| |
| /** |
| * |
| * |
| * @param float $rebalanceBatchesPrefetchCount |
| * |
| * @return CacheConfiguration the same instance of the CacheConfiguration. |
| */ |
| public function setRebalanceBatchesPrefetchCount(float $rebalanceBatchesPrefetchCount): CacheConfiguration |
| { |
| $this->properties[self::PROP_REBALANCE_BATCHES_PREFETCH_COUNT] = $rebalanceBatchesPrefetchCount; |
| return $this; |
| } |
| |
| /** |
| * |
| * |
| * @return float|null |
| */ |
| public function getRebalanceBatchesPrefetchCount(): ?float |
| { |
| return $this->getProperty(self::PROP_REBALANCE_BATCHES_PREFETCH_COUNT); |
| } |
| |
| /** |
| * |
| * |
| * @param float $rebalanceDelay |
| * |
| * @return CacheConfiguration the same instance of the CacheConfiguration. |
| */ |
| public function setRebalanceDelay(float $rebalanceDelay): CacheConfiguration |
| { |
| $this->properties[self::PROP_REBALANCE_DELAY] = $rebalanceDelay; |
| return $this; |
| } |
| |
| /** |
| * |
| * |
| * @return float|null |
| */ |
| public function getRebalanceDelay(): ?float |
| { |
| return $this->getProperty(self::PROP_REBALANCE_DELAY); |
| } |
| |
| /** |
| * |
| * |
| * @param int $rebalanceMode one of @ref RebalanceMode constants. |
| * |
| * @return CacheConfiguration the same instance of the CacheConfiguration. |
| * |
| * @throws ClientException if error. |
| */ |
| public function setRebalanceMode(int $rebalanceMode): CacheConfiguration |
| { |
| ArgumentChecker::hasValueFrom( |
| $rebalanceMode, |
| 'rebalanceMode', |
| false, |
| [self::REABALANCE_MODE_SYNC, self::REABALANCE_MODE_ASYNC, self::REABALANCE_MODE_NONE]); |
| $this->properties[self::PROP_REBALANCE_MODE] = $rebalanceMode; |
| return $this; |
| } |
| |
| /** |
| * |
| * |
| * @return int|null |
| */ |
| public function getRebalanceMode(): ?int |
| { |
| return $this->getProperty(self::PROP_REBALANCE_MODE); |
| } |
| |
| /** |
| * |
| * |
| * @param int $rebalanceOrder |
| * |
| * @return CacheConfiguration the same instance of the CacheConfiguration. |
| */ |
| public function setRebalanceOrder(int $rebalanceOrder): CacheConfiguration |
| { |
| $this->properties[self::PROP_REBALANCE_ORDER] = $rebalanceOrder; |
| return $this; |
| } |
| |
| /** |
| * |
| * |
| * @return int|null |
| */ |
| public function getRebalanceOrder(): ?int |
| { |
| return $this->getProperty(self::PROP_REBALANCE_ORDER); |
| } |
| |
| /** |
| * |
| * |
| * @param float $rebalanceThrottle |
| * |
| * @return CacheConfiguration the same instance of the CacheConfiguration. |
| */ |
| public function setRebalanceThrottle(float $rebalanceThrottle): CacheConfiguration |
| { |
| $this->properties[self::PROP_REBALANCE_THROTTLE] = $rebalanceThrottle; |
| return $this; |
| } |
| |
| /** |
| * |
| * |
| * @return float|null |
| */ |
| public function getRebalanceThrottle(): ?float |
| { |
| return $this->getProperty(self::PROP_REBALANCE_THROTTLE); |
| } |
| |
| /** |
| * |
| * |
| * @param float $rebalanceTimeout |
| * |
| * @return CacheConfiguration the same instance of the CacheConfiguration. |
| */ |
| public function setRebalanceTimeout(float $rebalanceTimeout): CacheConfiguration |
| { |
| $this->properties[self::PROP_REBALANCE_TIMEOUT] = $rebalanceTimeout; |
| return $this; |
| } |
| |
| /** |
| * |
| * |
| * @return float|null |
| */ |
| public function getRebalanceTimeout(): ?float |
| { |
| return $this->getProperty(self::PROP_REBALANCE_TIMEOUT); |
| } |
| |
| /** |
| * |
| * |
| * @param bool $sqlEscapeAll |
| * |
| * @return CacheConfiguration the same instance of the CacheConfiguration. |
| */ |
| public function setSqlEscapeAll(bool $sqlEscapeAll): CacheConfiguration |
| { |
| $this->properties[self::PROP_SQL_ESCAPE_ALL] = $sqlEscapeAll; |
| return $this; |
| } |
| |
| /** |
| * |
| * |
| * @return bool|null |
| */ |
| public function getSqlEscapeAll(): ?bool |
| { |
| return $this->getProperty(self::PROP_SQL_ESCAPE_ALL); |
| } |
| |
| /** |
| * |
| * |
| * @param int $sqlIndexInlineMaxSize |
| * |
| * @return CacheConfiguration the same instance of the CacheConfiguration. |
| */ |
| public function setSqlIndexInlineMaxSize(int $sqlIndexInlineMaxSize): CacheConfiguration |
| { |
| $this->properties[self::PROP_SQL_INDEX_INLINE_MAX_SIZE] = $sqlIndexInlineMaxSize; |
| return $this; |
| } |
| |
| /** |
| * |
| * |
| * @return int|null |
| */ |
| public function getSqlIndexInlineMaxSize(): ?int |
| { |
| return $this->getProperty(self::PROP_SQL_INDEX_INLINE_MAX_SIZE); |
| } |
| |
| /** |
| * |
| * |
| * @param string|null $sqlSchema |
| * |
| * @return CacheConfiguration the same instance of the CacheConfiguration. |
| */ |
| public function setSqlSchema(?string $sqlSchema): CacheConfiguration |
| { |
| $this->properties[self::PROP_SQL_SCHEMA] = $sqlSchema; |
| return $this; |
| } |
| |
| /** |
| * |
| * |
| * @return string|null |
| */ |
| public function getSqlSchema(): ?string |
| { |
| return $this->getProperty(self::PROP_SQL_SCHEMA); |
| } |
| |
| /** |
| * |
| * |
| * @param int $writeSynchronizationMode one of @ref WriteSynchronizationMode constants. |
| * |
| * @return CacheConfiguration the same instance of the CacheConfiguration. |
| * |
| * @throws ClientException if error. |
| */ |
| public function setWriteSynchronizationMode(int $writeSynchronizationMode): CacheConfiguration |
| { |
| ArgumentChecker::hasValueFrom( |
| $writeSynchronizationMode, |
| 'writeSynchronizationMode', |
| false, |
| [self::WRITE_SYNC_MODE_FULL_SYNC, self::WRITE_SYNC_MODE_FULL_ASYNC, self::WRITE_SYNC_MODE_PRIMARY_SYNC]); |
| $this->properties[self::PROP_WRITE_SYNCHRONIZATION_MODE] = $writeSynchronizationMode; |
| return $this; |
| } |
| |
| /** |
| * |
| * |
| * @return int|null |
| */ |
| public function getWriteSynchronizationMode(): ?int |
| { |
| return $this->getProperty(self::PROP_WRITE_SYNCHRONIZATION_MODE); |
| } |
| |
| /** |
| * |
| * |
| * @param CacheKeyConfiguration ...$keyConfigurations |
| * |
| * @return CacheConfiguration the same instance of the CacheConfiguration. |
| */ |
| public function setKeyConfigurations(CacheKeyConfiguration ...$keyConfigurations): CacheConfiguration |
| { |
| $this->properties[self::PROP_CACHE_KEY_CONFIGURATION] = $keyConfigurations; |
| return $this; |
| } |
| |
| /** |
| * |
| * |
| * @return CacheKeyConfiguration[]|null |
| */ |
| public function getKeyConfigurations(): ?array |
| { |
| return $this->getProperty(self::PROP_CACHE_KEY_CONFIGURATION); |
| } |
| |
| /** |
| * |
| * |
| * @param QueryEntity ...$queryEntities |
| * |
| * @return CacheConfiguration the same instance of the CacheConfiguration. |
| */ |
| public function setQueryEntities(QueryEntity ...$queryEntities): CacheConfiguration |
| { |
| $this->properties[self::PROP_QUERY_ENTITY] = $queryEntities; |
| return $this; |
| } |
| |
| /** |
| * |
| * |
| * @return QueryEntity[]|null |
| */ |
| public function getQueryEntities(): ?array |
| { |
| return $this->getProperty(self::PROP_QUERY_ENTITY); |
| } |
| |
| private function getProperty(int $prop) |
| { |
| if (array_key_exists($prop, $this->properties)) { |
| return $this->properties[$prop]; |
| } |
| return null; |
| } |
| |
| static function init(): void |
| { |
| self::$propInfo = array( |
| self::PROP_NAME => ObjectType::STRING, |
| self::PROP_CACHE_MODE => ObjectType::INTEGER, |
| self::PROP_ATOMICITY_MODE => ObjectType::INTEGER, |
| self::PROP_BACKUPS => ObjectType::INTEGER, |
| self::PROP_WRITE_SYNCHRONIZATION_MODE => ObjectType::INTEGER, |
| self::PROP_COPY_ON_READ => ObjectType::BOOLEAN, |
| self::PROP_READ_FROM_BACKUP => ObjectType::BOOLEAN, |
| self::PROP_DATA_REGION_NAME => ObjectType::STRING, |
| self::PROP_IS_ONHEAP_CACHE_ENABLED => ObjectType::BOOLEAN, |
| self::PROP_QUERY_ENTITY => new ObjectArrayType((new ComplexObjectType())->setPhpClassName(QueryEntity::class)), |
| self::PROP_QUERY_PARALLELISM => ObjectType::INTEGER, |
| self::PROP_QUERY_DETAIL_METRICS_SIZE => ObjectType::INTEGER, |
| self::PROP_SQL_SCHEMA => ObjectType::STRING, |
| self::PROP_SQL_INDEX_INLINE_MAX_SIZE => ObjectType::INTEGER, |
| self::PROP_SQL_ESCAPE_ALL => ObjectType::BOOLEAN, |
| self::PROP_MAX_QUERY_ITERATORS => ObjectType::INTEGER, |
| self::PROP_REBALANCE_MODE => ObjectType::INTEGER, |
| self::PROP_REBALANCE_DELAY => ObjectType::LONG, |
| self::PROP_REBALANCE_TIMEOUT => ObjectType::LONG, |
| self::PROP_REBALANCE_BATCH_SIZE => ObjectType::INTEGER, |
| self::PROP_REBALANCE_BATCHES_PREFETCH_COUNT => ObjectType::LONG, |
| self::PROP_REBALANCE_ORDER => ObjectType::INTEGER, |
| self::PROP_REBALANCE_THROTTLE => ObjectType::LONG, |
| self::PROP_GROUP_NAME => ObjectType::STRING, |
| self::PROP_CACHE_KEY_CONFIGURATION => new ObjectArrayType((new ComplexObjectType())->setPhpClassName(CacheKeyConfiguration::class)), |
| self::PROP_DEFAULT_LOCK_TIMEOUT => ObjectType::LONG, |
| self::PROP_MAX_CONCURRENT_ASYNC_OPS => ObjectType::INTEGER, |
| self::PROP_PARTITION_LOSS_POLICY => ObjectType::INTEGER, |
| self::PROP_EAGER_TTL => ObjectType::BOOLEAN, |
| self::PROP_STATISTICS_ENABLED => ObjectType::BOOLEAN |
| ); |
| } |
| |
| // This is not the public API method, is not intended for usage by an application. |
| public function write(BinaryCommunicator $communicator, MessageBuffer $buffer, string $name): void |
| { |
| $this->setName($name); |
| |
| $startPos = $buffer->getPosition(); |
| $buffer->setPosition($startPos + |
| BinaryUtils::getSize(ObjectType::INTEGER) + |
| BinaryUtils::getSize(ObjectType::SHORT)); |
| |
| foreach ($this->properties as $propertyCode => $property) { |
| $this->writeProperty($communicator, $buffer, $propertyCode, $property); |
| } |
| |
| $length = $buffer->getPosition() - $startPos; |
| $buffer->setPosition($startPos); |
| |
| $buffer->writeInteger($length); |
| $buffer->writeShort(count($this->properties)); |
| } |
| |
| private function writeProperty(BinaryCommunicator $communicator, MessageBuffer $buffer, int $propertyCode, $property): void |
| { |
| $buffer->writeShort($propertyCode); |
| $propertyType = self::$propInfo[$propertyCode]; |
| switch (BinaryUtils::getTypeCode($propertyType)) { |
| case ObjectType::INTEGER: |
| case ObjectType::LONG: |
| case ObjectType::BOOLEAN: |
| $communicator->writeObject($buffer, $property, $propertyType, false); |
| return; |
| case ObjectType::STRING: |
| $communicator->writeObject($buffer, $property, $propertyType); |
| return; |
| case ObjectType::OBJECT_ARRAY: |
| $length = $property ? count($property) : 0; |
| $buffer->writeInteger($length); |
| foreach ($property as $prop) { |
| $prop->write($communicator, $buffer); |
| } |
| return; |
| default: |
| BinaryUtils::internalError(); |
| } |
| } |
| |
| // This is not the public API method, is not intended for usage by an application. |
| public function read(BinaryCommunicator $communicator, MessageBuffer $buffer): void |
| { |
| //length |
| $buffer->readInteger(); |
| $this->readProperty($communicator, $buffer, self::PROP_ATOMICITY_MODE); |
| $this->readProperty($communicator, $buffer, self::PROP_BACKUPS); |
| $this->readProperty($communicator, $buffer, self::PROP_CACHE_MODE); |
| $this->readProperty($communicator, $buffer, self::PROP_COPY_ON_READ); |
| $this->readProperty($communicator, $buffer, self::PROP_DATA_REGION_NAME); |
| $this->readProperty($communicator, $buffer, self::PROP_EAGER_TTL); |
| $this->readProperty($communicator, $buffer, self::PROP_STATISTICS_ENABLED); |
| $this->readProperty($communicator, $buffer, self::PROP_GROUP_NAME); |
| $this->readProperty($communicator, $buffer, self::PROP_DEFAULT_LOCK_TIMEOUT); |
| $this->readProperty($communicator, $buffer, self::PROP_MAX_CONCURRENT_ASYNC_OPS); |
| $this->readProperty($communicator, $buffer, self::PROP_MAX_QUERY_ITERATORS); |
| $this->readProperty($communicator, $buffer, self::PROP_NAME); |
| $this->readProperty($communicator, $buffer, self::PROP_IS_ONHEAP_CACHE_ENABLED); |
| $this->readProperty($communicator, $buffer, self::PROP_PARTITION_LOSS_POLICY); |
| $this->readProperty($communicator, $buffer, self::PROP_QUERY_DETAIL_METRICS_SIZE); |
| $this->readProperty($communicator, $buffer, self::PROP_QUERY_PARALLELISM); |
| $this->readProperty($communicator, $buffer, self::PROP_READ_FROM_BACKUP); |
| $this->readProperty($communicator, $buffer, self::PROP_REBALANCE_BATCH_SIZE); |
| $this->readProperty($communicator, $buffer, self::PROP_REBALANCE_BATCHES_PREFETCH_COUNT); |
| $this->readProperty($communicator, $buffer, self::PROP_REBALANCE_DELAY); |
| $this->readProperty($communicator, $buffer, self::PROP_REBALANCE_MODE); |
| $this->readProperty($communicator, $buffer, self::PROP_REBALANCE_ORDER); |
| $this->readProperty($communicator, $buffer, self::PROP_REBALANCE_THROTTLE); |
| $this->readProperty($communicator, $buffer, self::PROP_REBALANCE_TIMEOUT); |
| $this->readProperty($communicator, $buffer, self::PROP_SQL_ESCAPE_ALL); |
| $this->readProperty($communicator, $buffer, self::PROP_SQL_INDEX_INLINE_MAX_SIZE); |
| $this->readProperty($communicator, $buffer, self::PROP_SQL_SCHEMA); |
| $this->readProperty($communicator, $buffer, self::PROP_WRITE_SYNCHRONIZATION_MODE); |
| $this->readProperty($communicator, $buffer, self::PROP_CACHE_KEY_CONFIGURATION); |
| $this->readProperty($communicator, $buffer, self::PROP_QUERY_ENTITY); |
| } |
| |
| private function readProperty(BinaryCommunicator $communicator, MessageBuffer $buffer, int $propertyCode): void |
| { |
| $propertyType = self::$propInfo[$propertyCode]; |
| switch (BinaryUtils::getTypeCode($propertyType)) { |
| case ObjectType::INTEGER: |
| case ObjectType::LONG: |
| case ObjectType::BOOLEAN: |
| $this->properties[$propertyCode] = $communicator->readTypedObject($buffer, $propertyType); |
| return; |
| case ObjectType::STRING: |
| $this->properties[$propertyCode] = $communicator->readObject($buffer, $propertyType); |
| return; |
| case ObjectType::OBJECT_ARRAY: |
| $length = $buffer->readInteger(); |
| $properties = []; |
| for ($i = 0; $i < $length; $i++) { |
| $propClassName = $propertyType->getElementType()->getPhpClassName(); |
| $property = new $propClassName(); |
| $property->read($communicator, $buffer); |
| array_push($properties, $property); |
| } |
| $this->properties[$propertyCode] = $properties; |
| return; |
| default: |
| BinaryUtils::internalError(); |
| } |
| } |
| } |
| |
| CacheConfiguration::init(); |
