├── .gitattributes
├── .gitignore
├── LICENSE
├── README.cn.md
├── README.md
├── composer.json
└── src
    ├── Broker.php
    ├── Client
        ├── ClientInterface.php
        ├── SwooleClient.php
        └── SyncClient.php
    ├── Config
        ├── AbstractConfig.php
        ├── CommonConfig.php
        └── SslConfig.php
    ├── Consumer
        ├── Assignor
        │   ├── AbstractPartitionAssignor.php
        │   ├── PartitionAssignorInterface.php
        │   ├── PartitionMovements.php
        │   ├── RangeAssignor.php
        │   ├── RoundRobinAssignor.php
        │   ├── StickyAssignor.php
        │   └── Struct
        │   │   └── TopicAndPartition.php
        ├── ConsumeMessage.php
        ├── Consumer.php
        ├── ConsumerConfig.php
        ├── OffsetManager.php
        └── Struct
        │   ├── ConsumerGenerationPair.php
        │   ├── ConsumerGroupMemberMetadata.php
        │   ├── ConsumerPair.php
        │   ├── StickyAssignorUserData.php
        │   └── TopicPartition.php
    ├── Exception
        ├── CRC32Exception.php
        ├── ConnectionException.php
        ├── KafkaErrorException.php
        ├── NoAliveBrokerException.php
        ├── SocketException.php
        ├── UnknownException.php
        ├── UnsupportedApiKeyException.php
        ├── UnsupportedApiVersionException.php
        └── UnsupportedCompressionException.php
    ├── Generator
        ├── AbstractGenerator.php
        ├── MessageGenerator.php
        ├── StructGenerator.php
        └── SubStructGenerator.php
    ├── Group
        ├── CoordinatorType.php
        ├── GroupManager.php
        ├── ProtocolType.php
        └── Struct
        │   ├── ConsumerGroupMemberAssignment.php
        │   └── ConsumerGroupTopic.php
    ├── Producer
        ├── Partitioner
        │   ├── DefaultPartitioner.php
        │   └── PartitionerInterface.php
        ├── ProduceMessage.php
        ├── Producer.php
        └── ProducerConfig.php
    ├── Protocol
        ├── AbstractApiKeys.php
        ├── AbstractProtocol.php
        ├── AbstractRequest.php
        ├── AbstractRequestHeader.php
        ├── AbstractResponse.php
        ├── AbstractResponseHeader.php
        ├── AbstractStruct.php
        ├── AddOffsetsToTxn
        │   ├── AddOffsetsToTxnRequest.php
        │   └── AddOffsetsToTxnResponse.php
        ├── AddPartitionsToTxn
        │   ├── AddPartitionsToTxnPartitionResult.php
        │   ├── AddPartitionsToTxnRequest.php
        │   ├── AddPartitionsToTxnResponse.php
        │   ├── AddPartitionsToTxnTopic.php
        │   └── AddPartitionsToTxnTopicResult.php
        ├── AlterClientQuotas
        │   ├── AlterClientQuotasRequest.php
        │   ├── AlterClientQuotasResponse.php
        │   ├── EntityData.php
        │   ├── EntryData.php
        │   └── OpData.php
        ├── AlterConfigs
        │   ├── AlterConfigsRequest.php
        │   ├── AlterConfigsResource.php
        │   ├── AlterConfigsResourceResponse.php
        │   ├── AlterConfigsResponse.php
        │   └── AlterableConfig.php
        ├── AlterPartitionReassignments
        │   ├── AlterPartitionReassignmentsRequest.php
        │   ├── AlterPartitionReassignmentsResponse.php
        │   ├── ReassignablePartition.php
        │   ├── ReassignablePartitionResponse.php
        │   ├── ReassignableTopic.php
        │   └── ReassignableTopicResponse.php
        ├── AlterReplicaLogDirs
        │   ├── AlterReplicaLogDir.php
        │   ├── AlterReplicaLogDirPartitionResult.php
        │   ├── AlterReplicaLogDirTopic.php
        │   ├── AlterReplicaLogDirTopicResult.php
        │   ├── AlterReplicaLogDirsRequest.php
        │   └── AlterReplicaLogDirsResponse.php
        ├── ApiKeys.php
        ├── ApiVersion.php
        ├── ApiVersions
        │   ├── ApiVersionsRequest.php
        │   ├── ApiVersionsResponse.php
        │   └── ApiVersionsResponseKey.php
        ├── ControlledShutdown
        │   ├── ControlledShutdownRequest.php
        │   ├── ControlledShutdownResponse.php
        │   └── RemainingPartition.php
        ├── CreateAcls
        │   ├── AclCreation.php
        │   ├── AclCreationResult.php
        │   ├── CreateAclsRequest.php
        │   └── CreateAclsResponse.php
        ├── CreateDelegationToken
        │   ├── CreatableRenewers.php
        │   ├── CreateDelegationTokenRequest.php
        │   └── CreateDelegationTokenResponse.php
        ├── CreatePartitions
        │   ├── CreatePartitionsAssignment.php
        │   ├── CreatePartitionsRequest.php
        │   ├── CreatePartitionsResponse.php
        │   ├── CreatePartitionsTopic.php
        │   └── CreatePartitionsTopicResult.php
        ├── CreateTopics
        │   ├── CreatableReplicaAssignment.php
        │   ├── CreatableTopic.php
        │   ├── CreatableTopicConfigs.php
        │   ├── CreatableTopicResult.php
        │   ├── CreateTopicsRequest.php
        │   ├── CreateTopicsResponse.php
        │   └── CreateableTopicConfig.php
        ├── DeleteAcls
        │   ├── DeleteAclsFilter.php
        │   ├── DeleteAclsFilterResult.php
        │   ├── DeleteAclsMatchingAcl.php
        │   ├── DeleteAclsRequest.php
        │   └── DeleteAclsResponse.php
        ├── DeleteGroups
        │   ├── DeletableGroupResult.php
        │   ├── DeleteGroupsRequest.php
        │   └── DeleteGroupsResponse.php
        ├── DeleteRecords
        │   ├── DeleteRecordsPartition.php
        │   ├── DeleteRecordsPartitionResult.php
        │   ├── DeleteRecordsRequest.php
        │   ├── DeleteRecordsResponse.php
        │   ├── DeleteRecordsTopic.php
        │   └── DeleteRecordsTopicResult.php
        ├── DeleteTopics
        │   ├── DeletableTopicResult.php
        │   ├── DeleteTopicsRequest.php
        │   └── DeleteTopicsResponse.php
        ├── DescribeAcls
        │   ├── AclDescription.php
        │   ├── DescribeAclsRequest.php
        │   ├── DescribeAclsResource.php
        │   └── DescribeAclsResponse.php
        ├── DescribeClientQuotas
        │   ├── ComponentData.php
        │   ├── DescribeClientQuotasRequest.php
        │   ├── DescribeClientQuotasResponse.php
        │   ├── EntityData.php
        │   ├── EntryData.php
        │   └── ValueData.php
        ├── DescribeConfigs
        │   ├── DescribeConfigsRequest.php
        │   ├── DescribeConfigsResource.php
        │   ├── DescribeConfigsResourceResult.php
        │   ├── DescribeConfigsResponse.php
        │   ├── DescribeConfigsResult.php
        │   └── DescribeConfigsSynonym.php
        ├── DescribeDelegationToken
        │   ├── DescribeDelegationTokenOwner.php
        │   ├── DescribeDelegationTokenRequest.php
        │   ├── DescribeDelegationTokenResponse.php
        │   ├── DescribedDelegationToken.php
        │   └── DescribedDelegationTokenRenewer.php
        ├── DescribeGroups
        │   ├── DescribeGroupsRequest.php
        │   ├── DescribeGroupsResponse.php
        │   ├── DescribedGroup.php
        │   └── DescribedGroupMember.php
        ├── DescribeLogDirs
        │   ├── DescribableLogDirTopic.php
        │   ├── DescribeLogDirsPartition.php
        │   ├── DescribeLogDirsRequest.php
        │   ├── DescribeLogDirsResponse.php
        │   ├── DescribeLogDirsResult.php
        │   └── DescribeLogDirsTopic.php
        ├── ElectLeaders
        │   ├── ElectLeadersRequest.php
        │   ├── ElectLeadersResponse.php
        │   ├── PartitionResult.php
        │   ├── ReplicaElectionResult.php
        │   └── TopicPartitions.php
        ├── EndTxn
        │   ├── EndTxnRequest.php
        │   └── EndTxnResponse.php
        ├── ErrorCode.php
        ├── ExpireDelegationToken
        │   ├── ExpireDelegationTokenRequest.php
        │   └── ExpireDelegationTokenResponse.php
        ├── Fetch
        │   ├── AbortedTransaction.php
        │   ├── FetchPartition.php
        │   ├── FetchRequest.php
        │   ├── FetchResponse.php
        │   ├── FetchablePartitionResponse.php
        │   ├── FetchableTopic.php
        │   ├── FetchableTopicResponse.php
        │   └── ForgottenTopic.php
        ├── FindCoordinator
        │   ├── FindCoordinatorRequest.php
        │   └── FindCoordinatorResponse.php
        ├── Heartbeat
        │   ├── HeartbeatRequest.php
        │   └── HeartbeatResponse.php
        ├── IncrementalAlterConfigs
        │   ├── AlterConfigsResource.php
        │   ├── AlterConfigsResourceResponse.php
        │   ├── AlterableConfig.php
        │   ├── IncrementalAlterConfigsRequest.php
        │   └── IncrementalAlterConfigsResponse.php
        ├── InitProducerId
        │   ├── InitProducerIdRequest.php
        │   └── InitProducerIdResponse.php
        ├── JoinGroup
        │   ├── JoinGroupRequest.php
        │   ├── JoinGroupRequestProtocol.php
        │   ├── JoinGroupResponse.php
        │   └── JoinGroupResponseMember.php
        ├── KafkaRequest.php
        ├── LeaderAndIsr
        │   ├── LeaderAndIsrLiveLeader.php
        │   ├── LeaderAndIsrPartitionError.php
        │   ├── LeaderAndIsrPartitionState.php
        │   ├── LeaderAndIsrRequest.php
        │   ├── LeaderAndIsrResponse.php
        │   └── LeaderAndIsrTopicState.php
        ├── LeaveGroup
        │   ├── LeaveGroupRequest.php
        │   ├── LeaveGroupResponse.php
        │   ├── MemberIdentity.php
        │   └── MemberResponse.php
        ├── ListGroups
        │   ├── ListGroupsRequest.php
        │   ├── ListGroupsResponse.php
        │   └── ListedGroup.php
        ├── ListOffset
        │   ├── ListOffsetPartition.php
        │   ├── ListOffsetPartitionResponse.php
        │   ├── ListOffsetRequest.php
        │   ├── ListOffsetResponse.php
        │   ├── ListOffsetTopic.php
        │   └── ListOffsetTopicResponse.php
        ├── ListPartitionReassignments
        │   ├── ListPartitionReassignmentsRequest.php
        │   ├── ListPartitionReassignmentsResponse.php
        │   ├── ListPartitionReassignmentsTopics.php
        │   ├── OngoingPartitionReassignment.php
        │   └── OngoingTopicReassignment.php
        ├── Metadata
        │   ├── MetadataRequest.php
        │   ├── MetadataRequestTopic.php
        │   ├── MetadataResponse.php
        │   ├── MetadataResponseBroker.php
        │   ├── MetadataResponsePartition.php
        │   └── MetadataResponseTopic.php
        ├── OffsetCommit
        │   ├── OffsetCommitRequest.php
        │   ├── OffsetCommitRequestPartition.php
        │   ├── OffsetCommitRequestTopic.php
        │   ├── OffsetCommitResponse.php
        │   ├── OffsetCommitResponsePartition.php
        │   └── OffsetCommitResponseTopic.php
        ├── OffsetDelete
        │   ├── OffsetDeleteRequest.php
        │   ├── OffsetDeleteRequestPartition.php
        │   ├── OffsetDeleteRequestTopic.php
        │   ├── OffsetDeleteResponse.php
        │   ├── OffsetDeleteResponsePartition.php
        │   └── OffsetDeleteResponseTopic.php
        ├── OffsetFetch
        │   ├── OffsetFetchRequest.php
        │   ├── OffsetFetchRequestTopic.php
        │   ├── OffsetFetchResponse.php
        │   ├── OffsetFetchResponsePartition.php
        │   └── OffsetFetchResponseTopic.php
        ├── OffsetForLeaderEpoch
        │   ├── OffsetForLeaderEpochRequest.php
        │   ├── OffsetForLeaderEpochResponse.php
        │   ├── OffsetForLeaderPartition.php
        │   ├── OffsetForLeaderPartitionResult.php
        │   ├── OffsetForLeaderTopic.php
        │   └── OffsetForLeaderTopicResult.php
        ├── Produce
        │   ├── BatchIndexAndErrorMessage.php
        │   ├── PartitionProduceData.php
        │   ├── PartitionProduceResponse.php
        │   ├── ProduceRequest.php
        │   ├── ProduceResponse.php
        │   ├── TopicProduceData.php
        │   └── TopicProduceResponse.php
        ├── ProtocolField.php
        ├── ProtocolUtil.php
        ├── RecordBatch
        │   ├── Attributes.php
        │   ├── Enum
        │   │   ├── Compression.php
        │   │   └── TimestampType.php
        │   ├── Record.php
        │   ├── RecordBatch.php
        │   └── RecordHeader.php
        ├── RenewDelegationToken
        │   ├── RenewDelegationTokenRequest.php
        │   └── RenewDelegationTokenResponse.php
        ├── RequestHeader
        │   └── RequestHeader.php
        ├── ResponseHeader
        │   └── ResponseHeader.php
        ├── SaslAuthenticate
        │   ├── SaslAuthenticateRequest.php
        │   └── SaslAuthenticateResponse.php
        ├── SaslHandshake
        │   ├── SaslHandshakeRequest.php
        │   └── SaslHandshakeResponse.php
        ├── StopReplica
        │   ├── StopReplicaPartitionError.php
        │   ├── StopReplicaPartitionState.php
        │   ├── StopReplicaPartitionV0.php
        │   ├── StopReplicaRequest.php
        │   ├── StopReplicaResponse.php
        │   ├── StopReplicaTopicState.php
        │   └── StopReplicaTopicV1.php
        ├── SyncGroup
        │   ├── SyncGroupRequest.php
        │   ├── SyncGroupRequestAssignment.php
        │   └── SyncGroupResponse.php
        ├── TxnOffsetCommit
        │   ├── TxnOffsetCommitRequest.php
        │   ├── TxnOffsetCommitRequestPartition.php
        │   ├── TxnOffsetCommitRequestTopic.php
        │   ├── TxnOffsetCommitResponse.php
        │   ├── TxnOffsetCommitResponsePartition.php
        │   └── TxnOffsetCommitResponseTopic.php
        ├── Type
        │   ├── AbstractType.php
        │   ├── ArrayInt32.php
        │   ├── Boolean.php
        │   ├── CompactArray.php
        │   ├── CompactNullableString.php
        │   ├── CompactString.php
        │   ├── Float64.php
        │   ├── Int16.php
        │   ├── Int32.php
        │   ├── Int64.php
        │   ├── Int8.php
        │   ├── NullableString.php
        │   ├── NullableString32.php
        │   ├── String16.php
        │   ├── String32.php
        │   ├── TypeRelation.php
        │   ├── UInt32.php
        │   ├── UVarInt.php
        │   ├── VarInt.php
        │   └── VarIntCompactArray.php
        ├── UpdateMetadata
        │   ├── UpdateMetadataBroker.php
        │   ├── UpdateMetadataEndpoint.php
        │   ├── UpdateMetadataPartitionState.php
        │   ├── UpdateMetadataRequest.php
        │   ├── UpdateMetadataResponse.php
        │   └── UpdateMetadataTopicState.php
        └── WriteTxnMarkers
        │   ├── WritableTxnMarker.php
        │   ├── WritableTxnMarkerPartitionResult.php
        │   ├── WritableTxnMarkerResult.php
        │   ├── WritableTxnMarkerTopic.php
        │   ├── WritableTxnMarkerTopicResult.php
        │   ├── WriteTxnMarkersRequest.php
        │   └── WriteTxnMarkersResponse.php
    ├── Sasl
        ├── PlainSasl.php
        └── SaslInterface.php
    ├── Socket
        ├── SocketInterface.php
        ├── StreamSocket.php
        └── SwooleSocket.php
    ├── Timer
        ├── NoopTimer.php
        ├── SwooleTimer.php
        └── TimerInterface.php
    └── Util
        ├── ArrayUtil.php
        ├── KafkaUtil.php
        ├── LZ4.php
        └── ObjectKeyArray.php


/.gitattributes:
--------------------------------------------------------------------------------
 1 | # Exclude non-essential files from dist
 2 | /.github export-ignore
 3 | /bin export-ignore
 4 | /doc export-ignore
 5 | /examples export-ignore
 6 | /res export-ignore
 7 | /tests export-ignore
 8 | .php_cs.dist export-ignore
 9 | phpstan.neon export-ignore
10 | phpunit.xml.dist export-ignore
11 | swoole-phpunit export-ignore


--------------------------------------------------------------------------------
/.gitignore:
--------------------------------------------------------------------------------
 1 | vendor/
 2 | .vscode/
 3 | .idea/
 4 | .buildpath
 5 | .settings/
 6 | .project
 7 | .DS_Store
 8 | *.lock
 9 | *.log
10 | /coverage.txt
11 | /.php_cs.cache
12 | *.cache
13 | .bashrc


--------------------------------------------------------------------------------
/README.cn.md:
--------------------------------------------------------------------------------
 1 | # longlang/phpkafka
 2 | 
 3 | [![Latest Version](https://poser.pugx.org/longlang/phpkafka/v/stable)](https://packagist.org/packages/longlang/phpkafka)
 4 | [![Php Version](https://img.shields.io/badge/php-%3E=7.1-brightgreen.svg)](https://secure.php.net/)
 5 | [![License](https://img.shields.io/github/license/longyan/phpkafka.svg)](https://github.com/longyan/phpkafka/blob/master/LICENSE)
 6 | 
 7 | ## 简介
 8 | 
 9 | [English](README.md) | 简体中文
10 | 
11 | PHP Kafka 客户端，支持 PHP-FPM、Swoole 环境使用。
12 | 
13 | 通讯协议的结构基于 Java 版本中的 JSON 文件生成，这可能是有史以来支持消息类型最多的 PHP Kafka 客户端，支持全部 50 个 API。
14 | 
15 | > 目前已实现消息的生成及消费，本组件仍处于开发及测试阶段。
16 | 
17 | ## 功能特性
18 | 
19 | - [x] 支持全部 50 个 API
20 | - [x] 消息压缩支持 (gzip、snappy、lz4、zstd)
21 | - [x] PHP-FPM、Swoole 智能环境识别兼容
22 | - [x] 生产者类
23 | - [x] 消费者类
24 | - [x] SASL 鉴权
25 | - [x] SSL 加密通信
26 | - [ ] 更多功能的封装及测试用例编写
27 | 
28 | ## 环境要求
29 | 
30 | - PHP >= 7.1
31 | - Kafka >= 1.0.0
32 | - Swoole >= 4.5 (可选)
33 | 
34 | ## 安装
35 | 
36 | `composer require longlang/phpkafka`
37 | 
38 | ## 文档及示例
39 | 
40 | - [生产者](doc/producer.md)
41 | 
42 | - [消费者](doc/consumer.md)
43 | 
44 | 示例代码请参考 `examples` 目录
45 | 


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
 1 | # longlang/phpkafka
 2 | 
 3 | [![Latest Version](https://poser.pugx.org/longlang/phpkafka/v/stable)](https://packagist.org/packages/longlang/phpkafka)
 4 | [![Php Version](https://img.shields.io/badge/php-%3E=7.1-brightgreen.svg)](https://secure.php.net/)
 5 | [![License](https://img.shields.io/github/license/longyan/phpkafka.svg)](https://github.com/longyan/phpkafka/blob/master/LICENSE)
 6 | 
 7 | ## Introduction
 8 | 
 9 | English | [简体中文](README.cn.md)
10 | 
11 | PHP Kafka client is used in PHP-FPM and Swoole.
12 | 
13 | The communication protocol is based on the JSON file in Java. PHP Kafka client supports 50 APIs, which might be one that supports the most message types ever.
14 | 
15 | > The produce and the consume of messages are implemented. The component is in developing and testing.
16 | 
17 | ## Features
18 | 
19 | - [x] Support all 50 APIs
20 | - [x] Message compression 
21 | - [x] PHP-FPM and Swoole compatible
22 | - [x] Producer
23 | - [x] Consumer
24 | - [x] SASL
25 | - [x] SSL
26 | - [ ] More features and test cases
27 | 
28 | ## Environment
29 | 
30 | - PHP >= 7.1
31 | - Kafka >= 1.0.0
32 | - Swoole >= 4.5 (optional)
33 | 
34 | ## Installation
35 | 
36 | `composer require longlang/phpkafka`
37 | 
38 | ## Documentation and Examples
39 | 
40 | - [Producer](doc/producer.en.md)
41 | 
42 | - [Consumer](doc/consumer.en.md)
43 | 
44 | Refer to `examples` for code examples. 
45 | 


--------------------------------------------------------------------------------
/composer.json:
--------------------------------------------------------------------------------
 1 | {
 2 |     "name": "longlang/phpkafka",
 3 |     "description": "A kafka client. Support php-fpm and Swoole.",
 4 |     "license": "Apache-2.0",
 5 |     "require": {
 6 |         "php": ">=7.1",
 7 |         "google/crc32": "^0.1.0",
 8 |         "exussum12/xxhash": "^1.0.0",
 9 |         "chdemko/sorted-collections": "^1.0",
10 |         "symfony/polyfill-php81": "^1.23"
11 |     },
12 |     "require-dev": {
13 |         "phpunit/phpunit": "^7.5|^8.0|^9.0",
14 |         "colinodell/json5": "^2.1",
15 |         "swoole/ide-helper": "^4.5",
16 |         "friendsofphp/php-cs-fixer": "^2.18",
17 |         "phpstan/phpstan": "^0.12.81"
18 |     },
19 |     "autoload": {
20 |         "psr-4": {
21 |             "longlang\\phpkafka\\": "src"
22 |         }
23 |     },
24 |     "autoload-dev": {
25 |         "psr-4": {
26 |             "longlang\\phpkafka\\Test\\": "tests"
27 |         }
28 |     },
29 |     "scripts": {
30 |         "test": "./vendor/bin/phpunit",
31 |         "swoole-test": "export KAFKA_CLIENT_CLASS=\"\\longlang\\phpkafka\\Client\\SwooleClient\" && ./swoole-phpunit",
32 |         "test-coverage": "php -dzend_extension=xdebug ./vendor/bin/phpunit"
33 |     }
34 | }
35 | 


--------------------------------------------------------------------------------
/src/Client/ClientInterface.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace longlang\phpkafka\Client;
 6 | 
 7 | use longlang\phpkafka\Config\CommonConfig;
 8 | use longlang\phpkafka\Protocol\AbstractRequest;
 9 | use longlang\phpkafka\Protocol\AbstractResponse;
10 | use longlang\phpkafka\Protocol\ApiVersions\ApiVersionsResponseKey;
11 | use longlang\phpkafka\Protocol\RequestHeader\RequestHeader;
12 | use longlang\phpkafka\Protocol\ResponseHeader\ResponseHeader;
13 | use longlang\phpkafka\Socket\SocketInterface;
14 | use longlang\phpkafka\Socket\StreamSocket;
15 | 
16 | interface ClientInterface
17 | {
18 |     public function __construct(string $host, int $port, ?CommonConfig $config = null, string $socketClass = StreamSocket::class);
19 | 
20 |     public function getHost(): string;
21 | 
22 |     public function getPort(): int;
23 | 
24 |     public function getConfig(): CommonConfig;
25 | 
26 |     public function getSocket(): SocketInterface;
27 | 
28 |     /**
29 |      * @param ApiVersionsResponseKey[] $apiKeys
30 |      */
31 |     public function setApiKeys(array $apiKeys): self;
32 | 
33 |     /**
34 |      * @return ApiVersionsResponseKey[]|null
35 |      */
36 |     public function getApiKeys(): ?array;
37 | 
38 |     public function connect(): void;
39 | 
40 |     public function close(): bool;
41 | 
42 |     public function getRequestApiVersion(AbstractRequest $request): int;
43 | 
44 |     /**
45 |      * Send message to kafka server.
46 |      *
47 |      * If successful, return the correlationId
48 |      */
49 |     public function send(AbstractRequest $request, ?RequestHeader $header = null, bool $hasResponse = true): int;
50 | 
51 |     public function recv(?int $correlationId, ?ResponseHeader &$header = null): AbstractResponse;
52 | 
53 |     public function sendRecv(AbstractRequest $request, ?RequestHeader $requestHeader = null, ?ResponseHeader &$responseHeader = null): AbstractResponse;
54 | }
55 | 


--------------------------------------------------------------------------------
/src/Config/AbstractConfig.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace longlang\phpkafka\Config;
 6 | 
 7 | class AbstractConfig
 8 | {
 9 |     public function __construct(array $data = [])
10 |     {
11 |         foreach ($data as $k => $v) {
12 |             $methodName = 'set' . ucfirst($k);
13 |             if (method_exists($this, $methodName)) {
14 |                 $this->$methodName($v);
15 |             } else {
16 |                 $this->$k = $v;
17 |             }
18 |         }
19 |     }
20 | }
21 | 


--------------------------------------------------------------------------------
/src/Consumer/Assignor/AbstractPartitionAssignor.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace longlang\phpkafka\Consumer\Assignor;
 6 | 
 7 | use longlang\phpkafka\Protocol\Metadata\MetadataResponseTopic;
 8 | 
 9 | abstract class AbstractPartitionAssignor implements PartitionAssignorInterface
10 | {
11 |     /**
12 |      * @param string[] $topics
13 |      */
14 |     public function subscriptionUserData(array $topics): string
15 |     {
16 |         return '';
17 |     }
18 | 
19 |     /**
20 |      * @param MetadataResponseTopic[] $topicMetadatas
21 |      */
22 |     protected function getTopicPartitions(string $topic, array $topicMetadatas): array
23 |     {
24 |         foreach ($topicMetadatas as $metadata) {
25 |             if ($metadata->getName() === $topic) {
26 |                 $partitions = [];
27 |                 foreach ($metadata->getPartitions() as $partition) {
28 |                     $partitions[] = $partition->getPartitionIndex();
29 |                 }
30 | 
31 |                 return $partitions;
32 |             }
33 |         }
34 | 
35 |         return [];
36 |     }
37 | }
38 | 


--------------------------------------------------------------------------------
/src/Consumer/Assignor/PartitionAssignorInterface.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace longlang\phpkafka\Consumer\Assignor;
 6 | 
 7 | use longlang\phpkafka\Protocol\JoinGroup\JoinGroupResponseMember;
 8 | use longlang\phpkafka\Protocol\Metadata\MetadataResponseTopic;
 9 | use longlang\phpkafka\Protocol\SyncGroup\SyncGroupRequestAssignment;
10 | 
11 | interface PartitionAssignorInterface
12 | {
13 |     /**
14 |      * @param string[] $topics
15 |      */
16 |     public function subscriptionUserData(array $topics): string;
17 | 
18 |     /**
19 |      * @param MetadataResponseTopic[]   $topicMetadatas
20 |      * @param JoinGroupResponseMember[] $groupMembers
21 |      *
22 |      * @return SyncGroupRequestAssignment[]
23 |      */
24 |     public function assign(array $topicMetadatas, array $groupMembers): array;
25 | }
26 | 


--------------------------------------------------------------------------------
/src/Consumer/Assignor/Struct/TopicAndPartition.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace longlang\phpkafka\Consumer\Assignor\Struct;
 6 | 
 7 | class TopicAndPartition
 8 | {
 9 |     /**
10 |      * @var string
11 |      */
12 |     protected $topic;
13 | 
14 |     /**
15 |      * @var int
16 |      */
17 |     protected $partition;
18 | 
19 |     public function __construct(string $topic, int $partition)
20 |     {
21 |         $this->topic = $topic;
22 |         $this->partition = $partition;
23 |     }
24 | 
25 |     public function getTopic(): string
26 |     {
27 |         return $this->topic;
28 |     }
29 | 
30 |     public function setTopic(string $topic): self
31 |     {
32 |         $this->topic = $topic;
33 | 
34 |         return $this;
35 |     }
36 | 
37 |     public function getPartition(): int
38 |     {
39 |         return $this->partition;
40 |     }
41 | 
42 |     public function setPartition(int $partition): self
43 |     {
44 |         $this->partition = $partition;
45 | 
46 |         return $this;
47 |     }
48 | }
49 | 


--------------------------------------------------------------------------------
/src/Consumer/Struct/ConsumerGenerationPair.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace longlang\phpkafka\Consumer\Struct;
 6 | 
 7 | class ConsumerGenerationPair
 8 | {
 9 |     /**
10 |      * @var string
11 |      */
12 |     private $consumer;
13 | 
14 |     /**
15 |      * @var int
16 |      */
17 |     private $generation;
18 | 
19 |     public function __construct(string $consumer, int $generation)
20 |     {
21 |         $this->consumer = $consumer;
22 |         $this->generation = $generation;
23 |     }
24 | 
25 |     public function getConsumer(): string
26 |     {
27 |         return $this->consumer;
28 |     }
29 | 
30 |     public function getGeneration(): int
31 |     {
32 |         return $this->generation;
33 |     }
34 | }
35 | 


--------------------------------------------------------------------------------
/src/Consumer/Struct/ConsumerPair.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace longlang\phpkafka\Consumer\Struct;
 6 | 
 7 | class ConsumerPair
 8 | {
 9 |     /**
10 |      * @var string
11 |      */
12 |     private $srcMemberId;
13 | 
14 |     /**
15 |      * @var string
16 |      */
17 |     private $dstMemberId;
18 | 
19 |     public function __construct(string $srcMemberId, string $dstMemberId)
20 |     {
21 |         $this->srcMemberId = $srcMemberId;
22 |         $this->dstMemberId = $dstMemberId;
23 |     }
24 | 
25 |     public function __toString()
26 |     {
27 |         return $this->srcMemberId . '->' . $this->dstMemberId;
28 |     }
29 | 
30 |     public function getSrcMemberId(): string
31 |     {
32 |         return $this->srcMemberId;
33 |     }
34 | 
35 |     public function getDstMemberId(): string
36 |     {
37 |         return $this->dstMemberId;
38 |     }
39 | 
40 |     public function in(array $pairs): bool
41 |     {
42 |         $thisString = (string) $this;
43 |         foreach ($pairs as $pair) {
44 |             if ((string) $pair === $thisString) {
45 |                 return true;
46 |             }
47 |         }
48 | 
49 |         return false;
50 |     }
51 | }
52 | 


--------------------------------------------------------------------------------
/src/Consumer/Struct/StickyAssignorUserData.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace longlang\phpkafka\Consumer\Struct;
 6 | 
 7 | use longlang\phpkafka\Protocol\AbstractStruct;
 8 | use longlang\phpkafka\Protocol\ProtocolField;
 9 | 
10 | class StickyAssignorUserData extends AbstractStruct
11 | {
12 |     /**
13 |      * @var TopicPartition[]
14 |      */
15 |     protected $partitions = [];
16 | 
17 |     /**
18 |      * @var int|null
19 |      */
20 |     protected $generation;
21 | 
22 |     public function __construct()
23 |     {
24 |         if (!isset(self::$maps[self::class])) {
25 |             self::$maps[self::class] = [
26 |                 new ProtocolField('partitions', TopicPartition::class, true, [0], [], [], [], null),
27 |                 new ProtocolField('generation', 'int32', false, [0, 1], [], [], [], null),
28 |             ];
29 |             self::$taggedFieldses[self::class] = [
30 |             ];
31 |         }
32 |     }
33 | 
34 |     public function getMaxSupportedVersion(): int
35 |     {
36 |         return 0;
37 |     }
38 | 
39 |     public function getFlexibleVersions(): array
40 |     {
41 |         return [];
42 |     }
43 | 
44 |     /**
45 |      * @return TopicPartition[]
46 |      */
47 |     public function getPartitions(): array
48 |     {
49 |         return $this->partitions;
50 |     }
51 | 
52 |     /**
53 |      * @param TopicPartition[] $partitions
54 |      */
55 |     public function setPartitions(array $partitions): self
56 |     {
57 |         $this->partitions = $partitions;
58 | 
59 |         return $this;
60 |     }
61 | 
62 |     public function getGeneration(): ?int
63 |     {
64 |         return $this->generation;
65 |     }
66 | 
67 |     public function setGeneration(?int $generation): self
68 |     {
69 |         $this->generation = $generation;
70 | 
71 |         return $this;
72 |     }
73 | }
74 | 


--------------------------------------------------------------------------------
/src/Consumer/Struct/TopicPartition.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace longlang\phpkafka\Consumer\Struct;
 6 | 
 7 | use longlang\phpkafka\Protocol\AbstractStruct;
 8 | use longlang\phpkafka\Protocol\ProtocolField;
 9 | 
10 | class TopicPartition extends AbstractStruct
11 | {
12 |     /**
13 |      * @var string
14 |      */
15 |     protected $topic;
16 | 
17 |     /**
18 |      * @var int
19 |      */
20 |     protected $partition;
21 | 
22 |     public function __construct(?string $topic = null, ?int $partition = null)
23 |     {
24 |         if (!isset(self::$maps[self::class])) {
25 |             self::$maps[self::class] = [
26 |                 new ProtocolField('topic', 'string', false, [1], [], [], [], null),
27 |                 new ProtocolField('partition', 'int32', false, [1], [], [], [], null),
28 |             ];
29 |             self::$taggedFieldses[self::class] = [
30 |             ];
31 |         }
32 |         $this->topic = $topic;
33 |         $this->partition = $partition;
34 |     }
35 | 
36 |     public function getMaxSupportedVersion(): int
37 |     {
38 |         return 1;
39 |     }
40 | 
41 |     public function getFlexibleVersions(): array
42 |     {
43 |         return [];
44 |     }
45 | 
46 |     public function getTopic(): string
47 |     {
48 |         return $this->topic;
49 |     }
50 | 
51 |     public function setTopic(string $topic): self
52 |     {
53 |         $this->topic = $topic;
54 | 
55 |         return $this;
56 |     }
57 | 
58 |     public function getPartition(): int
59 |     {
60 |         return $this->partition;
61 |     }
62 | 
63 |     public function setPartition(int $partition): self
64 |     {
65 |         $this->partition = $partition;
66 | 
67 |         return $this;
68 |     }
69 | 
70 |     public function __toString()
71 |     {
72 |         return $this->topic . '-' . $this->partition;
73 |     }
74 | }
75 | 


--------------------------------------------------------------------------------
/src/Exception/CRC32Exception.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace longlang\phpkafka\Exception;
 6 | 
 7 | class CRC32Exception extends \Exception
 8 | {
 9 | }
10 | 


--------------------------------------------------------------------------------
/src/Exception/ConnectionException.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace longlang\phpkafka\Exception;
 6 | 
 7 | class ConnectionException extends \Exception
 8 | {
 9 | }
10 | 


--------------------------------------------------------------------------------
/src/Exception/KafkaErrorException.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace longlang\phpkafka\Exception;
 6 | 
 7 | class KafkaErrorException extends \Exception
 8 | {
 9 | }
10 | 


--------------------------------------------------------------------------------
/src/Exception/NoAliveBrokerException.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace longlang\phpkafka\Exception;
 6 | 
 7 | class NoAliveBrokerException extends \Exception
 8 | {
 9 | }
10 | 


--------------------------------------------------------------------------------
/src/Exception/SocketException.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace longlang\phpkafka\Exception;
 6 | 
 7 | class SocketException extends \Exception
 8 | {
 9 | }
10 | 


--------------------------------------------------------------------------------
/src/Exception/UnknownException.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace longlang\phpkafka\Exception;
 6 | 
 7 | class UnknownException extends \Exception
 8 | {
 9 | }
10 | 


--------------------------------------------------------------------------------
/src/Exception/UnsupportedApiKeyException.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace longlang\phpkafka\Exception;
 6 | 
 7 | class UnsupportedApiKeyException extends \Exception
 8 | {
 9 | }
10 | 


--------------------------------------------------------------------------------
/src/Exception/UnsupportedApiVersionException.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace longlang\phpkafka\Exception;
 6 | 
 7 | class UnsupportedApiVersionException extends \Exception
 8 | {
 9 | }
10 | 


--------------------------------------------------------------------------------
/src/Exception/UnsupportedCompressionException.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace longlang\phpkafka\Exception;
 6 | 
 7 | class UnsupportedCompressionException extends \Exception
 8 | {
 9 | }
10 | 


--------------------------------------------------------------------------------
/src/Group/CoordinatorType.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace longlang\phpkafka\Group;
 6 | 
 7 | class CoordinatorType
 8 | {
 9 |     public const GROUP = 0;
10 | 
11 |     public const TRANSACTION = 1;
12 | 
13 |     private function __construct()
14 |     {
15 |     }
16 | }
17 | 


--------------------------------------------------------------------------------
/src/Group/ProtocolType.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace longlang\phpkafka\Group;
 6 | 
 7 | class ProtocolType
 8 | {
 9 |     public const CONSUMER = 'consumer';
10 | 
11 |     public const CONNECT = 'connect';
12 | 
13 |     private function __construct()
14 |     {
15 |     }
16 | }
17 | 


--------------------------------------------------------------------------------
/src/Group/Struct/ConsumerGroupTopic.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace longlang\phpkafka\Group\Struct;
 6 | 
 7 | use longlang\phpkafka\Protocol\AbstractStruct;
 8 | use longlang\phpkafka\Protocol\ProtocolField;
 9 | 
10 | class ConsumerGroupTopic extends AbstractStruct
11 | {
12 |     /**
13 |      * @var string
14 |      */
15 |     protected $topicName;
16 | 
17 |     /**
18 |      * @var array
19 |      */
20 |     protected $partitions = [];
21 | 
22 |     public function __construct()
23 |     {
24 |         if (!isset(self::$maps[self::class])) {
25 |             self::$maps[self::class] = [
26 |                 new ProtocolField('topicName', 'string', false, [0], [], [], [], null),
27 |                 new ProtocolField('partitions', 'int32', true, [0], [], [], [], null),
28 |             ];
29 |             self::$taggedFieldses[self::class] = [
30 |             ];
31 |         }
32 |     }
33 | 
34 |     public function getMaxSupportedVersion(): int
35 |     {
36 |         return 0;
37 |     }
38 | 
39 |     public function getFlexibleVersions(): array
40 |     {
41 |         return [];
42 |     }
43 | 
44 |     public function getTopicName(): string
45 |     {
46 |         return $this->topicName;
47 |     }
48 | 
49 |     public function setTopicName(string $topicName): self
50 |     {
51 |         $this->topicName = $topicName;
52 | 
53 |         return $this;
54 |     }
55 | 
56 |     public function getPartitions(): array
57 |     {
58 |         return $this->partitions;
59 |     }
60 | 
61 |     public function setPartitions(array $partitions): self
62 |     {
63 |         $this->partitions = $partitions;
64 | 
65 |         return $this;
66 |     }
67 | }
68 | 


--------------------------------------------------------------------------------
/src/Producer/Partitioner/PartitionerInterface.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace longlang\phpkafka\Producer\Partitioner;
 6 | 
 7 | use longlang\phpkafka\Protocol\Metadata\MetadataResponseTopic;
 8 | 
 9 | interface PartitionerInterface
10 | {
11 |     /**
12 |      * @param MetadataResponseTopic[] $topicsMeta
13 |      */
14 |     public function partition(string $topic, ?string $value, ?string $key, array $topicsMeta): int;
15 | }
16 | 


--------------------------------------------------------------------------------
/src/Producer/ProduceMessage.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace longlang\phpkafka\Producer;
 6 | 
 7 | use longlang\phpkafka\Protocol\RecordBatch\RecordHeader;
 8 | 
 9 | class ProduceMessage
10 | {
11 |     /**
12 |      * @var string
13 |      */
14 |     protected $topic;
15 | 
16 |     /**
17 |      * @var string|null
18 |      */
19 |     protected $value;
20 | 
21 |     /**
22 |      * @var string|null
23 |      */
24 |     protected $key;
25 | 
26 |     /**
27 |      * @var RecordHeader[]|array
28 |      */
29 |     protected $headers;
30 | 
31 |     /**
32 |      * @var int|null
33 |      */
34 |     protected $partitionIndex;
35 | 
36 |     /**
37 |      * @param RecordHeader[]|array $headers
38 |      */
39 |     public function __construct(string $topic, ?string $value, ?string $key = null, array $headers = [], ?int $partitionIndex = null)
40 |     {
41 |         $this->topic = $topic;
42 |         $this->value = $value;
43 |         $this->key = $key;
44 |         $this->headers = $headers;
45 |         $this->partitionIndex = $partitionIndex;
46 |     }
47 | 
48 |     public function getTopic(): string
49 |     {
50 |         return $this->topic;
51 |     }
52 | 
53 |     public function getValue(): ?string
54 |     {
55 |         return $this->value;
56 |     }
57 | 
58 |     public function getKey(): ?string
59 |     {
60 |         return $this->key;
61 |     }
62 | 
63 |     /**
64 |      * @return RecordHeader[]|array
65 |      */
66 |     public function getHeaders(): array
67 |     {
68 |         return $this->headers;
69 |     }
70 | 
71 |     public function getPartitionIndex(): ?int
72 |     {
73 |         return $this->partitionIndex;
74 |     }
75 | }
76 | 


--------------------------------------------------------------------------------
/src/Protocol/AbstractProtocol.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace longlang\phpkafka\Protocol;
 6 | 
 7 | abstract class AbstractProtocol extends AbstractStruct
 8 | {
 9 |     abstract public function getRequestApiKey(): ?int;
10 | }
11 | 


--------------------------------------------------------------------------------
/src/Protocol/AbstractRequest.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace longlang\phpkafka\Protocol;
 6 | 
 7 | abstract class AbstractRequest extends AbstractProtocol
 8 | {
 9 |     abstract public function getMaxSupportedVersion(): int;
10 | 
11 |     public function getApiKeyText(): string
12 |     {
13 |         return ApiKeys::PROTOCOL_MAP[$this->getRequestApiKey()] ?? 'Unknown';
14 |     }
15 | }
16 | 


--------------------------------------------------------------------------------
/src/Protocol/AbstractRequestHeader.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace longlang\phpkafka\Protocol;
 6 | 
 7 | class AbstractRequestHeader extends AbstractStruct
 8 | {
 9 |     public static function parseVersion(int $requestApiVersion, array $flexibleVersions): int
10 |     {
11 |         return \in_array($requestApiVersion, $flexibleVersions) ? 2 : 1;
12 |     }
13 | }
14 | 


--------------------------------------------------------------------------------
/src/Protocol/AbstractResponse.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace longlang\phpkafka\Protocol;
 6 | 
 7 | abstract class AbstractResponse extends AbstractProtocol
 8 | {
 9 | }
10 | 


--------------------------------------------------------------------------------
/src/Protocol/AbstractResponseHeader.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace longlang\phpkafka\Protocol;
 6 | 
 7 | class AbstractResponseHeader extends AbstractStruct
 8 | {
 9 |     public static function parseVersion(int $requestApiVersion, array $flexibleVersions): int
10 |     {
11 |         return \in_array($requestApiVersion, $flexibleVersions) ? 1 : 0;
12 |     }
13 | }
14 | 


--------------------------------------------------------------------------------
/src/Protocol/AddOffsetsToTxn/AddOffsetsToTxnResponse.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace longlang\phpkafka\Protocol\AddOffsetsToTxn;
 6 | 
 7 | use longlang\phpkafka\Protocol\AbstractResponse;
 8 | use longlang\phpkafka\Protocol\ProtocolField;
 9 | 
10 | class AddOffsetsToTxnResponse extends AbstractResponse
11 | {
12 |     /**
13 |      * Duration in milliseconds for which the request was throttled due to a quota violation, or zero if the request did not violate any quota.
14 |      *
15 |      * @var int
16 |      */
17 |     protected $throttleTimeMs = 0;
18 | 
19 |     /**
20 |      * The response error code, or 0 if there was no error.
21 |      *
22 |      * @var int
23 |      */
24 |     protected $errorCode = 0;
25 | 
26 |     public function __construct()
27 |     {
28 |         if (!isset(self::$maps[self::class])) {
29 |             self::$maps[self::class] = [
30 |                 new ProtocolField('throttleTimeMs', 'int32', false, [0, 1], [], [], [], null),
31 |                 new ProtocolField('errorCode', 'int16', false, [0, 1], [], [], [], null),
32 |             ];
33 |             self::$taggedFieldses[self::class] = [
34 |             ];
35 |         }
36 |     }
37 | 
38 |     public function getRequestApiKey(): ?int
39 |     {
40 |         return 25;
41 |     }
42 | 
43 |     public function getFlexibleVersions(): array
44 |     {
45 |         return [];
46 |     }
47 | 
48 |     public function getThrottleTimeMs(): int
49 |     {
50 |         return $this->throttleTimeMs;
51 |     }
52 | 
53 |     public function setThrottleTimeMs(int $throttleTimeMs): self
54 |     {
55 |         $this->throttleTimeMs = $throttleTimeMs;
56 | 
57 |         return $this;
58 |     }
59 | 
60 |     public function getErrorCode(): int
61 |     {
62 |         return $this->errorCode;
63 |     }
64 | 
65 |     public function setErrorCode(int $errorCode): self
66 |     {
67 |         $this->errorCode = $errorCode;
68 | 
69 |         return $this;
70 |     }
71 | }
72 | 


--------------------------------------------------------------------------------
/src/Protocol/AddPartitionsToTxn/AddPartitionsToTxnPartitionResult.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace longlang\phpkafka\Protocol\AddPartitionsToTxn;
 6 | 
 7 | use longlang\phpkafka\Protocol\AbstractStruct;
 8 | use longlang\phpkafka\Protocol\ProtocolField;
 9 | 
10 | class AddPartitionsToTxnPartitionResult extends AbstractStruct
11 | {
12 |     /**
13 |      * The partition indexes.
14 |      *
15 |      * @var int
16 |      */
17 |     protected $partitionIndex = 0;
18 | 
19 |     /**
20 |      * The response error code.
21 |      *
22 |      * @var int
23 |      */
24 |     protected $errorCode = 0;
25 | 
26 |     public function __construct()
27 |     {
28 |         if (!isset(self::$maps[self::class])) {
29 |             self::$maps[self::class] = [
30 |                 new ProtocolField('partitionIndex', 'int32', false, [0, 1], [], [], [], null),
31 |                 new ProtocolField('errorCode', 'int16', false, [0, 1], [], [], [], null),
32 |             ];
33 |             self::$taggedFieldses[self::class] = [
34 |             ];
35 |         }
36 |     }
37 | 
38 |     public function getFlexibleVersions(): array
39 |     {
40 |         return [];
41 |     }
42 | 
43 |     public function getPartitionIndex(): int
44 |     {
45 |         return $this->partitionIndex;
46 |     }
47 | 
48 |     public function setPartitionIndex(int $partitionIndex): self
49 |     {
50 |         $this->partitionIndex = $partitionIndex;
51 | 
52 |         return $this;
53 |     }
54 | 
55 |     public function getErrorCode(): int
56 |     {
57 |         return $this->errorCode;
58 |     }
59 | 
60 |     public function setErrorCode(int $errorCode): self
61 |     {
62 |         $this->errorCode = $errorCode;
63 | 
64 |         return $this;
65 |     }
66 | }
67 | 


--------------------------------------------------------------------------------
/src/Protocol/AddPartitionsToTxn/AddPartitionsToTxnTopic.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace longlang\phpkafka\Protocol\AddPartitionsToTxn;
 6 | 
 7 | use longlang\phpkafka\Protocol\AbstractStruct;
 8 | use longlang\phpkafka\Protocol\ProtocolField;
 9 | 
10 | class AddPartitionsToTxnTopic extends AbstractStruct
11 | {
12 |     /**
13 |      * The name of the topic.
14 |      *
15 |      * @var string
16 |      */
17 |     protected $name = '';
18 | 
19 |     /**
20 |      * The partition indexes to add to the transaction.
21 |      *
22 |      * @var int[]
23 |      */
24 |     protected $partitions = [];
25 | 
26 |     public function __construct()
27 |     {
28 |         if (!isset(self::$maps[self::class])) {
29 |             self::$maps[self::class] = [
30 |                 new ProtocolField('name', 'string', false, [0, 1], [], [], [], null),
31 |                 new ProtocolField('partitions', 'int32', true, [0, 1], [], [], [], null),
32 |             ];
33 |             self::$taggedFieldses[self::class] = [
34 |             ];
35 |         }
36 |     }
37 | 
38 |     public function getFlexibleVersions(): array
39 |     {
40 |         return [];
41 |     }
42 | 
43 |     public function getName(): string
44 |     {
45 |         return $this->name;
46 |     }
47 | 
48 |     public function setName(string $name): self
49 |     {
50 |         $this->name = $name;
51 | 
52 |         return $this;
53 |     }
54 | 
55 |     /**
56 |      * @return int[]
57 |      */
58 |     public function getPartitions(): array
59 |     {
60 |         return $this->partitions;
61 |     }
62 | 
63 |     /**
64 |      * @param int[] $partitions
65 |      */
66 |     public function setPartitions(array $partitions): self
67 |     {
68 |         $this->partitions = $partitions;
69 | 
70 |         return $this;
71 |     }
72 | }
73 | 


--------------------------------------------------------------------------------
/src/Protocol/AddPartitionsToTxn/AddPartitionsToTxnTopicResult.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace longlang\phpkafka\Protocol\AddPartitionsToTxn;
 6 | 
 7 | use longlang\phpkafka\Protocol\AbstractStruct;
 8 | use longlang\phpkafka\Protocol\ProtocolField;
 9 | 
10 | class AddPartitionsToTxnTopicResult extends AbstractStruct
11 | {
12 |     /**
13 |      * The topic name.
14 |      *
15 |      * @var string
16 |      */
17 |     protected $name = '';
18 | 
19 |     /**
20 |      * The results for each partition.
21 |      *
22 |      * @var AddPartitionsToTxnPartitionResult[]
23 |      */
24 |     protected $results = [];
25 | 
26 |     public function __construct()
27 |     {
28 |         if (!isset(self::$maps[self::class])) {
29 |             self::$maps[self::class] = [
30 |                 new ProtocolField('name', 'string', false, [0, 1], [], [], [], null),
31 |                 new ProtocolField('results', AddPartitionsToTxnPartitionResult::class, true, [0, 1], [], [], [], null),
32 |             ];
33 |             self::$taggedFieldses[self::class] = [
34 |             ];
35 |         }
36 |     }
37 | 
38 |     public function getFlexibleVersions(): array
39 |     {
40 |         return [];
41 |     }
42 | 
43 |     public function getName(): string
44 |     {
45 |         return $this->name;
46 |     }
47 | 
48 |     public function setName(string $name): self
49 |     {
50 |         $this->name = $name;
51 | 
52 |         return $this;
53 |     }
54 | 
55 |     /**
56 |      * @return AddPartitionsToTxnPartitionResult[]
57 |      */
58 |     public function getResults(): array
59 |     {
60 |         return $this->results;
61 |     }
62 | 
63 |     /**
64 |      * @param AddPartitionsToTxnPartitionResult[] $results
65 |      */
66 |     public function setResults(array $results): self
67 |     {
68 |         $this->results = $results;
69 | 
70 |         return $this;
71 |     }
72 | }
73 | 


--------------------------------------------------------------------------------
/src/Protocol/AlterClientQuotas/EntityData.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace longlang\phpkafka\Protocol\AlterClientQuotas;
 6 | 
 7 | use longlang\phpkafka\Protocol\AbstractStruct;
 8 | use longlang\phpkafka\Protocol\ProtocolField;
 9 | 
10 | class EntityData extends AbstractStruct
11 | {
12 |     /**
13 |      * The entity type.
14 |      *
15 |      * @var string
16 |      */
17 |     protected $entityType = '';
18 | 
19 |     /**
20 |      * The name of the entity, or null if the default.
21 |      *
22 |      * @var string|null
23 |      */
24 |     protected $entityName = null;
25 | 
26 |     public function __construct()
27 |     {
28 |         if (!isset(self::$maps[self::class])) {
29 |             self::$maps[self::class] = [
30 |                 new ProtocolField('entityType', 'string', false, [0], [], [], [], null),
31 |                 new ProtocolField('entityName', 'string', false, [0], [], [0], [], null),
32 |             ];
33 |             self::$taggedFieldses[self::class] = [
34 |             ];
35 |         }
36 |     }
37 | 
38 |     public function getFlexibleVersions(): array
39 |     {
40 |         return [];
41 |     }
42 | 
43 |     public function getEntityType(): string
44 |     {
45 |         return $this->entityType;
46 |     }
47 | 
48 |     public function setEntityType(string $entityType): self
49 |     {
50 |         $this->entityType = $entityType;
51 | 
52 |         return $this;
53 |     }
54 | 
55 |     public function getEntityName(): ?string
56 |     {
57 |         return $this->entityName;
58 |     }
59 | 
60 |     public function setEntityName(?string $entityName): self
61 |     {
62 |         $this->entityName = $entityName;
63 | 
64 |         return $this;
65 |     }
66 | }
67 | 


--------------------------------------------------------------------------------
/src/Protocol/AlterConfigs/AlterableConfig.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace longlang\phpkafka\Protocol\AlterConfigs;
 6 | 
 7 | use longlang\phpkafka\Protocol\AbstractStruct;
 8 | use longlang\phpkafka\Protocol\ProtocolField;
 9 | 
10 | class AlterableConfig extends AbstractStruct
11 | {
12 |     /**
13 |      * The configuration key name.
14 |      *
15 |      * @var string
16 |      */
17 |     protected $name = '';
18 | 
19 |     /**
20 |      * The value to set for the configuration key.
21 |      *
22 |      * @var string|null
23 |      */
24 |     protected $value = null;
25 | 
26 |     public function __construct()
27 |     {
28 |         if (!isset(self::$maps[self::class])) {
29 |             self::$maps[self::class] = [
30 |                 new ProtocolField('name', 'string', false, [0, 1], [], [], [], null),
31 |                 new ProtocolField('value', 'string', false, [0, 1], [], [0, 1], [], null),
32 |             ];
33 |             self::$taggedFieldses[self::class] = [
34 |             ];
35 |         }
36 |     }
37 | 
38 |     public function getFlexibleVersions(): array
39 |     {
40 |         return [];
41 |     }
42 | 
43 |     public function getName(): string
44 |     {
45 |         return $this->name;
46 |     }
47 | 
48 |     public function setName(string $name): self
49 |     {
50 |         $this->name = $name;
51 | 
52 |         return $this;
53 |     }
54 | 
55 |     public function getValue(): ?string
56 |     {
57 |         return $this->value;
58 |     }
59 | 
60 |     public function setValue(?string $value): self
61 |     {
62 |         $this->value = $value;
63 | 
64 |         return $this;
65 |     }
66 | }
67 | 


--------------------------------------------------------------------------------
/src/Protocol/AlterPartitionReassignments/ReassignablePartition.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace longlang\phpkafka\Protocol\AlterPartitionReassignments;
 6 | 
 7 | use longlang\phpkafka\Protocol\AbstractStruct;
 8 | use longlang\phpkafka\Protocol\ProtocolField;
 9 | 
10 | class ReassignablePartition extends AbstractStruct
11 | {
12 |     /**
13 |      * The partition index.
14 |      *
15 |      * @var int
16 |      */
17 |     protected $partitionIndex = 0;
18 | 
19 |     /**
20 |      * The replicas to place the partitions on, or null to cancel a pending reassignment for this partition.
21 |      *
22 |      * @var int[]|null
23 |      */
24 |     protected $replicas = null;
25 | 
26 |     public function __construct()
27 |     {
28 |         if (!isset(self::$maps[self::class])) {
29 |             self::$maps[self::class] = [
30 |                 new ProtocolField('partitionIndex', 'int32', false, [0], [0], [], [], null),
31 |                 new ProtocolField('replicas', 'int32', true, [0], [0], [0], [], null),
32 |             ];
33 |             self::$taggedFieldses[self::class] = [
34 |             ];
35 |         }
36 |     }
37 | 
38 |     public function getFlexibleVersions(): array
39 |     {
40 |         return [0];
41 |     }
42 | 
43 |     public function getPartitionIndex(): int
44 |     {
45 |         return $this->partitionIndex;
46 |     }
47 | 
48 |     public function setPartitionIndex(int $partitionIndex): self
49 |     {
50 |         $this->partitionIndex = $partitionIndex;
51 | 
52 |         return $this;
53 |     }
54 | 
55 |     /**
56 |      * @return int[]|null
57 |      */
58 |     public function getReplicas(): ?array
59 |     {
60 |         return $this->replicas;
61 |     }
62 | 
63 |     /**
64 |      * @param int[]|null $replicas
65 |      */
66 |     public function setReplicas(?array $replicas): self
67 |     {
68 |         $this->replicas = $replicas;
69 | 
70 |         return $this;
71 |     }
72 | }
73 | 


--------------------------------------------------------------------------------
/src/Protocol/AlterPartitionReassignments/ReassignableTopic.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace longlang\phpkafka\Protocol\AlterPartitionReassignments;
 6 | 
 7 | use longlang\phpkafka\Protocol\AbstractStruct;
 8 | use longlang\phpkafka\Protocol\ProtocolField;
 9 | 
10 | class ReassignableTopic extends AbstractStruct
11 | {
12 |     /**
13 |      * The topic name.
14 |      *
15 |      * @var string
16 |      */
17 |     protected $name = '';
18 | 
19 |     /**
20 |      * The partitions to reassign.
21 |      *
22 |      * @var ReassignablePartition[]
23 |      */
24 |     protected $partitions = [];
25 | 
26 |     public function __construct()
27 |     {
28 |         if (!isset(self::$maps[self::class])) {
29 |             self::$maps[self::class] = [
30 |                 new ProtocolField('name', 'string', false, [0], [0], [], [], null),
31 |                 new ProtocolField('partitions', ReassignablePartition::class, true, [0], [0], [], [], null),
32 |             ];
33 |             self::$taggedFieldses[self::class] = [
34 |             ];
35 |         }
36 |     }
37 | 
38 |     public function getFlexibleVersions(): array
39 |     {
40 |         return [0];
41 |     }
42 | 
43 |     public function getName(): string
44 |     {
45 |         return $this->name;
46 |     }
47 | 
48 |     public function setName(string $name): self
49 |     {
50 |         $this->name = $name;
51 | 
52 |         return $this;
53 |     }
54 | 
55 |     /**
56 |      * @return ReassignablePartition[]
57 |      */
58 |     public function getPartitions(): array
59 |     {
60 |         return $this->partitions;
61 |     }
62 | 
63 |     /**
64 |      * @param ReassignablePartition[] $partitions
65 |      */
66 |     public function setPartitions(array $partitions): self
67 |     {
68 |         $this->partitions = $partitions;
69 | 
70 |         return $this;
71 |     }
72 | }
73 | 


--------------------------------------------------------------------------------
/src/Protocol/AlterPartitionReassignments/ReassignableTopicResponse.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace longlang\phpkafka\Protocol\AlterPartitionReassignments;
 6 | 
 7 | use longlang\phpkafka\Protocol\AbstractStruct;
 8 | use longlang\phpkafka\Protocol\ProtocolField;
 9 | 
10 | class ReassignableTopicResponse extends AbstractStruct
11 | {
12 |     /**
13 |      * The topic name.
14 |      *
15 |      * @var string
16 |      */
17 |     protected $name = '';
18 | 
19 |     /**
20 |      * The responses to partitions to reassign.
21 |      *
22 |      * @var ReassignablePartitionResponse[]
23 |      */
24 |     protected $partitions = [];
25 | 
26 |     public function __construct()
27 |     {
28 |         if (!isset(self::$maps[self::class])) {
29 |             self::$maps[self::class] = [
30 |                 new ProtocolField('name', 'string', false, [0], [0], [], [], null),
31 |                 new ProtocolField('partitions', ReassignablePartitionResponse::class, true, [0], [0], [], [], null),
32 |             ];
33 |             self::$taggedFieldses[self::class] = [
34 |             ];
35 |         }
36 |     }
37 | 
38 |     public function getFlexibleVersions(): array
39 |     {
40 |         return [0];
41 |     }
42 | 
43 |     public function getName(): string
44 |     {
45 |         return $this->name;
46 |     }
47 | 
48 |     public function setName(string $name): self
49 |     {
50 |         $this->name = $name;
51 | 
52 |         return $this;
53 |     }
54 | 
55 |     /**
56 |      * @return ReassignablePartitionResponse[]
57 |      */
58 |     public function getPartitions(): array
59 |     {
60 |         return $this->partitions;
61 |     }
62 | 
63 |     /**
64 |      * @param ReassignablePartitionResponse[] $partitions
65 |      */
66 |     public function setPartitions(array $partitions): self
67 |     {
68 |         $this->partitions = $partitions;
69 | 
70 |         return $this;
71 |     }
72 | }
73 | 


--------------------------------------------------------------------------------
/src/Protocol/AlterReplicaLogDirs/AlterReplicaLogDir.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace longlang\phpkafka\Protocol\AlterReplicaLogDirs;
 6 | 
 7 | use longlang\phpkafka\Protocol\AbstractStruct;
 8 | use longlang\phpkafka\Protocol\ProtocolField;
 9 | 
10 | class AlterReplicaLogDir extends AbstractStruct
11 | {
12 |     /**
13 |      * The absolute directory path.
14 |      *
15 |      * @var string
16 |      */
17 |     protected $path = '';
18 | 
19 |     /**
20 |      * The topics to add to the directory.
21 |      *
22 |      * @var AlterReplicaLogDirTopic[]
23 |      */
24 |     protected $topics = [];
25 | 
26 |     public function __construct()
27 |     {
28 |         if (!isset(self::$maps[self::class])) {
29 |             self::$maps[self::class] = [
30 |                 new ProtocolField('path', 'string', false, [0, 1], [], [], [], null),
31 |                 new ProtocolField('topics', AlterReplicaLogDirTopic::class, true, [0, 1], [], [], [], null),
32 |             ];
33 |             self::$taggedFieldses[self::class] = [
34 |             ];
35 |         }
36 |     }
37 | 
38 |     public function getFlexibleVersions(): array
39 |     {
40 |         return [];
41 |     }
42 | 
43 |     public function getPath(): string
44 |     {
45 |         return $this->path;
46 |     }
47 | 
48 |     public function setPath(string $path): self
49 |     {
50 |         $this->path = $path;
51 | 
52 |         return $this;
53 |     }
54 | 
55 |     /**
56 |      * @return AlterReplicaLogDirTopic[]
57 |      */
58 |     public function getTopics(): array
59 |     {
60 |         return $this->topics;
61 |     }
62 | 
63 |     /**
64 |      * @param AlterReplicaLogDirTopic[] $topics
65 |      */
66 |     public function setTopics(array $topics): self
67 |     {
68 |         $this->topics = $topics;
69 | 
70 |         return $this;
71 |     }
72 | }
73 | 


--------------------------------------------------------------------------------
/src/Protocol/AlterReplicaLogDirs/AlterReplicaLogDirPartitionResult.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace longlang\phpkafka\Protocol\AlterReplicaLogDirs;
 6 | 
 7 | use longlang\phpkafka\Protocol\AbstractStruct;
 8 | use longlang\phpkafka\Protocol\ProtocolField;
 9 | 
10 | class AlterReplicaLogDirPartitionResult extends AbstractStruct
11 | {
12 |     /**
13 |      * The partition index.
14 |      *
15 |      * @var int
16 |      */
17 |     protected $partitionIndex = 0;
18 | 
19 |     /**
20 |      * The error code, or 0 if there was no error.
21 |      *
22 |      * @var int
23 |      */
24 |     protected $errorCode = 0;
25 | 
26 |     public function __construct()
27 |     {
28 |         if (!isset(self::$maps[self::class])) {
29 |             self::$maps[self::class] = [
30 |                 new ProtocolField('partitionIndex', 'int32', false, [0, 1], [], [], [], null),
31 |                 new ProtocolField('errorCode', 'int16', false, [0, 1], [], [], [], null),
32 |             ];
33 |             self::$taggedFieldses[self::class] = [
34 |             ];
35 |         }
36 |     }
37 | 
38 |     public function getFlexibleVersions(): array
39 |     {
40 |         return [];
41 |     }
42 | 
43 |     public function getPartitionIndex(): int
44 |     {
45 |         return $this->partitionIndex;
46 |     }
47 | 
48 |     public function setPartitionIndex(int $partitionIndex): self
49 |     {
50 |         $this->partitionIndex = $partitionIndex;
51 | 
52 |         return $this;
53 |     }
54 | 
55 |     public function getErrorCode(): int
56 |     {
57 |         return $this->errorCode;
58 |     }
59 | 
60 |     public function setErrorCode(int $errorCode): self
61 |     {
62 |         $this->errorCode = $errorCode;
63 | 
64 |         return $this;
65 |     }
66 | }
67 | 


--------------------------------------------------------------------------------
/src/Protocol/AlterReplicaLogDirs/AlterReplicaLogDirTopic.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace longlang\phpkafka\Protocol\AlterReplicaLogDirs;
 6 | 
 7 | use longlang\phpkafka\Protocol\AbstractStruct;
 8 | use longlang\phpkafka\Protocol\ProtocolField;
 9 | 
10 | class AlterReplicaLogDirTopic extends AbstractStruct
11 | {
12 |     /**
13 |      * The topic name.
14 |      *
15 |      * @var string
16 |      */
17 |     protected $name = '';
18 | 
19 |     /**
20 |      * The partition indexes.
21 |      *
22 |      * @var int[]
23 |      */
24 |     protected $partitions = [];
25 | 
26 |     public function __construct()
27 |     {
28 |         if (!isset(self::$maps[self::class])) {
29 |             self::$maps[self::class] = [
30 |                 new ProtocolField('name', 'string', false, [0, 1], [], [], [], null),
31 |                 new ProtocolField('partitions', 'int32', true, [0, 1], [], [], [], null),
32 |             ];
33 |             self::$taggedFieldses[self::class] = [
34 |             ];
35 |         }
36 |     }
37 | 
38 |     public function getFlexibleVersions(): array
39 |     {
40 |         return [];
41 |     }
42 | 
43 |     public function getName(): string
44 |     {
45 |         return $this->name;
46 |     }
47 | 
48 |     public function setName(string $name): self
49 |     {
50 |         $this->name = $name;
51 | 
52 |         return $this;
53 |     }
54 | 
55 |     /**
56 |      * @return int[]
57 |      */
58 |     public function getPartitions(): array
59 |     {
60 |         return $this->partitions;
61 |     }
62 | 
63 |     /**
64 |      * @param int[] $partitions
65 |      */
66 |     public function setPartitions(array $partitions): self
67 |     {
68 |         $this->partitions = $partitions;
69 | 
70 |         return $this;
71 |     }
72 | }
73 | 


--------------------------------------------------------------------------------
/src/Protocol/AlterReplicaLogDirs/AlterReplicaLogDirTopicResult.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace longlang\phpkafka\Protocol\AlterReplicaLogDirs;
 6 | 
 7 | use longlang\phpkafka\Protocol\AbstractStruct;
 8 | use longlang\phpkafka\Protocol\ProtocolField;
 9 | 
10 | class AlterReplicaLogDirTopicResult extends AbstractStruct
11 | {
12 |     /**
13 |      * The name of the topic.
14 |      *
15 |      * @var string
16 |      */
17 |     protected $topicName = '';
18 | 
19 |     /**
20 |      * The results for each partition.
21 |      *
22 |      * @var AlterReplicaLogDirPartitionResult[]
23 |      */
24 |     protected $partitions = [];
25 | 
26 |     public function __construct()
27 |     {
28 |         if (!isset(self::$maps[self::class])) {
29 |             self::$maps[self::class] = [
30 |                 new ProtocolField('topicName', 'string', false, [0, 1], [], [], [], null),
31 |                 new ProtocolField('partitions', AlterReplicaLogDirPartitionResult::class, true, [0, 1], [], [], [], null),
32 |             ];
33 |             self::$taggedFieldses[self::class] = [
34 |             ];
35 |         }
36 |     }
37 | 
38 |     public function getFlexibleVersions(): array
39 |     {
40 |         return [];
41 |     }
42 | 
43 |     public function getTopicName(): string
44 |     {
45 |         return $this->topicName;
46 |     }
47 | 
48 |     public function setTopicName(string $topicName): self
49 |     {
50 |         $this->topicName = $topicName;
51 | 
52 |         return $this;
53 |     }
54 | 
55 |     /**
56 |      * @return AlterReplicaLogDirPartitionResult[]
57 |      */
58 |     public function getPartitions(): array
59 |     {
60 |         return $this->partitions;
61 |     }
62 | 
63 |     /**
64 |      * @param AlterReplicaLogDirPartitionResult[] $partitions
65 |      */
66 |     public function setPartitions(array $partitions): self
67 |     {
68 |         $this->partitions = $partitions;
69 | 
70 |         return $this;
71 |     }
72 | }
73 | 


--------------------------------------------------------------------------------
/src/Protocol/AlterReplicaLogDirs/AlterReplicaLogDirsRequest.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace longlang\phpkafka\Protocol\AlterReplicaLogDirs;
 6 | 
 7 | use longlang\phpkafka\Protocol\AbstractRequest;
 8 | use longlang\phpkafka\Protocol\ProtocolField;
 9 | 
10 | class AlterReplicaLogDirsRequest extends AbstractRequest
11 | {
12 |     /**
13 |      * The alterations to make for each directory.
14 |      *
15 |      * @var AlterReplicaLogDir[]
16 |      */
17 |     protected $dirs = [];
18 | 
19 |     public function __construct()
20 |     {
21 |         if (!isset(self::$maps[self::class])) {
22 |             self::$maps[self::class] = [
23 |                 new ProtocolField('dirs', AlterReplicaLogDir::class, true, [0, 1], [], [], [], null),
24 |             ];
25 |             self::$taggedFieldses[self::class] = [
26 |             ];
27 |         }
28 |     }
29 | 
30 |     public function getRequestApiKey(): ?int
31 |     {
32 |         return 34;
33 |     }
34 | 
35 |     public function getMaxSupportedVersion(): int
36 |     {
37 |         return 1;
38 |     }
39 | 
40 |     public function getFlexibleVersions(): array
41 |     {
42 |         return [];
43 |     }
44 | 
45 |     /**
46 |      * @return AlterReplicaLogDir[]
47 |      */
48 |     public function getDirs(): array
49 |     {
50 |         return $this->dirs;
51 |     }
52 | 
53 |     /**
54 |      * @param AlterReplicaLogDir[] $dirs
55 |      */
56 |     public function setDirs(array $dirs): self
57 |     {
58 |         $this->dirs = $dirs;
59 | 
60 |         return $this;
61 |     }
62 | }
63 | 


--------------------------------------------------------------------------------
/src/Protocol/ApiKeys.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace longlang\phpkafka\Protocol;
 6 | 
 7 | class ApiKeys extends AbstractApiKeys
 8 | {
 9 |     public static function createResponse(int $protocol, string $data = '', int $apiVersion = 0): AbstractResponse
10 |     {
11 |         $name = self::PROTOCOL_MAP[$protocol] ?? null;
12 |         if (!$name) {
13 |             throw new \RuntimeException(sprintf('Could not found api keys %d', $protocol));
14 |         }
15 |         $class = 'longlang\phpkafka\Protocol\\' . $name . '\\' . $name . 'Response';
16 |         /** @var AbstractResponse $instance */
17 |         $instance = new $class();
18 |         if ($data) {
19 |             $instance->unpack($data, $size, $apiVersion);
20 |         }
21 | 
22 |         return $instance;
23 |     }
24 | }
25 | 


--------------------------------------------------------------------------------
/src/Protocol/ControlledShutdown/ControlledShutdownRequest.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace longlang\phpkafka\Protocol\ControlledShutdown;
 6 | 
 7 | use longlang\phpkafka\Protocol\AbstractRequest;
 8 | use longlang\phpkafka\Protocol\ProtocolField;
 9 | 
10 | class ControlledShutdownRequest extends AbstractRequest
11 | {
12 |     /**
13 |      * The id of the broker for which controlled shutdown has been requested.
14 |      *
15 |      * @var int
16 |      */
17 |     protected $brokerId = 0;
18 | 
19 |     /**
20 |      * The broker epoch.
21 |      *
22 |      * @var int
23 |      */
24 |     protected $brokerEpoch = -1;
25 | 
26 |     public function __construct()
27 |     {
28 |         if (!isset(self::$maps[self::class])) {
29 |             self::$maps[self::class] = [
30 |                 new ProtocolField('brokerId', 'int32', false, [0, 1, 2, 3], [3], [], [], null),
31 |                 new ProtocolField('brokerEpoch', 'int64', false, [2, 3], [3], [], [], null),
32 |             ];
33 |             self::$taggedFieldses[self::class] = [
34 |             ];
35 |         }
36 |     }
37 | 
38 |     public function getRequestApiKey(): ?int
39 |     {
40 |         return 7;
41 |     }
42 | 
43 |     public function getMaxSupportedVersion(): int
44 |     {
45 |         return 3;
46 |     }
47 | 
48 |     public function getFlexibleVersions(): array
49 |     {
50 |         return [3];
51 |     }
52 | 
53 |     public function getBrokerId(): int
54 |     {
55 |         return $this->brokerId;
56 |     }
57 | 
58 |     public function setBrokerId(int $brokerId): self
59 |     {
60 |         $this->brokerId = $brokerId;
61 | 
62 |         return $this;
63 |     }
64 | 
65 |     public function getBrokerEpoch(): int
66 |     {
67 |         return $this->brokerEpoch;
68 |     }
69 | 
70 |     public function setBrokerEpoch(int $brokerEpoch): self
71 |     {
72 |         $this->brokerEpoch = $brokerEpoch;
73 | 
74 |         return $this;
75 |     }
76 | }
77 | 


--------------------------------------------------------------------------------
/src/Protocol/ControlledShutdown/RemainingPartition.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace longlang\phpkafka\Protocol\ControlledShutdown;
 6 | 
 7 | use longlang\phpkafka\Protocol\AbstractStruct;
 8 | use longlang\phpkafka\Protocol\ProtocolField;
 9 | 
10 | class RemainingPartition extends AbstractStruct
11 | {
12 |     /**
13 |      * The name of the topic.
14 |      *
15 |      * @var string
16 |      */
17 |     protected $topicName = '';
18 | 
19 |     /**
20 |      * The index of the partition.
21 |      *
22 |      * @var int
23 |      */
24 |     protected $partitionIndex = 0;
25 | 
26 |     public function __construct()
27 |     {
28 |         if (!isset(self::$maps[self::class])) {
29 |             self::$maps[self::class] = [
30 |                 new ProtocolField('topicName', 'string', false, [0, 1, 2, 3], [3], [], [], null),
31 |                 new ProtocolField('partitionIndex', 'int32', false, [0, 1, 2, 3], [3], [], [], null),
32 |             ];
33 |             self::$taggedFieldses[self::class] = [
34 |             ];
35 |         }
36 |     }
37 | 
38 |     public function getFlexibleVersions(): array
39 |     {
40 |         return [3];
41 |     }
42 | 
43 |     public function getTopicName(): string
44 |     {
45 |         return $this->topicName;
46 |     }
47 | 
48 |     public function setTopicName(string $topicName): self
49 |     {
50 |         $this->topicName = $topicName;
51 | 
52 |         return $this;
53 |     }
54 | 
55 |     public function getPartitionIndex(): int
56 |     {
57 |         return $this->partitionIndex;
58 |     }
59 | 
60 |     public function setPartitionIndex(int $partitionIndex): self
61 |     {
62 |         $this->partitionIndex = $partitionIndex;
63 | 
64 |         return $this;
65 |     }
66 | }
67 | 


--------------------------------------------------------------------------------
/src/Protocol/CreateAcls/AclCreationResult.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace longlang\phpkafka\Protocol\CreateAcls;
 6 | 
 7 | use longlang\phpkafka\Protocol\AbstractStruct;
 8 | use longlang\phpkafka\Protocol\ProtocolField;
 9 | 
10 | class AclCreationResult extends AbstractStruct
11 | {
12 |     /**
13 |      * The result error, or zero if there was no error.
14 |      *
15 |      * @var int
16 |      */
17 |     protected $errorCode = 0;
18 | 
19 |     /**
20 |      * The result message, or null if there was no error.
21 |      *
22 |      * @var string|null
23 |      */
24 |     protected $errorMessage = null;
25 | 
26 |     public function __construct()
27 |     {
28 |         if (!isset(self::$maps[self::class])) {
29 |             self::$maps[self::class] = [
30 |                 new ProtocolField('errorCode', 'int16', false, [0, 1, 2], [2], [], [], null),
31 |                 new ProtocolField('errorMessage', 'string', false, [0, 1, 2], [2], [0, 1, 2], [], null),
32 |             ];
33 |             self::$taggedFieldses[self::class] = [
34 |             ];
35 |         }
36 |     }
37 | 
38 |     public function getFlexibleVersions(): array
39 |     {
40 |         return [2];
41 |     }
42 | 
43 |     public function getErrorCode(): int
44 |     {
45 |         return $this->errorCode;
46 |     }
47 | 
48 |     public function setErrorCode(int $errorCode): self
49 |     {
50 |         $this->errorCode = $errorCode;
51 | 
52 |         return $this;
53 |     }
54 | 
55 |     public function getErrorMessage(): ?string
56 |     {
57 |         return $this->errorMessage;
58 |     }
59 | 
60 |     public function setErrorMessage(?string $errorMessage): self
61 |     {
62 |         $this->errorMessage = $errorMessage;
63 | 
64 |         return $this;
65 |     }
66 | }
67 | 


--------------------------------------------------------------------------------
/src/Protocol/CreateAcls/CreateAclsRequest.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace longlang\phpkafka\Protocol\CreateAcls;
 6 | 
 7 | use longlang\phpkafka\Protocol\AbstractRequest;
 8 | use longlang\phpkafka\Protocol\ProtocolField;
 9 | 
10 | class CreateAclsRequest extends AbstractRequest
11 | {
12 |     /**
13 |      * The ACLs that we want to create.
14 |      *
15 |      * @var AclCreation[]
16 |      */
17 |     protected $creations = [];
18 | 
19 |     public function __construct()
20 |     {
21 |         if (!isset(self::$maps[self::class])) {
22 |             self::$maps[self::class] = [
23 |                 new ProtocolField('creations', AclCreation::class, true, [0, 1, 2], [2], [], [], null),
24 |             ];
25 |             self::$taggedFieldses[self::class] = [
26 |             ];
27 |         }
28 |     }
29 | 
30 |     public function getRequestApiKey(): ?int
31 |     {
32 |         return 30;
33 |     }
34 | 
35 |     public function getMaxSupportedVersion(): int
36 |     {
37 |         return 2;
38 |     }
39 | 
40 |     public function getFlexibleVersions(): array
41 |     {
42 |         return [2];
43 |     }
44 | 
45 |     /**
46 |      * @return AclCreation[]
47 |      */
48 |     public function getCreations(): array
49 |     {
50 |         return $this->creations;
51 |     }
52 | 
53 |     /**
54 |      * @param AclCreation[] $creations
55 |      */
56 |     public function setCreations(array $creations): self
57 |     {
58 |         $this->creations = $creations;
59 | 
60 |         return $this;
61 |     }
62 | }
63 | 


--------------------------------------------------------------------------------
/src/Protocol/CreateDelegationToken/CreatableRenewers.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace longlang\phpkafka\Protocol\CreateDelegationToken;
 6 | 
 7 | use longlang\phpkafka\Protocol\AbstractStruct;
 8 | use longlang\phpkafka\Protocol\ProtocolField;
 9 | 
10 | class CreatableRenewers extends AbstractStruct
11 | {
12 |     /**
13 |      * The type of the Kafka principal.
14 |      *
15 |      * @var string
16 |      */
17 |     protected $principalType = '';
18 | 
19 |     /**
20 |      * The name of the Kafka principal.
21 |      *
22 |      * @var string
23 |      */
24 |     protected $principalName = '';
25 | 
26 |     public function __construct()
27 |     {
28 |         if (!isset(self::$maps[self::class])) {
29 |             self::$maps[self::class] = [
30 |                 new ProtocolField('principalType', 'string', false, [0, 1, 2], [2], [], [], null),
31 |                 new ProtocolField('principalName', 'string', false, [0, 1, 2], [2], [], [], null),
32 |             ];
33 |             self::$taggedFieldses[self::class] = [
34 |             ];
35 |         }
36 |     }
37 | 
38 |     public function getFlexibleVersions(): array
39 |     {
40 |         return [2];
41 |     }
42 | 
43 |     public function getPrincipalType(): string
44 |     {
45 |         return $this->principalType;
46 |     }
47 | 
48 |     public function setPrincipalType(string $principalType): self
49 |     {
50 |         $this->principalType = $principalType;
51 | 
52 |         return $this;
53 |     }
54 | 
55 |     public function getPrincipalName(): string
56 |     {
57 |         return $this->principalName;
58 |     }
59 | 
60 |     public function setPrincipalName(string $principalName): self
61 |     {
62 |         $this->principalName = $principalName;
63 | 
64 |         return $this;
65 |     }
66 | }
67 | 


--------------------------------------------------------------------------------
/src/Protocol/CreatePartitions/CreatePartitionsAssignment.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace longlang\phpkafka\Protocol\CreatePartitions;
 6 | 
 7 | use longlang\phpkafka\Protocol\AbstractStruct;
 8 | use longlang\phpkafka\Protocol\ProtocolField;
 9 | 
10 | class CreatePartitionsAssignment extends AbstractStruct
11 | {
12 |     /**
13 |      * The assigned broker IDs.
14 |      *
15 |      * @var int[]
16 |      */
17 |     protected $brokerIds = [];
18 | 
19 |     public function __construct()
20 |     {
21 |         if (!isset(self::$maps[self::class])) {
22 |             self::$maps[self::class] = [
23 |                 new ProtocolField('brokerIds', 'int32', true, [0, 1, 2], [2], [], [], null),
24 |             ];
25 |             self::$taggedFieldses[self::class] = [
26 |             ];
27 |         }
28 |     }
29 | 
30 |     public function getFlexibleVersions(): array
31 |     {
32 |         return [2];
33 |     }
34 | 
35 |     /**
36 |      * @return int[]
37 |      */
38 |     public function getBrokerIds(): array
39 |     {
40 |         return $this->brokerIds;
41 |     }
42 | 
43 |     /**
44 |      * @param int[] $brokerIds
45 |      */
46 |     public function setBrokerIds(array $brokerIds): self
47 |     {
48 |         $this->brokerIds = $brokerIds;
49 | 
50 |         return $this;
51 |     }
52 | }
53 | 


--------------------------------------------------------------------------------
/src/Protocol/CreateTopics/CreatableReplicaAssignment.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace longlang\phpkafka\Protocol\CreateTopics;
 6 | 
 7 | use longlang\phpkafka\Protocol\AbstractStruct;
 8 | use longlang\phpkafka\Protocol\ProtocolField;
 9 | 
10 | class CreatableReplicaAssignment extends AbstractStruct
11 | {
12 |     /**
13 |      * The partition index.
14 |      *
15 |      * @var int
16 |      */
17 |     protected $partitionIndex = 0;
18 | 
19 |     /**
20 |      * The brokers to place the partition on.
21 |      *
22 |      * @var int[]
23 |      */
24 |     protected $brokerIds = [];
25 | 
26 |     public function __construct()
27 |     {
28 |         if (!isset(self::$maps[self::class])) {
29 |             self::$maps[self::class] = [
30 |                 new ProtocolField('partitionIndex', 'int32', false, [0, 1, 2, 3, 4, 5], [5], [], [], null),
31 |                 new ProtocolField('brokerIds', 'int32', true, [0, 1, 2, 3, 4, 5], [5], [], [], null),
32 |             ];
33 |             self::$taggedFieldses[self::class] = [
34 |             ];
35 |         }
36 |     }
37 | 
38 |     public function getFlexibleVersions(): array
39 |     {
40 |         return [5];
41 |     }
42 | 
43 |     public function getPartitionIndex(): int
44 |     {
45 |         return $this->partitionIndex;
46 |     }
47 | 
48 |     public function setPartitionIndex(int $partitionIndex): self
49 |     {
50 |         $this->partitionIndex = $partitionIndex;
51 | 
52 |         return $this;
53 |     }
54 | 
55 |     /**
56 |      * @return int[]
57 |      */
58 |     public function getBrokerIds(): array
59 |     {
60 |         return $this->brokerIds;
61 |     }
62 | 
63 |     /**
64 |      * @param int[] $brokerIds
65 |      */
66 |     public function setBrokerIds(array $brokerIds): self
67 |     {
68 |         $this->brokerIds = $brokerIds;
69 | 
70 |         return $this;
71 |     }
72 | }
73 | 


--------------------------------------------------------------------------------
/src/Protocol/CreateTopics/CreateableTopicConfig.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace longlang\phpkafka\Protocol\CreateTopics;
 6 | 
 7 | use longlang\phpkafka\Protocol\AbstractStruct;
 8 | use longlang\phpkafka\Protocol\ProtocolField;
 9 | 
10 | class CreateableTopicConfig extends AbstractStruct
11 | {
12 |     /**
13 |      * The configuration name.
14 |      *
15 |      * @var string
16 |      */
17 |     protected $name = '';
18 | 
19 |     /**
20 |      * The configuration value.
21 |      *
22 |      * @var string|null
23 |      */
24 |     protected $value = null;
25 | 
26 |     public function __construct()
27 |     {
28 |         if (!isset(self::$maps[self::class])) {
29 |             self::$maps[self::class] = [
30 |                 new ProtocolField('name', 'string', false, [0, 1, 2, 3, 4, 5], [5], [], [], null),
31 |                 new ProtocolField('value', 'string', false, [0, 1, 2, 3, 4, 5], [5], [0, 1, 2, 3, 4, 5], [], null),
32 |             ];
33 |             self::$taggedFieldses[self::class] = [
34 |             ];
35 |         }
36 |     }
37 | 
38 |     public function getFlexibleVersions(): array
39 |     {
40 |         return [5];
41 |     }
42 | 
43 |     public function getName(): string
44 |     {
45 |         return $this->name;
46 |     }
47 | 
48 |     public function setName(string $name): self
49 |     {
50 |         $this->name = $name;
51 | 
52 |         return $this;
53 |     }
54 | 
55 |     public function getValue(): ?string
56 |     {
57 |         return $this->value;
58 |     }
59 | 
60 |     public function setValue(?string $value): self
61 |     {
62 |         $this->value = $value;
63 | 
64 |         return $this;
65 |     }
66 | }
67 | 


--------------------------------------------------------------------------------
/src/Protocol/DeleteAcls/DeleteAclsRequest.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace longlang\phpkafka\Protocol\DeleteAcls;
 6 | 
 7 | use longlang\phpkafka\Protocol\AbstractRequest;
 8 | use longlang\phpkafka\Protocol\ProtocolField;
 9 | 
10 | class DeleteAclsRequest extends AbstractRequest
11 | {
12 |     /**
13 |      * The filters to use when deleting ACLs.
14 |      *
15 |      * @var DeleteAclsFilter[]
16 |      */
17 |     protected $filters = [];
18 | 
19 |     public function __construct()
20 |     {
21 |         if (!isset(self::$maps[self::class])) {
22 |             self::$maps[self::class] = [
23 |                 new ProtocolField('filters', DeleteAclsFilter::class, true, [0, 1, 2], [2], [], [], null),
24 |             ];
25 |             self::$taggedFieldses[self::class] = [
26 |             ];
27 |         }
28 |     }
29 | 
30 |     public function getRequestApiKey(): ?int
31 |     {
32 |         return 31;
33 |     }
34 | 
35 |     public function getMaxSupportedVersion(): int
36 |     {
37 |         return 2;
38 |     }
39 | 
40 |     public function getFlexibleVersions(): array
41 |     {
42 |         return [2];
43 |     }
44 | 
45 |     /**
46 |      * @return DeleteAclsFilter[]
47 |      */
48 |     public function getFilters(): array
49 |     {
50 |         return $this->filters;
51 |     }
52 | 
53 |     /**
54 |      * @param DeleteAclsFilter[] $filters
55 |      */
56 |     public function setFilters(array $filters): self
57 |     {
58 |         $this->filters = $filters;
59 | 
60 |         return $this;
61 |     }
62 | }
63 | 


--------------------------------------------------------------------------------
/src/Protocol/DeleteGroups/DeletableGroupResult.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace longlang\phpkafka\Protocol\DeleteGroups;
 6 | 
 7 | use longlang\phpkafka\Protocol\AbstractStruct;
 8 | use longlang\phpkafka\Protocol\ProtocolField;
 9 | 
10 | class DeletableGroupResult extends AbstractStruct
11 | {
12 |     /**
13 |      * The group id.
14 |      *
15 |      * @var string
16 |      */
17 |     protected $groupId = '';
18 | 
19 |     /**
20 |      * The deletion error, or 0 if the deletion succeeded.
21 |      *
22 |      * @var int
23 |      */
24 |     protected $errorCode = 0;
25 | 
26 |     public function __construct()
27 |     {
28 |         if (!isset(self::$maps[self::class])) {
29 |             self::$maps[self::class] = [
30 |                 new ProtocolField('groupId', 'string', false, [0, 1, 2], [2], [], [], null),
31 |                 new ProtocolField('errorCode', 'int16', false, [0, 1, 2], [2], [], [], null),
32 |             ];
33 |             self::$taggedFieldses[self::class] = [
34 |             ];
35 |         }
36 |     }
37 | 
38 |     public function getFlexibleVersions(): array
39 |     {
40 |         return [2];
41 |     }
42 | 
43 |     public function getGroupId(): string
44 |     {
45 |         return $this->groupId;
46 |     }
47 | 
48 |     public function setGroupId(string $groupId): self
49 |     {
50 |         $this->groupId = $groupId;
51 | 
52 |         return $this;
53 |     }
54 | 
55 |     public function getErrorCode(): int
56 |     {
57 |         return $this->errorCode;
58 |     }
59 | 
60 |     public function setErrorCode(int $errorCode): self
61 |     {
62 |         $this->errorCode = $errorCode;
63 | 
64 |         return $this;
65 |     }
66 | }
67 | 


--------------------------------------------------------------------------------
/src/Protocol/DeleteGroups/DeleteGroupsRequest.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace longlang\phpkafka\Protocol\DeleteGroups;
 6 | 
 7 | use longlang\phpkafka\Protocol\AbstractRequest;
 8 | use longlang\phpkafka\Protocol\ProtocolField;
 9 | 
10 | class DeleteGroupsRequest extends AbstractRequest
11 | {
12 |     /**
13 |      * The group names to delete.
14 |      *
15 |      * @var string[]
16 |      */
17 |     protected $groupsNames = [];
18 | 
19 |     public function __construct()
20 |     {
21 |         if (!isset(self::$maps[self::class])) {
22 |             self::$maps[self::class] = [
23 |                 new ProtocolField('groupsNames', 'string', true, [0, 1, 2], [2], [], [], null),
24 |             ];
25 |             self::$taggedFieldses[self::class] = [
26 |             ];
27 |         }
28 |     }
29 | 
30 |     public function getRequestApiKey(): ?int
31 |     {
32 |         return 42;
33 |     }
34 | 
35 |     public function getMaxSupportedVersion(): int
36 |     {
37 |         return 2;
38 |     }
39 | 
40 |     public function getFlexibleVersions(): array
41 |     {
42 |         return [2];
43 |     }
44 | 
45 |     /**
46 |      * @return string[]
47 |      */
48 |     public function getGroupsNames(): array
49 |     {
50 |         return $this->groupsNames;
51 |     }
52 | 
53 |     /**
54 |      * @param string[] $groupsNames
55 |      */
56 |     public function setGroupsNames(array $groupsNames): self
57 |     {
58 |         $this->groupsNames = $groupsNames;
59 | 
60 |         return $this;
61 |     }
62 | }
63 | 


--------------------------------------------------------------------------------
/src/Protocol/DeleteRecords/DeleteRecordsPartition.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace longlang\phpkafka\Protocol\DeleteRecords;
 6 | 
 7 | use longlang\phpkafka\Protocol\AbstractStruct;
 8 | use longlang\phpkafka\Protocol\ProtocolField;
 9 | 
10 | class DeleteRecordsPartition extends AbstractStruct
11 | {
12 |     /**
13 |      * The partition index.
14 |      *
15 |      * @var int
16 |      */
17 |     protected $partitionIndex = 0;
18 | 
19 |     /**
20 |      * The deletion offset.
21 |      *
22 |      * @var int
23 |      */
24 |     protected $offset = 0;
25 | 
26 |     public function __construct()
27 |     {
28 |         if (!isset(self::$maps[self::class])) {
29 |             self::$maps[self::class] = [
30 |                 new ProtocolField('partitionIndex', 'int32', false, [0, 1, 2], [2], [], [], null),
31 |                 new ProtocolField('offset', 'int64', false, [0, 1, 2], [2], [], [], null),
32 |             ];
33 |             self::$taggedFieldses[self::class] = [
34 |             ];
35 |         }
36 |     }
37 | 
38 |     public function getFlexibleVersions(): array
39 |     {
40 |         return [2];
41 |     }
42 | 
43 |     public function getPartitionIndex(): int
44 |     {
45 |         return $this->partitionIndex;
46 |     }
47 | 
48 |     public function setPartitionIndex(int $partitionIndex): self
49 |     {
50 |         $this->partitionIndex = $partitionIndex;
51 | 
52 |         return $this;
53 |     }
54 | 
55 |     public function getOffset(): int
56 |     {
57 |         return $this->offset;
58 |     }
59 | 
60 |     public function setOffset(int $offset): self
61 |     {
62 |         $this->offset = $offset;
63 | 
64 |         return $this;
65 |     }
66 | }
67 | 


--------------------------------------------------------------------------------
/src/Protocol/DeleteRecords/DeleteRecordsTopic.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace longlang\phpkafka\Protocol\DeleteRecords;
 6 | 
 7 | use longlang\phpkafka\Protocol\AbstractStruct;
 8 | use longlang\phpkafka\Protocol\ProtocolField;
 9 | 
10 | class DeleteRecordsTopic extends AbstractStruct
11 | {
12 |     /**
13 |      * The topic name.
14 |      *
15 |      * @var string
16 |      */
17 |     protected $name = '';
18 | 
19 |     /**
20 |      * Each partition that we want to delete records from.
21 |      *
22 |      * @var DeleteRecordsPartition[]
23 |      */
24 |     protected $partitions = [];
25 | 
26 |     public function __construct()
27 |     {
28 |         if (!isset(self::$maps[self::class])) {
29 |             self::$maps[self::class] = [
30 |                 new ProtocolField('name', 'string', false, [0, 1, 2], [2], [], [], null),
31 |                 new ProtocolField('partitions', DeleteRecordsPartition::class, true, [0, 1, 2], [2], [], [], null),
32 |             ];
33 |             self::$taggedFieldses[self::class] = [
34 |             ];
35 |         }
36 |     }
37 | 
38 |     public function getFlexibleVersions(): array
39 |     {
40 |         return [2];
41 |     }
42 | 
43 |     public function getName(): string
44 |     {
45 |         return $this->name;
46 |     }
47 | 
48 |     public function setName(string $name): self
49 |     {
50 |         $this->name = $name;
51 | 
52 |         return $this;
53 |     }
54 | 
55 |     /**
56 |      * @return DeleteRecordsPartition[]
57 |      */
58 |     public function getPartitions(): array
59 |     {
60 |         return $this->partitions;
61 |     }
62 | 
63 |     /**
64 |      * @param DeleteRecordsPartition[] $partitions
65 |      */
66 |     public function setPartitions(array $partitions): self
67 |     {
68 |         $this->partitions = $partitions;
69 | 
70 |         return $this;
71 |     }
72 | }
73 | 


--------------------------------------------------------------------------------
/src/Protocol/DeleteRecords/DeleteRecordsTopicResult.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace longlang\phpkafka\Protocol\DeleteRecords;
 6 | 
 7 | use longlang\phpkafka\Protocol\AbstractStruct;
 8 | use longlang\phpkafka\Protocol\ProtocolField;
 9 | 
10 | class DeleteRecordsTopicResult extends AbstractStruct
11 | {
12 |     /**
13 |      * The topic name.
14 |      *
15 |      * @var string
16 |      */
17 |     protected $name = '';
18 | 
19 |     /**
20 |      * Each partition that we wanted to delete records from.
21 |      *
22 |      * @var DeleteRecordsPartitionResult[]
23 |      */
24 |     protected $partitions = [];
25 | 
26 |     public function __construct()
27 |     {
28 |         if (!isset(self::$maps[self::class])) {
29 |             self::$maps[self::class] = [
30 |                 new ProtocolField('name', 'string', false, [0, 1, 2], [2], [], [], null),
31 |                 new ProtocolField('partitions', DeleteRecordsPartitionResult::class, true, [0, 1, 2], [2], [], [], null),
32 |             ];
33 |             self::$taggedFieldses[self::class] = [
34 |             ];
35 |         }
36 |     }
37 | 
38 |     public function getFlexibleVersions(): array
39 |     {
40 |         return [2];
41 |     }
42 | 
43 |     public function getName(): string
44 |     {
45 |         return $this->name;
46 |     }
47 | 
48 |     public function setName(string $name): self
49 |     {
50 |         $this->name = $name;
51 | 
52 |         return $this;
53 |     }
54 | 
55 |     /**
56 |      * @return DeleteRecordsPartitionResult[]
57 |      */
58 |     public function getPartitions(): array
59 |     {
60 |         return $this->partitions;
61 |     }
62 | 
63 |     /**
64 |      * @param DeleteRecordsPartitionResult[] $partitions
65 |      */
66 |     public function setPartitions(array $partitions): self
67 |     {
68 |         $this->partitions = $partitions;
69 | 
70 |         return $this;
71 |     }
72 | }
73 | 


--------------------------------------------------------------------------------
/src/Protocol/DeleteTopics/DeletableTopicResult.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace longlang\phpkafka\Protocol\DeleteTopics;
 6 | 
 7 | use longlang\phpkafka\Protocol\AbstractStruct;
 8 | use longlang\phpkafka\Protocol\ProtocolField;
 9 | 
10 | class DeletableTopicResult extends AbstractStruct
11 | {
12 |     /**
13 |      * The topic name.
14 |      *
15 |      * @var string
16 |      */
17 |     protected $name = '';
18 | 
19 |     /**
20 |      * The deletion error, or 0 if the deletion succeeded.
21 |      *
22 |      * @var int
23 |      */
24 |     protected $errorCode = 0;
25 | 
26 |     public function __construct()
27 |     {
28 |         if (!isset(self::$maps[self::class])) {
29 |             self::$maps[self::class] = [
30 |                 new ProtocolField('name', 'string', false, [0, 1, 2, 3, 4], [4], [], [], null),
31 |                 new ProtocolField('errorCode', 'int16', false, [0, 1, 2, 3, 4], [4], [], [], null),
32 |             ];
33 |             self::$taggedFieldses[self::class] = [
34 |             ];
35 |         }
36 |     }
37 | 
38 |     public function getFlexibleVersions(): array
39 |     {
40 |         return [4];
41 |     }
42 | 
43 |     public function getName(): string
44 |     {
45 |         return $this->name;
46 |     }
47 | 
48 |     public function setName(string $name): self
49 |     {
50 |         $this->name = $name;
51 | 
52 |         return $this;
53 |     }
54 | 
55 |     public function getErrorCode(): int
56 |     {
57 |         return $this->errorCode;
58 |     }
59 | 
60 |     public function setErrorCode(int $errorCode): self
61 |     {
62 |         $this->errorCode = $errorCode;
63 | 
64 |         return $this;
65 |     }
66 | }
67 | 


--------------------------------------------------------------------------------
/src/Protocol/DescribeClientQuotas/EntityData.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace longlang\phpkafka\Protocol\DescribeClientQuotas;
 6 | 
 7 | use longlang\phpkafka\Protocol\AbstractStruct;
 8 | use longlang\phpkafka\Protocol\ProtocolField;
 9 | 
10 | class EntityData extends AbstractStruct
11 | {
12 |     /**
13 |      * The entity type.
14 |      *
15 |      * @var string
16 |      */
17 |     protected $entityType = '';
18 | 
19 |     /**
20 |      * The entity name, or null if the default.
21 |      *
22 |      * @var string|null
23 |      */
24 |     protected $entityName = null;
25 | 
26 |     public function __construct()
27 |     {
28 |         if (!isset(self::$maps[self::class])) {
29 |             self::$maps[self::class] = [
30 |                 new ProtocolField('entityType', 'string', false, [0], [], [], [], null),
31 |                 new ProtocolField('entityName', 'string', false, [0], [], [0], [], null),
32 |             ];
33 |             self::$taggedFieldses[self::class] = [
34 |             ];
35 |         }
36 |     }
37 | 
38 |     public function getFlexibleVersions(): array
39 |     {
40 |         return [];
41 |     }
42 | 
43 |     public function getEntityType(): string
44 |     {
45 |         return $this->entityType;
46 |     }
47 | 
48 |     public function setEntityType(string $entityType): self
49 |     {
50 |         $this->entityType = $entityType;
51 | 
52 |         return $this;
53 |     }
54 | 
55 |     public function getEntityName(): ?string
56 |     {
57 |         return $this->entityName;
58 |     }
59 | 
60 |     public function setEntityName(?string $entityName): self
61 |     {
62 |         $this->entityName = $entityName;
63 | 
64 |         return $this;
65 |     }
66 | }
67 | 


--------------------------------------------------------------------------------
/src/Protocol/DescribeClientQuotas/EntryData.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace longlang\phpkafka\Protocol\DescribeClientQuotas;
 6 | 
 7 | use longlang\phpkafka\Protocol\AbstractStruct;
 8 | use longlang\phpkafka\Protocol\ProtocolField;
 9 | 
10 | class EntryData extends AbstractStruct
11 | {
12 |     /**
13 |      * The quota entity description.
14 |      *
15 |      * @var EntityData[]
16 |      */
17 |     protected $entity = [];
18 | 
19 |     /**
20 |      * The quota values for the entity.
21 |      *
22 |      * @var ValueData[]
23 |      */
24 |     protected $values = [];
25 | 
26 |     public function __construct()
27 |     {
28 |         if (!isset(self::$maps[self::class])) {
29 |             self::$maps[self::class] = [
30 |                 new ProtocolField('entity', EntityData::class, true, [0], [], [], [], null),
31 |                 new ProtocolField('values', ValueData::class, true, [0], [], [], [], null),
32 |             ];
33 |             self::$taggedFieldses[self::class] = [
34 |             ];
35 |         }
36 |     }
37 | 
38 |     public function getFlexibleVersions(): array
39 |     {
40 |         return [];
41 |     }
42 | 
43 |     /**
44 |      * @return EntityData[]
45 |      */
46 |     public function getEntity(): array
47 |     {
48 |         return $this->entity;
49 |     }
50 | 
51 |     /**
52 |      * @param EntityData[] $entity
53 |      */
54 |     public function setEntity(array $entity): self
55 |     {
56 |         $this->entity = $entity;
57 | 
58 |         return $this;
59 |     }
60 | 
61 |     /**
62 |      * @return ValueData[]
63 |      */
64 |     public function getValues(): array
65 |     {
66 |         return $this->values;
67 |     }
68 | 
69 |     /**
70 |      * @param ValueData[] $values
71 |      */
72 |     public function setValues(array $values): self
73 |     {
74 |         $this->values = $values;
75 | 
76 |         return $this;
77 |     }
78 | }
79 | 


--------------------------------------------------------------------------------
/src/Protocol/DescribeClientQuotas/ValueData.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace longlang\phpkafka\Protocol\DescribeClientQuotas;
 6 | 
 7 | use longlang\phpkafka\Protocol\AbstractStruct;
 8 | use longlang\phpkafka\Protocol\ProtocolField;
 9 | 
10 | class ValueData extends AbstractStruct
11 | {
12 |     /**
13 |      * The quota configuration key.
14 |      *
15 |      * @var string
16 |      */
17 |     protected $key = '';
18 | 
19 |     /**
20 |      * The quota configuration value.
21 |      *
22 |      * @var float
23 |      */
24 |     protected $value = 0;
25 | 
26 |     public function __construct()
27 |     {
28 |         if (!isset(self::$maps[self::class])) {
29 |             self::$maps[self::class] = [
30 |                 new ProtocolField('key', 'string', false, [0], [], [], [], null),
31 |                 new ProtocolField('value', 'float64', false, [0], [], [], [], null),
32 |             ];
33 |             self::$taggedFieldses[self::class] = [
34 |             ];
35 |         }
36 |     }
37 | 
38 |     public function getFlexibleVersions(): array
39 |     {
40 |         return [];
41 |     }
42 | 
43 |     public function getKey(): string
44 |     {
45 |         return $this->key;
46 |     }
47 | 
48 |     public function setKey(string $key): self
49 |     {
50 |         $this->key = $key;
51 | 
52 |         return $this;
53 |     }
54 | 
55 |     public function getValue(): float
56 |     {
57 |         return $this->value;
58 |     }
59 | 
60 |     public function setValue(float $value): self
61 |     {
62 |         $this->value = $value;
63 | 
64 |         return $this;
65 |     }
66 | }
67 | 


--------------------------------------------------------------------------------
/src/Protocol/DescribeDelegationToken/DescribeDelegationTokenOwner.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace longlang\phpkafka\Protocol\DescribeDelegationToken;
 6 | 
 7 | use longlang\phpkafka\Protocol\AbstractStruct;
 8 | use longlang\phpkafka\Protocol\ProtocolField;
 9 | 
10 | class DescribeDelegationTokenOwner extends AbstractStruct
11 | {
12 |     /**
13 |      * The owner principal type.
14 |      *
15 |      * @var string
16 |      */
17 |     protected $principalType = '';
18 | 
19 |     /**
20 |      * The owner principal name.
21 |      *
22 |      * @var string
23 |      */
24 |     protected $principalName = '';
25 | 
26 |     public function __construct()
27 |     {
28 |         if (!isset(self::$maps[self::class])) {
29 |             self::$maps[self::class] = [
30 |                 new ProtocolField('principalType', 'string', false, [0, 1, 2], [2], [], [], null),
31 |                 new ProtocolField('principalName', 'string', false, [0, 1, 2], [2], [], [], null),
32 |             ];
33 |             self::$taggedFieldses[self::class] = [
34 |             ];
35 |         }
36 |     }
37 | 
38 |     public function getFlexibleVersions(): array
39 |     {
40 |         return [2];
41 |     }
42 | 
43 |     public function getPrincipalType(): string
44 |     {
45 |         return $this->principalType;
46 |     }
47 | 
48 |     public function setPrincipalType(string $principalType): self
49 |     {
50 |         $this->principalType = $principalType;
51 | 
52 |         return $this;
53 |     }
54 | 
55 |     public function getPrincipalName(): string
56 |     {
57 |         return $this->principalName;
58 |     }
59 | 
60 |     public function setPrincipalName(string $principalName): self
61 |     {
62 |         $this->principalName = $principalName;
63 | 
64 |         return $this;
65 |     }
66 | }
67 | 


--------------------------------------------------------------------------------
/src/Protocol/DescribeDelegationToken/DescribeDelegationTokenRequest.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace longlang\phpkafka\Protocol\DescribeDelegationToken;
 6 | 
 7 | use longlang\phpkafka\Protocol\AbstractRequest;
 8 | use longlang\phpkafka\Protocol\ProtocolField;
 9 | 
10 | class DescribeDelegationTokenRequest extends AbstractRequest
11 | {
12 |     /**
13 |      * Each owner that we want to describe delegation tokens for, or null to describe all tokens.
14 |      *
15 |      * @var DescribeDelegationTokenOwner[]|null
16 |      */
17 |     protected $owners = null;
18 | 
19 |     public function __construct()
20 |     {
21 |         if (!isset(self::$maps[self::class])) {
22 |             self::$maps[self::class] = [
23 |                 new ProtocolField('owners', DescribeDelegationTokenOwner::class, true, [0, 1, 2], [2], [0, 1, 2], [], null),
24 |             ];
25 |             self::$taggedFieldses[self::class] = [
26 |             ];
27 |         }
28 |     }
29 | 
30 |     public function getRequestApiKey(): ?int
31 |     {
32 |         return 41;
33 |     }
34 | 
35 |     public function getMaxSupportedVersion(): int
36 |     {
37 |         return 2;
38 |     }
39 | 
40 |     public function getFlexibleVersions(): array
41 |     {
42 |         return [2];
43 |     }
44 | 
45 |     /**
46 |      * @return DescribeDelegationTokenOwner[]|null
47 |      */
48 |     public function getOwners(): ?array
49 |     {
50 |         return $this->owners;
51 |     }
52 | 
53 |     /**
54 |      * @param DescribeDelegationTokenOwner[]|null $owners
55 |      */
56 |     public function setOwners(?array $owners): self
57 |     {
58 |         $this->owners = $owners;
59 | 
60 |         return $this;
61 |     }
62 | }
63 | 


--------------------------------------------------------------------------------
/src/Protocol/DescribeDelegationToken/DescribedDelegationTokenRenewer.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace longlang\phpkafka\Protocol\DescribeDelegationToken;
 6 | 
 7 | use longlang\phpkafka\Protocol\AbstractStruct;
 8 | use longlang\phpkafka\Protocol\ProtocolField;
 9 | 
10 | class DescribedDelegationTokenRenewer extends AbstractStruct
11 | {
12 |     /**
13 |      * The renewer principal type.
14 |      *
15 |      * @var string
16 |      */
17 |     protected $principalType = '';
18 | 
19 |     /**
20 |      * The renewer principal name.
21 |      *
22 |      * @var string
23 |      */
24 |     protected $principalName = '';
25 | 
26 |     public function __construct()
27 |     {
28 |         if (!isset(self::$maps[self::class])) {
29 |             self::$maps[self::class] = [
30 |                 new ProtocolField('principalType', 'string', false, [0, 1, 2], [2], [], [], null),
31 |                 new ProtocolField('principalName', 'string', false, [0, 1, 2], [2], [], [], null),
32 |             ];
33 |             self::$taggedFieldses[self::class] = [
34 |             ];
35 |         }
36 |     }
37 | 
38 |     public function getFlexibleVersions(): array
39 |     {
40 |         return [2];
41 |     }
42 | 
43 |     public function getPrincipalType(): string
44 |     {
45 |         return $this->principalType;
46 |     }
47 | 
48 |     public function setPrincipalType(string $principalType): self
49 |     {
50 |         $this->principalType = $principalType;
51 | 
52 |         return $this;
53 |     }
54 | 
55 |     public function getPrincipalName(): string
56 |     {
57 |         return $this->principalName;
58 |     }
59 | 
60 |     public function setPrincipalName(string $principalName): self
61 |     {
62 |         $this->principalName = $principalName;
63 | 
64 |         return $this;
65 |     }
66 | }
67 | 


--------------------------------------------------------------------------------
/src/Protocol/DescribeLogDirs/DescribableLogDirTopic.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace longlang\phpkafka\Protocol\DescribeLogDirs;
 6 | 
 7 | use longlang\phpkafka\Protocol\AbstractStruct;
 8 | use longlang\phpkafka\Protocol\ProtocolField;
 9 | 
10 | class DescribableLogDirTopic extends AbstractStruct
11 | {
12 |     /**
13 |      * The topic name.
14 |      *
15 |      * @var string
16 |      */
17 |     protected $topic = '';
18 | 
19 |     /**
20 |      * The partition indxes.
21 |      *
22 |      * @var int[]
23 |      */
24 |     protected $partitionIndex = [];
25 | 
26 |     public function __construct()
27 |     {
28 |         if (!isset(self::$maps[self::class])) {
29 |             self::$maps[self::class] = [
30 |                 new ProtocolField('topic', 'string', false, [0, 1, 2], [2], [], [], null),
31 |                 new ProtocolField('partitionIndex', 'int32', true, [0, 1, 2], [2], [], [], null),
32 |             ];
33 |             self::$taggedFieldses[self::class] = [
34 |             ];
35 |         }
36 |     }
37 | 
38 |     public function getFlexibleVersions(): array
39 |     {
40 |         return [2];
41 |     }
42 | 
43 |     public function getTopic(): string
44 |     {
45 |         return $this->topic;
46 |     }
47 | 
48 |     public function setTopic(string $topic): self
49 |     {
50 |         $this->topic = $topic;
51 | 
52 |         return $this;
53 |     }
54 | 
55 |     /**
56 |      * @return int[]
57 |      */
58 |     public function getPartitionIndex(): array
59 |     {
60 |         return $this->partitionIndex;
61 |     }
62 | 
63 |     /**
64 |      * @param int[] $partitionIndex
65 |      */
66 |     public function setPartitionIndex(array $partitionIndex): self
67 |     {
68 |         $this->partitionIndex = $partitionIndex;
69 | 
70 |         return $this;
71 |     }
72 | }
73 | 


--------------------------------------------------------------------------------
/src/Protocol/DescribeLogDirs/DescribeLogDirsRequest.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace longlang\phpkafka\Protocol\DescribeLogDirs;
 6 | 
 7 | use longlang\phpkafka\Protocol\AbstractRequest;
 8 | use longlang\phpkafka\Protocol\ProtocolField;
 9 | 
10 | class DescribeLogDirsRequest extends AbstractRequest
11 | {
12 |     /**
13 |      * Each topic that we want to describe log directories for, or null for all topics.
14 |      *
15 |      * @var DescribableLogDirTopic[]|null
16 |      */
17 |     protected $topics = null;
18 | 
19 |     public function __construct()
20 |     {
21 |         if (!isset(self::$maps[self::class])) {
22 |             self::$maps[self::class] = [
23 |                 new ProtocolField('topics', DescribableLogDirTopic::class, true, [0, 1, 2], [2], [0, 1, 2], [], null),
24 |             ];
25 |             self::$taggedFieldses[self::class] = [
26 |             ];
27 |         }
28 |     }
29 | 
30 |     public function getRequestApiKey(): ?int
31 |     {
32 |         return 35;
33 |     }
34 | 
35 |     public function getMaxSupportedVersion(): int
36 |     {
37 |         return 2;
38 |     }
39 | 
40 |     public function getFlexibleVersions(): array
41 |     {
42 |         return [2];
43 |     }
44 | 
45 |     /**
46 |      * @return DescribableLogDirTopic[]|null
47 |      */
48 |     public function getTopics(): ?array
49 |     {
50 |         return $this->topics;
51 |     }
52 | 
53 |     /**
54 |      * @param DescribableLogDirTopic[]|null $topics
55 |      */
56 |     public function setTopics(?array $topics): self
57 |     {
58 |         $this->topics = $topics;
59 | 
60 |         return $this;
61 |     }
62 | }
63 | 


--------------------------------------------------------------------------------
/src/Protocol/DescribeLogDirs/DescribeLogDirsTopic.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace longlang\phpkafka\Protocol\DescribeLogDirs;
 6 | 
 7 | use longlang\phpkafka\Protocol\AbstractStruct;
 8 | use longlang\phpkafka\Protocol\ProtocolField;
 9 | 
10 | class DescribeLogDirsTopic extends AbstractStruct
11 | {
12 |     /**
13 |      * The topic name.
14 |      *
15 |      * @var string
16 |      */
17 |     protected $name = '';
18 | 
19 |     /**
20 |      * @var DescribeLogDirsPartition[]
21 |      */
22 |     protected $partitions = [];
23 | 
24 |     public function __construct()
25 |     {
26 |         if (!isset(self::$maps[self::class])) {
27 |             self::$maps[self::class] = [
28 |                 new ProtocolField('name', 'string', false, [0, 1, 2], [2], [], [], null),
29 |                 new ProtocolField('partitions', DescribeLogDirsPartition::class, true, [0, 1, 2], [2], [], [], null),
30 |             ];
31 |             self::$taggedFieldses[self::class] = [
32 |             ];
33 |         }
34 |     }
35 | 
36 |     public function getFlexibleVersions(): array
37 |     {
38 |         return [2];
39 |     }
40 | 
41 |     public function getName(): string
42 |     {
43 |         return $this->name;
44 |     }
45 | 
46 |     public function setName(string $name): self
47 |     {
48 |         $this->name = $name;
49 | 
50 |         return $this;
51 |     }
52 | 
53 |     /**
54 |      * @return DescribeLogDirsPartition[]
55 |      */
56 |     public function getPartitions(): array
57 |     {
58 |         return $this->partitions;
59 |     }
60 | 
61 |     /**
62 |      * @param DescribeLogDirsPartition[] $partitions
63 |      */
64 |     public function setPartitions(array $partitions): self
65 |     {
66 |         $this->partitions = $partitions;
67 | 
68 |         return $this;
69 |     }
70 | }
71 | 


--------------------------------------------------------------------------------
/src/Protocol/ElectLeaders/ReplicaElectionResult.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace longlang\phpkafka\Protocol\ElectLeaders;
 6 | 
 7 | use longlang\phpkafka\Protocol\AbstractStruct;
 8 | use longlang\phpkafka\Protocol\ProtocolField;
 9 | 
10 | class ReplicaElectionResult extends AbstractStruct
11 | {
12 |     /**
13 |      * The topic name.
14 |      *
15 |      * @var string
16 |      */
17 |     protected $topic = '';
18 | 
19 |     /**
20 |      * The results for each partition.
21 |      *
22 |      * @var PartitionResult[]
23 |      */
24 |     protected $partitionResult = [];
25 | 
26 |     public function __construct()
27 |     {
28 |         if (!isset(self::$maps[self::class])) {
29 |             self::$maps[self::class] = [
30 |                 new ProtocolField('topic', 'string', false, [0, 1, 2], [2], [], [], null),
31 |                 new ProtocolField('partitionResult', PartitionResult::class, true, [0, 1, 2], [2], [], [], null),
32 |             ];
33 |             self::$taggedFieldses[self::class] = [
34 |             ];
35 |         }
36 |     }
37 | 
38 |     public function getFlexibleVersions(): array
39 |     {
40 |         return [2];
41 |     }
42 | 
43 |     public function getTopic(): string
44 |     {
45 |         return $this->topic;
46 |     }
47 | 
48 |     public function setTopic(string $topic): self
49 |     {
50 |         $this->topic = $topic;
51 | 
52 |         return $this;
53 |     }
54 | 
55 |     /**
56 |      * @return PartitionResult[]
57 |      */
58 |     public function getPartitionResult(): array
59 |     {
60 |         return $this->partitionResult;
61 |     }
62 | 
63 |     /**
64 |      * @param PartitionResult[] $partitionResult
65 |      */
66 |     public function setPartitionResult(array $partitionResult): self
67 |     {
68 |         $this->partitionResult = $partitionResult;
69 | 
70 |         return $this;
71 |     }
72 | }
73 | 


--------------------------------------------------------------------------------
/src/Protocol/ElectLeaders/TopicPartitions.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace longlang\phpkafka\Protocol\ElectLeaders;
 6 | 
 7 | use longlang\phpkafka\Protocol\AbstractStruct;
 8 | use longlang\phpkafka\Protocol\ProtocolField;
 9 | 
10 | class TopicPartitions extends AbstractStruct
11 | {
12 |     /**
13 |      * The name of a topic.
14 |      *
15 |      * @var string
16 |      */
17 |     protected $topic = '';
18 | 
19 |     /**
20 |      * The partitions of this topic whose leader should be elected.
21 |      *
22 |      * @var int[]
23 |      */
24 |     protected $partitionId = [];
25 | 
26 |     public function __construct()
27 |     {
28 |         if (!isset(self::$maps[self::class])) {
29 |             self::$maps[self::class] = [
30 |                 new ProtocolField('topic', 'string', false, [0, 1, 2], [2], [], [], null),
31 |                 new ProtocolField('partitionId', 'int32', true, [0, 1, 2], [2], [], [], null),
32 |             ];
33 |             self::$taggedFieldses[self::class] = [
34 |             ];
35 |         }
36 |     }
37 | 
38 |     public function getFlexibleVersions(): array
39 |     {
40 |         return [2];
41 |     }
42 | 
43 |     public function getTopic(): string
44 |     {
45 |         return $this->topic;
46 |     }
47 | 
48 |     public function setTopic(string $topic): self
49 |     {
50 |         $this->topic = $topic;
51 | 
52 |         return $this;
53 |     }
54 | 
55 |     /**
56 |      * @return int[]
57 |      */
58 |     public function getPartitionId(): array
59 |     {
60 |         return $this->partitionId;
61 |     }
62 | 
63 |     /**
64 |      * @param int[] $partitionId
65 |      */
66 |     public function setPartitionId(array $partitionId): self
67 |     {
68 |         $this->partitionId = $partitionId;
69 | 
70 |         return $this;
71 |     }
72 | }
73 | 


--------------------------------------------------------------------------------
/src/Protocol/EndTxn/EndTxnResponse.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace longlang\phpkafka\Protocol\EndTxn;
 6 | 
 7 | use longlang\phpkafka\Protocol\AbstractResponse;
 8 | use longlang\phpkafka\Protocol\ProtocolField;
 9 | 
10 | class EndTxnResponse extends AbstractResponse
11 | {
12 |     /**
13 |      * The duration in milliseconds for which the request was throttled due to a quota violation, or zero if the request did not violate any quota.
14 |      *
15 |      * @var int
16 |      */
17 |     protected $throttleTimeMs = 0;
18 | 
19 |     /**
20 |      * The error code, or 0 if there was no error.
21 |      *
22 |      * @var int
23 |      */
24 |     protected $errorCode = 0;
25 | 
26 |     public function __construct()
27 |     {
28 |         if (!isset(self::$maps[self::class])) {
29 |             self::$maps[self::class] = [
30 |                 new ProtocolField('throttleTimeMs', 'int32', false, [0, 1], [], [], [], null),
31 |                 new ProtocolField('errorCode', 'int16', false, [0, 1], [], [], [], null),
32 |             ];
33 |             self::$taggedFieldses[self::class] = [
34 |             ];
35 |         }
36 |     }
37 | 
38 |     public function getRequestApiKey(): ?int
39 |     {
40 |         return 26;
41 |     }
42 | 
43 |     public function getFlexibleVersions(): array
44 |     {
45 |         return [];
46 |     }
47 | 
48 |     public function getThrottleTimeMs(): int
49 |     {
50 |         return $this->throttleTimeMs;
51 |     }
52 | 
53 |     public function setThrottleTimeMs(int $throttleTimeMs): self
54 |     {
55 |         $this->throttleTimeMs = $throttleTimeMs;
56 | 
57 |         return $this;
58 |     }
59 | 
60 |     public function getErrorCode(): int
61 |     {
62 |         return $this->errorCode;
63 |     }
64 | 
65 |     public function setErrorCode(int $errorCode): self
66 |     {
67 |         $this->errorCode = $errorCode;
68 | 
69 |         return $this;
70 |     }
71 | }
72 | 


--------------------------------------------------------------------------------
/src/Protocol/ExpireDelegationToken/ExpireDelegationTokenRequest.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace longlang\phpkafka\Protocol\ExpireDelegationToken;
 6 | 
 7 | use longlang\phpkafka\Protocol\AbstractRequest;
 8 | use longlang\phpkafka\Protocol\ProtocolField;
 9 | 
10 | class ExpireDelegationTokenRequest extends AbstractRequest
11 | {
12 |     /**
13 |      * The HMAC of the delegation token to be expired.
14 |      *
15 |      * @var string
16 |      */
17 |     protected $hmac = '';
18 | 
19 |     /**
20 |      * The expiry time period in milliseconds.
21 |      *
22 |      * @var int
23 |      */
24 |     protected $expiryTimePeriodMs = 0;
25 | 
26 |     public function __construct()
27 |     {
28 |         if (!isset(self::$maps[self::class])) {
29 |             self::$maps[self::class] = [
30 |                 new ProtocolField('hmac', 'bytes', false, [0, 1, 2], [2], [], [], null),
31 |                 new ProtocolField('expiryTimePeriodMs', 'int64', false, [0, 1, 2], [2], [], [], null),
32 |             ];
33 |             self::$taggedFieldses[self::class] = [
34 |             ];
35 |         }
36 |     }
37 | 
38 |     public function getRequestApiKey(): ?int
39 |     {
40 |         return 40;
41 |     }
42 | 
43 |     public function getMaxSupportedVersion(): int
44 |     {
45 |         return 2;
46 |     }
47 | 
48 |     public function getFlexibleVersions(): array
49 |     {
50 |         return [2];
51 |     }
52 | 
53 |     public function getHmac(): string
54 |     {
55 |         return $this->hmac;
56 |     }
57 | 
58 |     public function setHmac(string $hmac): self
59 |     {
60 |         $this->hmac = $hmac;
61 | 
62 |         return $this;
63 |     }
64 | 
65 |     public function getExpiryTimePeriodMs(): int
66 |     {
67 |         return $this->expiryTimePeriodMs;
68 |     }
69 | 
70 |     public function setExpiryTimePeriodMs(int $expiryTimePeriodMs): self
71 |     {
72 |         $this->expiryTimePeriodMs = $expiryTimePeriodMs;
73 | 
74 |         return $this;
75 |     }
76 | }
77 | 


--------------------------------------------------------------------------------
/src/Protocol/Fetch/AbortedTransaction.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace longlang\phpkafka\Protocol\Fetch;
 6 | 
 7 | use longlang\phpkafka\Protocol\AbstractStruct;
 8 | use longlang\phpkafka\Protocol\ProtocolField;
 9 | 
10 | class AbortedTransaction extends AbstractStruct
11 | {
12 |     /**
13 |      * The producer id associated with the aborted transaction.
14 |      *
15 |      * @var int
16 |      */
17 |     protected $producerId = 0;
18 | 
19 |     /**
20 |      * The first offset in the aborted transaction.
21 |      *
22 |      * @var int
23 |      */
24 |     protected $firstOffset = 0;
25 | 
26 |     public function __construct()
27 |     {
28 |         if (!isset(self::$maps[self::class])) {
29 |             self::$maps[self::class] = [
30 |                 new ProtocolField('producerId', 'int64', false, [4, 5, 6, 7, 8, 9, 10, 11], [], [], [], null),
31 |                 new ProtocolField('firstOffset', 'int64', false, [4, 5, 6, 7, 8, 9, 10, 11], [], [], [], null),
32 |             ];
33 |             self::$taggedFieldses[self::class] = [
34 |             ];
35 |         }
36 |     }
37 | 
38 |     public function getFlexibleVersions(): array
39 |     {
40 |         return [];
41 |     }
42 | 
43 |     public function getProducerId(): int
44 |     {
45 |         return $this->producerId;
46 |     }
47 | 
48 |     public function setProducerId(int $producerId): self
49 |     {
50 |         $this->producerId = $producerId;
51 | 
52 |         return $this;
53 |     }
54 | 
55 |     public function getFirstOffset(): int
56 |     {
57 |         return $this->firstOffset;
58 |     }
59 | 
60 |     public function setFirstOffset(int $firstOffset): self
61 |     {
62 |         $this->firstOffset = $firstOffset;
63 | 
64 |         return $this;
65 |     }
66 | }
67 | 


--------------------------------------------------------------------------------
/src/Protocol/Fetch/FetchableTopic.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace longlang\phpkafka\Protocol\Fetch;
 6 | 
 7 | use longlang\phpkafka\Protocol\AbstractStruct;
 8 | use longlang\phpkafka\Protocol\ProtocolField;
 9 | 
10 | class FetchableTopic extends AbstractStruct
11 | {
12 |     /**
13 |      * The name of the topic to fetch.
14 |      *
15 |      * @var string
16 |      */
17 |     protected $name = '';
18 | 
19 |     /**
20 |      * The partitions to fetch.
21 |      *
22 |      * @var FetchPartition[]
23 |      */
24 |     protected $fetchPartitions = [];
25 | 
26 |     public function __construct()
27 |     {
28 |         if (!isset(self::$maps[self::class])) {
29 |             self::$maps[self::class] = [
30 |                 new ProtocolField('name', 'string', false, [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11], [], [], [], null),
31 |                 new ProtocolField('fetchPartitions', FetchPartition::class, true, [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11], [], [], [], null),
32 |             ];
33 |             self::$taggedFieldses[self::class] = [
34 |             ];
35 |         }
36 |     }
37 | 
38 |     public function getFlexibleVersions(): array
39 |     {
40 |         return [];
41 |     }
42 | 
43 |     public function getName(): string
44 |     {
45 |         return $this->name;
46 |     }
47 | 
48 |     public function setName(string $name): self
49 |     {
50 |         $this->name = $name;
51 | 
52 |         return $this;
53 |     }
54 | 
55 |     /**
56 |      * @return FetchPartition[]
57 |      */
58 |     public function getFetchPartitions(): array
59 |     {
60 |         return $this->fetchPartitions;
61 |     }
62 | 
63 |     /**
64 |      * @param FetchPartition[] $fetchPartitions
65 |      */
66 |     public function setFetchPartitions(array $fetchPartitions): self
67 |     {
68 |         $this->fetchPartitions = $fetchPartitions;
69 | 
70 |         return $this;
71 |     }
72 | }
73 | 


--------------------------------------------------------------------------------
/src/Protocol/Fetch/FetchableTopicResponse.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace longlang\phpkafka\Protocol\Fetch;
 6 | 
 7 | use longlang\phpkafka\Protocol\AbstractStruct;
 8 | use longlang\phpkafka\Protocol\ProtocolField;
 9 | 
10 | class FetchableTopicResponse extends AbstractStruct
11 | {
12 |     /**
13 |      * The topic name.
14 |      *
15 |      * @var string
16 |      */
17 |     protected $name = '';
18 | 
19 |     /**
20 |      * The topic partitions.
21 |      *
22 |      * @var FetchablePartitionResponse[]
23 |      */
24 |     protected $partitions = [];
25 | 
26 |     public function __construct()
27 |     {
28 |         if (!isset(self::$maps[self::class])) {
29 |             self::$maps[self::class] = [
30 |                 new ProtocolField('name', 'string', false, [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11], [], [], [], null),
31 |                 new ProtocolField('partitions', FetchablePartitionResponse::class, true, [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11], [], [], [], null),
32 |             ];
33 |             self::$taggedFieldses[self::class] = [
34 |             ];
35 |         }
36 |     }
37 | 
38 |     public function getFlexibleVersions(): array
39 |     {
40 |         return [];
41 |     }
42 | 
43 |     public function getName(): string
44 |     {
45 |         return $this->name;
46 |     }
47 | 
48 |     public function setName(string $name): self
49 |     {
50 |         $this->name = $name;
51 | 
52 |         return $this;
53 |     }
54 | 
55 |     /**
56 |      * @return FetchablePartitionResponse[]
57 |      */
58 |     public function getPartitions(): array
59 |     {
60 |         return $this->partitions;
61 |     }
62 | 
63 |     /**
64 |      * @param FetchablePartitionResponse[] $partitions
65 |      */
66 |     public function setPartitions(array $partitions): self
67 |     {
68 |         $this->partitions = $partitions;
69 | 
70 |         return $this;
71 |     }
72 | }
73 | 


--------------------------------------------------------------------------------
/src/Protocol/Fetch/ForgottenTopic.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace longlang\phpkafka\Protocol\Fetch;
 6 | 
 7 | use longlang\phpkafka\Protocol\AbstractStruct;
 8 | use longlang\phpkafka\Protocol\ProtocolField;
 9 | 
10 | class ForgottenTopic extends AbstractStruct
11 | {
12 |     /**
13 |      * The partition name.
14 |      *
15 |      * @var string
16 |      */
17 |     protected $name = '';
18 | 
19 |     /**
20 |      * The partitions indexes to forget.
21 |      *
22 |      * @var int[]
23 |      */
24 |     protected $forgottenPartitionIndexes = [];
25 | 
26 |     public function __construct()
27 |     {
28 |         if (!isset(self::$maps[self::class])) {
29 |             self::$maps[self::class] = [
30 |                 new ProtocolField('name', 'string', false, [7, 8, 9, 10, 11], [], [], [], null),
31 |                 new ProtocolField('forgottenPartitionIndexes', 'int32', true, [7, 8, 9, 10, 11], [], [], [], null),
32 |             ];
33 |             self::$taggedFieldses[self::class] = [
34 |             ];
35 |         }
36 |     }
37 | 
38 |     public function getFlexibleVersions(): array
39 |     {
40 |         return [];
41 |     }
42 | 
43 |     public function getName(): string
44 |     {
45 |         return $this->name;
46 |     }
47 | 
48 |     public function setName(string $name): self
49 |     {
50 |         $this->name = $name;
51 | 
52 |         return $this;
53 |     }
54 | 
55 |     /**
56 |      * @return int[]
57 |      */
58 |     public function getForgottenPartitionIndexes(): array
59 |     {
60 |         return $this->forgottenPartitionIndexes;
61 |     }
62 | 
63 |     /**
64 |      * @param int[] $forgottenPartitionIndexes
65 |      */
66 |     public function setForgottenPartitionIndexes(array $forgottenPartitionIndexes): self
67 |     {
68 |         $this->forgottenPartitionIndexes = $forgottenPartitionIndexes;
69 | 
70 |         return $this;
71 |     }
72 | }
73 | 


--------------------------------------------------------------------------------
/src/Protocol/FindCoordinator/FindCoordinatorRequest.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace longlang\phpkafka\Protocol\FindCoordinator;
 6 | 
 7 | use longlang\phpkafka\Protocol\AbstractRequest;
 8 | use longlang\phpkafka\Protocol\ProtocolField;
 9 | 
10 | class FindCoordinatorRequest extends AbstractRequest
11 | {
12 |     /**
13 |      * The coordinator key.
14 |      *
15 |      * @var string
16 |      */
17 |     protected $key = '';
18 | 
19 |     /**
20 |      * The coordinator key type.  (Group, transaction, etc.).
21 |      *
22 |      * @var int
23 |      */
24 |     protected $keyType = 0;
25 | 
26 |     public function __construct()
27 |     {
28 |         if (!isset(self::$maps[self::class])) {
29 |             self::$maps[self::class] = [
30 |                 new ProtocolField('key', 'string', false, [0, 1, 2, 3], [3], [], [], null),
31 |                 new ProtocolField('keyType', 'int8', false, [1, 2, 3], [3], [], [], null),
32 |             ];
33 |             self::$taggedFieldses[self::class] = [
34 |             ];
35 |         }
36 |     }
37 | 
38 |     public function getRequestApiKey(): ?int
39 |     {
40 |         return 10;
41 |     }
42 | 
43 |     public function getMaxSupportedVersion(): int
44 |     {
45 |         return 3;
46 |     }
47 | 
48 |     public function getFlexibleVersions(): array
49 |     {
50 |         return [3];
51 |     }
52 | 
53 |     public function getKey(): string
54 |     {
55 |         return $this->key;
56 |     }
57 | 
58 |     public function setKey(string $key): self
59 |     {
60 |         $this->key = $key;
61 | 
62 |         return $this;
63 |     }
64 | 
65 |     public function getKeyType(): int
66 |     {
67 |         return $this->keyType;
68 |     }
69 | 
70 |     public function setKeyType(int $keyType): self
71 |     {
72 |         $this->keyType = $keyType;
73 | 
74 |         return $this;
75 |     }
76 | }
77 | 


--------------------------------------------------------------------------------
/src/Protocol/Heartbeat/HeartbeatResponse.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace longlang\phpkafka\Protocol\Heartbeat;
 6 | 
 7 | use longlang\phpkafka\Protocol\AbstractResponse;
 8 | use longlang\phpkafka\Protocol\ProtocolField;
 9 | 
10 | class HeartbeatResponse extends AbstractResponse
11 | {
12 |     /**
13 |      * The duration in milliseconds for which the request was throttled due to a quota violation, or zero if the request did not violate any quota.
14 |      *
15 |      * @var int
16 |      */
17 |     protected $throttleTimeMs = 0;
18 | 
19 |     /**
20 |      * The error code, or 0 if there was no error.
21 |      *
22 |      * @var int
23 |      */
24 |     protected $errorCode = 0;
25 | 
26 |     public function __construct()
27 |     {
28 |         if (!isset(self::$maps[self::class])) {
29 |             self::$maps[self::class] = [
30 |                 new ProtocolField('throttleTimeMs', 'int32', false, [1, 2, 3, 4], [4], [], [], null),
31 |                 new ProtocolField('errorCode', 'int16', false, [0, 1, 2, 3, 4], [4], [], [], null),
32 |             ];
33 |             self::$taggedFieldses[self::class] = [
34 |             ];
35 |         }
36 |     }
37 | 
38 |     public function getRequestApiKey(): ?int
39 |     {
40 |         return 12;
41 |     }
42 | 
43 |     public function getFlexibleVersions(): array
44 |     {
45 |         return [4];
46 |     }
47 | 
48 |     public function getThrottleTimeMs(): int
49 |     {
50 |         return $this->throttleTimeMs;
51 |     }
52 | 
53 |     public function setThrottleTimeMs(int $throttleTimeMs): self
54 |     {
55 |         $this->throttleTimeMs = $throttleTimeMs;
56 | 
57 |         return $this;
58 |     }
59 | 
60 |     public function getErrorCode(): int
61 |     {
62 |         return $this->errorCode;
63 |     }
64 | 
65 |     public function setErrorCode(int $errorCode): self
66 |     {
67 |         $this->errorCode = $errorCode;
68 | 
69 |         return $this;
70 |     }
71 | }
72 | 


--------------------------------------------------------------------------------
/src/Protocol/JoinGroup/JoinGroupRequestProtocol.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace longlang\phpkafka\Protocol\JoinGroup;
 6 | 
 7 | use longlang\phpkafka\Protocol\AbstractStruct;
 8 | use longlang\phpkafka\Protocol\ProtocolField;
 9 | 
10 | class JoinGroupRequestProtocol extends AbstractStruct
11 | {
12 |     /**
13 |      * The protocol name.
14 |      *
15 |      * @var string
16 |      */
17 |     protected $name = '';
18 | 
19 |     /**
20 |      * The protocol metadata.
21 |      *
22 |      * @var string
23 |      */
24 |     protected $metadata = '';
25 | 
26 |     public function __construct()
27 |     {
28 |         if (!isset(self::$maps[self::class])) {
29 |             self::$maps[self::class] = [
30 |                 new ProtocolField('name', 'string', false, [0, 1, 2, 3, 4, 5, 6, 7], [6, 7], [], [], null),
31 |                 new ProtocolField('metadata', 'bytes', false, [0, 1, 2, 3, 4, 5, 6, 7], [6, 7], [], [], null),
32 |             ];
33 |             self::$taggedFieldses[self::class] = [
34 |             ];
35 |         }
36 |     }
37 | 
38 |     public function getFlexibleVersions(): array
39 |     {
40 |         return [6, 7];
41 |     }
42 | 
43 |     public function getName(): string
44 |     {
45 |         return $this->name;
46 |     }
47 | 
48 |     public function setName(string $name): self
49 |     {
50 |         $this->name = $name;
51 | 
52 |         return $this;
53 |     }
54 | 
55 |     public function getMetadata(): string
56 |     {
57 |         return $this->metadata;
58 |     }
59 | 
60 |     public function setMetadata(string $metadata): self
61 |     {
62 |         $this->metadata = $metadata;
63 | 
64 |         return $this;
65 |     }
66 | }
67 | 


--------------------------------------------------------------------------------
/src/Protocol/KafkaRequest.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace longlang\phpkafka\Protocol;
 6 | 
 7 | use longlang\phpkafka\Protocol\RequestHeader\RequestHeader;
 8 | use longlang\phpkafka\Protocol\Type\Int32;
 9 | 
10 | class KafkaRequest
11 | {
12 |     /**
13 |      * @var int
14 |      */
15 |     protected $size;
16 | 
17 |     /**
18 |      * @var RequestHeader
19 |      */
20 |     protected $header;
21 | 
22 |     /**
23 |      * @var AbstractRequest
24 |      */
25 |     protected $request;
26 | 
27 |     /**
28 |      * @var string
29 |      */
30 |     protected $data;
31 | 
32 |     public function __construct(AbstractRequest $request, RequestHeader $header)
33 |     {
34 |         $this->header = $header;
35 |         $this->request = $request;
36 |         $this->updateData();
37 |     }
38 | 
39 |     public function pack(): string
40 |     {
41 |         return Int32::pack($this->size) . $this->data;
42 |     }
43 | 
44 |     private function updateData(): void
45 |     {
46 |         $apiVersion = $this->header->getRequestApiVersion();
47 |         $headerVersion = RequestHeader::parseVersion($apiVersion, $this->request->getFlexibleVersions());
48 |         $this->data = $this->header->pack($headerVersion) . $this->request->pack($apiVersion);
49 |         $this->size = \strlen($this->data);
50 |     }
51 | 
52 |     public function getSize(): int
53 |     {
54 |         return $this->size;
55 |     }
56 | 
57 |     public function getHeader(): RequestHeader
58 |     {
59 |         return $this->header;
60 |     }
61 | 
62 |     public function setHeader(RequestHeader $header): self
63 |     {
64 |         $this->header = $header;
65 |         $this->updateData();
66 | 
67 |         return $this;
68 |     }
69 | 
70 |     public function getRequest(): AbstractRequest
71 |     {
72 |         return $this->request;
73 |     }
74 | 
75 |     public function setRequest(AbstractRequest $request): self
76 |     {
77 |         $this->request = $request;
78 |         $this->updateData();
79 | 
80 |         return $this;
81 |     }
82 | }
83 | 


--------------------------------------------------------------------------------
/src/Protocol/LeaderAndIsr/LeaderAndIsrTopicState.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace longlang\phpkafka\Protocol\LeaderAndIsr;
 6 | 
 7 | use longlang\phpkafka\Protocol\AbstractStruct;
 8 | use longlang\phpkafka\Protocol\ProtocolField;
 9 | 
10 | class LeaderAndIsrTopicState extends AbstractStruct
11 | {
12 |     /**
13 |      * The topic name.
14 |      *
15 |      * @var string
16 |      */
17 |     protected $topicName = '';
18 | 
19 |     /**
20 |      * The state of each partition.
21 |      *
22 |      * @var LeaderAndIsrPartitionState[]
23 |      */
24 |     protected $partitionStates = [];
25 | 
26 |     public function __construct()
27 |     {
28 |         if (!isset(self::$maps[self::class])) {
29 |             self::$maps[self::class] = [
30 |                 new ProtocolField('topicName', 'string', false, [2, 3, 4], [4], [], [], null),
31 |                 new ProtocolField('partitionStates', LeaderAndIsrPartitionState::class, true, [2, 3, 4], [4], [], [], null),
32 |             ];
33 |             self::$taggedFieldses[self::class] = [
34 |             ];
35 |         }
36 |     }
37 | 
38 |     public function getFlexibleVersions(): array
39 |     {
40 |         return [4];
41 |     }
42 | 
43 |     public function getTopicName(): string
44 |     {
45 |         return $this->topicName;
46 |     }
47 | 
48 |     public function setTopicName(string $topicName): self
49 |     {
50 |         $this->topicName = $topicName;
51 | 
52 |         return $this;
53 |     }
54 | 
55 |     /**
56 |      * @return LeaderAndIsrPartitionState[]
57 |      */
58 |     public function getPartitionStates(): array
59 |     {
60 |         return $this->partitionStates;
61 |     }
62 | 
63 |     /**
64 |      * @param LeaderAndIsrPartitionState[] $partitionStates
65 |      */
66 |     public function setPartitionStates(array $partitionStates): self
67 |     {
68 |         $this->partitionStates = $partitionStates;
69 | 
70 |         return $this;
71 |     }
72 | }
73 | 


--------------------------------------------------------------------------------
/src/Protocol/LeaveGroup/MemberIdentity.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace longlang\phpkafka\Protocol\LeaveGroup;
 6 | 
 7 | use longlang\phpkafka\Protocol\AbstractStruct;
 8 | use longlang\phpkafka\Protocol\ProtocolField;
 9 | 
10 | class MemberIdentity extends AbstractStruct
11 | {
12 |     /**
13 |      * The member ID to remove from the group.
14 |      *
15 |      * @var string
16 |      */
17 |     protected $memberId = '';
18 | 
19 |     /**
20 |      * The group instance ID to remove from the group.
21 |      *
22 |      * @var string|null
23 |      */
24 |     protected $groupInstanceId = null;
25 | 
26 |     public function __construct()
27 |     {
28 |         if (!isset(self::$maps[self::class])) {
29 |             self::$maps[self::class] = [
30 |                 new ProtocolField('memberId', 'string', false, [3, 4], [4], [], [], null),
31 |                 new ProtocolField('groupInstanceId', 'string', false, [3, 4], [4], [3, 4], [], null),
32 |             ];
33 |             self::$taggedFieldses[self::class] = [
34 |             ];
35 |         }
36 |     }
37 | 
38 |     public function getFlexibleVersions(): array
39 |     {
40 |         return [4];
41 |     }
42 | 
43 |     public function getMemberId(): string
44 |     {
45 |         return $this->memberId;
46 |     }
47 | 
48 |     public function setMemberId(string $memberId): self
49 |     {
50 |         $this->memberId = $memberId;
51 | 
52 |         return $this;
53 |     }
54 | 
55 |     public function getGroupInstanceId(): ?string
56 |     {
57 |         return $this->groupInstanceId;
58 |     }
59 | 
60 |     public function setGroupInstanceId(?string $groupInstanceId): self
61 |     {
62 |         $this->groupInstanceId = $groupInstanceId;
63 | 
64 |         return $this;
65 |     }
66 | }
67 | 


--------------------------------------------------------------------------------
/src/Protocol/ListGroups/ListGroupsRequest.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace longlang\phpkafka\Protocol\ListGroups;
 6 | 
 7 | use longlang\phpkafka\Protocol\AbstractRequest;
 8 | use longlang\phpkafka\Protocol\ProtocolField;
 9 | 
10 | class ListGroupsRequest extends AbstractRequest
11 | {
12 |     /**
13 |      * The states of the groups we want to list. If empty all groups are returned with their state.
14 |      *
15 |      * @var string[]
16 |      */
17 |     protected $statesFilter = [];
18 | 
19 |     public function __construct()
20 |     {
21 |         if (!isset(self::$maps[self::class])) {
22 |             self::$maps[self::class] = [
23 |                 new ProtocolField('statesFilter', 'string', true, [4], [3, 4], [], [], null),
24 |             ];
25 |             self::$taggedFieldses[self::class] = [
26 |             ];
27 |         }
28 |     }
29 | 
30 |     public function getRequestApiKey(): ?int
31 |     {
32 |         return 16;
33 |     }
34 | 
35 |     public function getMaxSupportedVersion(): int
36 |     {
37 |         return 4;
38 |     }
39 | 
40 |     public function getFlexibleVersions(): array
41 |     {
42 |         return [3, 4];
43 |     }
44 | 
45 |     /**
46 |      * @return string[]
47 |      */
48 |     public function getStatesFilter(): array
49 |     {
50 |         return $this->statesFilter;
51 |     }
52 | 
53 |     /**
54 |      * @param string[] $statesFilter
55 |      */
56 |     public function setStatesFilter(array $statesFilter): self
57 |     {
58 |         $this->statesFilter = $statesFilter;
59 | 
60 |         return $this;
61 |     }
62 | }
63 | 


--------------------------------------------------------------------------------
/src/Protocol/ListOffset/ListOffsetTopic.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace longlang\phpkafka\Protocol\ListOffset;
 6 | 
 7 | use longlang\phpkafka\Protocol\AbstractStruct;
 8 | use longlang\phpkafka\Protocol\ProtocolField;
 9 | 
10 | class ListOffsetTopic extends AbstractStruct
11 | {
12 |     /**
13 |      * The topic name.
14 |      *
15 |      * @var string
16 |      */
17 |     protected $name = '';
18 | 
19 |     /**
20 |      * Each partition in the request.
21 |      *
22 |      * @var ListOffsetPartition[]
23 |      */
24 |     protected $partitions = [];
25 | 
26 |     public function __construct()
27 |     {
28 |         if (!isset(self::$maps[self::class])) {
29 |             self::$maps[self::class] = [
30 |                 new ProtocolField('name', 'string', false, [0, 1, 2, 3, 4, 5], [], [], [], null),
31 |                 new ProtocolField('partitions', ListOffsetPartition::class, true, [0, 1, 2, 3, 4, 5], [], [], [], null),
32 |             ];
33 |             self::$taggedFieldses[self::class] = [
34 |             ];
35 |         }
36 |     }
37 | 
38 |     public function getFlexibleVersions(): array
39 |     {
40 |         return [];
41 |     }
42 | 
43 |     public function getName(): string
44 |     {
45 |         return $this->name;
46 |     }
47 | 
48 |     public function setName(string $name): self
49 |     {
50 |         $this->name = $name;
51 | 
52 |         return $this;
53 |     }
54 | 
55 |     /**
56 |      * @return ListOffsetPartition[]
57 |      */
58 |     public function getPartitions(): array
59 |     {
60 |         return $this->partitions;
61 |     }
62 | 
63 |     /**
64 |      * @param ListOffsetPartition[] $partitions
65 |      */
66 |     public function setPartitions(array $partitions): self
67 |     {
68 |         $this->partitions = $partitions;
69 | 
70 |         return $this;
71 |     }
72 | }
73 | 


--------------------------------------------------------------------------------
/src/Protocol/ListOffset/ListOffsetTopicResponse.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace longlang\phpkafka\Protocol\ListOffset;
 6 | 
 7 | use longlang\phpkafka\Protocol\AbstractStruct;
 8 | use longlang\phpkafka\Protocol\ProtocolField;
 9 | 
10 | class ListOffsetTopicResponse extends AbstractStruct
11 | {
12 |     /**
13 |      * The topic name.
14 |      *
15 |      * @var string
16 |      */
17 |     protected $name = '';
18 | 
19 |     /**
20 |      * Each partition in the response.
21 |      *
22 |      * @var ListOffsetPartitionResponse[]
23 |      */
24 |     protected $partitions = [];
25 | 
26 |     public function __construct()
27 |     {
28 |         if (!isset(self::$maps[self::class])) {
29 |             self::$maps[self::class] = [
30 |                 new ProtocolField('name', 'string', false, [0, 1, 2, 3, 4, 5], [], [], [], null),
31 |                 new ProtocolField('partitions', ListOffsetPartitionResponse::class, true, [0, 1, 2, 3, 4, 5], [], [], [], null),
32 |             ];
33 |             self::$taggedFieldses[self::class] = [
34 |             ];
35 |         }
36 |     }
37 | 
38 |     public function getFlexibleVersions(): array
39 |     {
40 |         return [];
41 |     }
42 | 
43 |     public function getName(): string
44 |     {
45 |         return $this->name;
46 |     }
47 | 
48 |     public function setName(string $name): self
49 |     {
50 |         $this->name = $name;
51 | 
52 |         return $this;
53 |     }
54 | 
55 |     /**
56 |      * @return ListOffsetPartitionResponse[]
57 |      */
58 |     public function getPartitions(): array
59 |     {
60 |         return $this->partitions;
61 |     }
62 | 
63 |     /**
64 |      * @param ListOffsetPartitionResponse[] $partitions
65 |      */
66 |     public function setPartitions(array $partitions): self
67 |     {
68 |         $this->partitions = $partitions;
69 | 
70 |         return $this;
71 |     }
72 | }
73 | 


--------------------------------------------------------------------------------
/src/Protocol/ListPartitionReassignments/ListPartitionReassignmentsTopics.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace longlang\phpkafka\Protocol\ListPartitionReassignments;
 6 | 
 7 | use longlang\phpkafka\Protocol\AbstractStruct;
 8 | use longlang\phpkafka\Protocol\ProtocolField;
 9 | 
10 | class ListPartitionReassignmentsTopics extends AbstractStruct
11 | {
12 |     /**
13 |      * The topic name.
14 |      *
15 |      * @var string
16 |      */
17 |     protected $name = '';
18 | 
19 |     /**
20 |      * The partitions to list partition reassignments for.
21 |      *
22 |      * @var int[]
23 |      */
24 |     protected $partitionIndexes = [];
25 | 
26 |     public function __construct()
27 |     {
28 |         if (!isset(self::$maps[self::class])) {
29 |             self::$maps[self::class] = [
30 |                 new ProtocolField('name', 'string', false, [0], [0], [], [], null),
31 |                 new ProtocolField('partitionIndexes', 'int32', true, [0], [0], [], [], null),
32 |             ];
33 |             self::$taggedFieldses[self::class] = [
34 |             ];
35 |         }
36 |     }
37 | 
38 |     public function getFlexibleVersions(): array
39 |     {
40 |         return [0];
41 |     }
42 | 
43 |     public function getName(): string
44 |     {
45 |         return $this->name;
46 |     }
47 | 
48 |     public function setName(string $name): self
49 |     {
50 |         $this->name = $name;
51 | 
52 |         return $this;
53 |     }
54 | 
55 |     /**
56 |      * @return int[]
57 |      */
58 |     public function getPartitionIndexes(): array
59 |     {
60 |         return $this->partitionIndexes;
61 |     }
62 | 
63 |     /**
64 |      * @param int[] $partitionIndexes
65 |      */
66 |     public function setPartitionIndexes(array $partitionIndexes): self
67 |     {
68 |         $this->partitionIndexes = $partitionIndexes;
69 | 
70 |         return $this;
71 |     }
72 | }
73 | 


--------------------------------------------------------------------------------
/src/Protocol/ListPartitionReassignments/OngoingTopicReassignment.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace longlang\phpkafka\Protocol\ListPartitionReassignments;
 6 | 
 7 | use longlang\phpkafka\Protocol\AbstractStruct;
 8 | use longlang\phpkafka\Protocol\ProtocolField;
 9 | 
10 | class OngoingTopicReassignment extends AbstractStruct
11 | {
12 |     /**
13 |      * The topic name.
14 |      *
15 |      * @var string
16 |      */
17 |     protected $name = '';
18 | 
19 |     /**
20 |      * The ongoing reassignments for each partition.
21 |      *
22 |      * @var OngoingPartitionReassignment[]
23 |      */
24 |     protected $partitions = [];
25 | 
26 |     public function __construct()
27 |     {
28 |         if (!isset(self::$maps[self::class])) {
29 |             self::$maps[self::class] = [
30 |                 new ProtocolField('name', 'string', false, [0], [0], [], [], null),
31 |                 new ProtocolField('partitions', OngoingPartitionReassignment::class, true, [0], [0], [], [], null),
32 |             ];
33 |             self::$taggedFieldses[self::class] = [
34 |             ];
35 |         }
36 |     }
37 | 
38 |     public function getFlexibleVersions(): array
39 |     {
40 |         return [0];
41 |     }
42 | 
43 |     public function getName(): string
44 |     {
45 |         return $this->name;
46 |     }
47 | 
48 |     public function setName(string $name): self
49 |     {
50 |         $this->name = $name;
51 | 
52 |         return $this;
53 |     }
54 | 
55 |     /**
56 |      * @return OngoingPartitionReassignment[]
57 |      */
58 |     public function getPartitions(): array
59 |     {
60 |         return $this->partitions;
61 |     }
62 | 
63 |     /**
64 |      * @param OngoingPartitionReassignment[] $partitions
65 |      */
66 |     public function setPartitions(array $partitions): self
67 |     {
68 |         $this->partitions = $partitions;
69 | 
70 |         return $this;
71 |     }
72 | }
73 | 


--------------------------------------------------------------------------------
/src/Protocol/Metadata/MetadataRequestTopic.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace longlang\phpkafka\Protocol\Metadata;
 6 | 
 7 | use longlang\phpkafka\Protocol\AbstractStruct;
 8 | use longlang\phpkafka\Protocol\ProtocolField;
 9 | 
10 | class MetadataRequestTopic extends AbstractStruct
11 | {
12 |     /**
13 |      * The topic name.
14 |      *
15 |      * @var string
16 |      */
17 |     protected $name = '';
18 | 
19 |     public function __construct()
20 |     {
21 |         if (!isset(self::$maps[self::class])) {
22 |             self::$maps[self::class] = [
23 |                 new ProtocolField('name', 'string', false, [0, 1, 2, 3, 4, 5, 6, 7, 8, 9], [9], [], [], null),
24 |             ];
25 |             self::$taggedFieldses[self::class] = [
26 |             ];
27 |         }
28 |     }
29 | 
30 |     public function getFlexibleVersions(): array
31 |     {
32 |         return [9];
33 |     }
34 | 
35 |     public function getName(): string
36 |     {
37 |         return $this->name;
38 |     }
39 | 
40 |     public function setName(string $name): self
41 |     {
42 |         $this->name = $name;
43 | 
44 |         return $this;
45 |     }
46 | }
47 | 


--------------------------------------------------------------------------------
/src/Protocol/OffsetCommit/OffsetCommitRequestTopic.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace longlang\phpkafka\Protocol\OffsetCommit;
 6 | 
 7 | use longlang\phpkafka\Protocol\AbstractStruct;
 8 | use longlang\phpkafka\Protocol\ProtocolField;
 9 | 
10 | class OffsetCommitRequestTopic extends AbstractStruct
11 | {
12 |     /**
13 |      * The topic name.
14 |      *
15 |      * @var string
16 |      */
17 |     protected $name = '';
18 | 
19 |     /**
20 |      * Each partition to commit offsets for.
21 |      *
22 |      * @var OffsetCommitRequestPartition[]
23 |      */
24 |     protected $partitions = [];
25 | 
26 |     public function __construct()
27 |     {
28 |         if (!isset(self::$maps[self::class])) {
29 |             self::$maps[self::class] = [
30 |                 new ProtocolField('name', 'string', false, [0, 1, 2, 3, 4, 5, 6, 7, 8], [8], [], [], null),
31 |                 new ProtocolField('partitions', OffsetCommitRequestPartition::class, true, [0, 1, 2, 3, 4, 5, 6, 7, 8], [8], [], [], null),
32 |             ];
33 |             self::$taggedFieldses[self::class] = [
34 |             ];
35 |         }
36 |     }
37 | 
38 |     public function getFlexibleVersions(): array
39 |     {
40 |         return [8];
41 |     }
42 | 
43 |     public function getName(): string
44 |     {
45 |         return $this->name;
46 |     }
47 | 
48 |     public function setName(string $name): self
49 |     {
50 |         $this->name = $name;
51 | 
52 |         return $this;
53 |     }
54 | 
55 |     /**
56 |      * @return OffsetCommitRequestPartition[]
57 |      */
58 |     public function getPartitions(): array
59 |     {
60 |         return $this->partitions;
61 |     }
62 | 
63 |     /**
64 |      * @param OffsetCommitRequestPartition[] $partitions
65 |      */
66 |     public function setPartitions(array $partitions): self
67 |     {
68 |         $this->partitions = $partitions;
69 | 
70 |         return $this;
71 |     }
72 | }
73 | 


--------------------------------------------------------------------------------
/src/Protocol/OffsetCommit/OffsetCommitResponsePartition.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace longlang\phpkafka\Protocol\OffsetCommit;
 6 | 
 7 | use longlang\phpkafka\Protocol\AbstractStruct;
 8 | use longlang\phpkafka\Protocol\ProtocolField;
 9 | 
10 | class OffsetCommitResponsePartition extends AbstractStruct
11 | {
12 |     /**
13 |      * The partition index.
14 |      *
15 |      * @var int
16 |      */
17 |     protected $partitionIndex = 0;
18 | 
19 |     /**
20 |      * The error code, or 0 if there was no error.
21 |      *
22 |      * @var int
23 |      */
24 |     protected $errorCode = 0;
25 | 
26 |     public function __construct()
27 |     {
28 |         if (!isset(self::$maps[self::class])) {
29 |             self::$maps[self::class] = [
30 |                 new ProtocolField('partitionIndex', 'int32', false, [0, 1, 2, 3, 4, 5, 6, 7, 8], [8], [], [], null),
31 |                 new ProtocolField('errorCode', 'int16', false, [0, 1, 2, 3, 4, 5, 6, 7, 8], [8], [], [], null),
32 |             ];
33 |             self::$taggedFieldses[self::class] = [
34 |             ];
35 |         }
36 |     }
37 | 
38 |     public function getFlexibleVersions(): array
39 |     {
40 |         return [8];
41 |     }
42 | 
43 |     public function getPartitionIndex(): int
44 |     {
45 |         return $this->partitionIndex;
46 |     }
47 | 
48 |     public function setPartitionIndex(int $partitionIndex): self
49 |     {
50 |         $this->partitionIndex = $partitionIndex;
51 | 
52 |         return $this;
53 |     }
54 | 
55 |     public function getErrorCode(): int
56 |     {
57 |         return $this->errorCode;
58 |     }
59 | 
60 |     public function setErrorCode(int $errorCode): self
61 |     {
62 |         $this->errorCode = $errorCode;
63 | 
64 |         return $this;
65 |     }
66 | }
67 | 


--------------------------------------------------------------------------------
/src/Protocol/OffsetCommit/OffsetCommitResponseTopic.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace longlang\phpkafka\Protocol\OffsetCommit;
 6 | 
 7 | use longlang\phpkafka\Protocol\AbstractStruct;
 8 | use longlang\phpkafka\Protocol\ProtocolField;
 9 | 
10 | class OffsetCommitResponseTopic extends AbstractStruct
11 | {
12 |     /**
13 |      * The topic name.
14 |      *
15 |      * @var string
16 |      */
17 |     protected $name = '';
18 | 
19 |     /**
20 |      * The responses for each partition in the topic.
21 |      *
22 |      * @var OffsetCommitResponsePartition[]
23 |      */
24 |     protected $partitions = [];
25 | 
26 |     public function __construct()
27 |     {
28 |         if (!isset(self::$maps[self::class])) {
29 |             self::$maps[self::class] = [
30 |                 new ProtocolField('name', 'string', false, [0, 1, 2, 3, 4, 5, 6, 7, 8], [8], [], [], null),
31 |                 new ProtocolField('partitions', OffsetCommitResponsePartition::class, true, [0, 1, 2, 3, 4, 5, 6, 7, 8], [8], [], [], null),
32 |             ];
33 |             self::$taggedFieldses[self::class] = [
34 |             ];
35 |         }
36 |     }
37 | 
38 |     public function getFlexibleVersions(): array
39 |     {
40 |         return [8];
41 |     }
42 | 
43 |     public function getName(): string
44 |     {
45 |         return $this->name;
46 |     }
47 | 
48 |     public function setName(string $name): self
49 |     {
50 |         $this->name = $name;
51 | 
52 |         return $this;
53 |     }
54 | 
55 |     /**
56 |      * @return OffsetCommitResponsePartition[]
57 |      */
58 |     public function getPartitions(): array
59 |     {
60 |         return $this->partitions;
61 |     }
62 | 
63 |     /**
64 |      * @param OffsetCommitResponsePartition[] $partitions
65 |      */
66 |     public function setPartitions(array $partitions): self
67 |     {
68 |         $this->partitions = $partitions;
69 | 
70 |         return $this;
71 |     }
72 | }
73 | 


--------------------------------------------------------------------------------
/src/Protocol/OffsetDelete/OffsetDeleteRequest.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace longlang\phpkafka\Protocol\OffsetDelete;
 6 | 
 7 | use longlang\phpkafka\Protocol\AbstractRequest;
 8 | use longlang\phpkafka\Protocol\ProtocolField;
 9 | 
10 | class OffsetDeleteRequest extends AbstractRequest
11 | {
12 |     /**
13 |      * The unique group identifier.
14 |      *
15 |      * @var string
16 |      */
17 |     protected $groupId = '';
18 | 
19 |     /**
20 |      * The topics to delete offsets for.
21 |      *
22 |      * @var OffsetDeleteRequestTopic[]
23 |      */
24 |     protected $topics = [];
25 | 
26 |     public function __construct()
27 |     {
28 |         if (!isset(self::$maps[self::class])) {
29 |             self::$maps[self::class] = [
30 |                 new ProtocolField('groupId', 'string', false, [0], [], [], [], null),
31 |                 new ProtocolField('topics', OffsetDeleteRequestTopic::class, true, [0], [], [], [], null),
32 |             ];
33 |             self::$taggedFieldses[self::class] = [
34 |             ];
35 |         }
36 |     }
37 | 
38 |     public function getRequestApiKey(): ?int
39 |     {
40 |         return 47;
41 |     }
42 | 
43 |     public function getMaxSupportedVersion(): int
44 |     {
45 |         return 0;
46 |     }
47 | 
48 |     public function getFlexibleVersions(): array
49 |     {
50 |         return [];
51 |     }
52 | 
53 |     public function getGroupId(): string
54 |     {
55 |         return $this->groupId;
56 |     }
57 | 
58 |     public function setGroupId(string $groupId): self
59 |     {
60 |         $this->groupId = $groupId;
61 | 
62 |         return $this;
63 |     }
64 | 
65 |     /**
66 |      * @return OffsetDeleteRequestTopic[]
67 |      */
68 |     public function getTopics(): array
69 |     {
70 |         return $this->topics;
71 |     }
72 | 
73 |     /**
74 |      * @param OffsetDeleteRequestTopic[] $topics
75 |      */
76 |     public function setTopics(array $topics): self
77 |     {
78 |         $this->topics = $topics;
79 | 
80 |         return $this;
81 |     }
82 | }
83 | 


--------------------------------------------------------------------------------
/src/Protocol/OffsetDelete/OffsetDeleteRequestPartition.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace longlang\phpkafka\Protocol\OffsetDelete;
 6 | 
 7 | use longlang\phpkafka\Protocol\AbstractStruct;
 8 | use longlang\phpkafka\Protocol\ProtocolField;
 9 | 
10 | class OffsetDeleteRequestPartition extends AbstractStruct
11 | {
12 |     /**
13 |      * The partition index.
14 |      *
15 |      * @var int
16 |      */
17 |     protected $partitionIndex = 0;
18 | 
19 |     public function __construct()
20 |     {
21 |         if (!isset(self::$maps[self::class])) {
22 |             self::$maps[self::class] = [
23 |                 new ProtocolField('partitionIndex', 'int32', false, [0], [], [], [], null),
24 |             ];
25 |             self::$taggedFieldses[self::class] = [
26 |             ];
27 |         }
28 |     }
29 | 
30 |     public function getFlexibleVersions(): array
31 |     {
32 |         return [];
33 |     }
34 | 
35 |     public function getPartitionIndex(): int
36 |     {
37 |         return $this->partitionIndex;
38 |     }
39 | 
40 |     public function setPartitionIndex(int $partitionIndex): self
41 |     {
42 |         $this->partitionIndex = $partitionIndex;
43 | 
44 |         return $this;
45 |     }
46 | }
47 | 


--------------------------------------------------------------------------------
/src/Protocol/OffsetDelete/OffsetDeleteRequestTopic.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace longlang\phpkafka\Protocol\OffsetDelete;
 6 | 
 7 | use longlang\phpkafka\Protocol\AbstractStruct;
 8 | use longlang\phpkafka\Protocol\ProtocolField;
 9 | 
10 | class OffsetDeleteRequestTopic extends AbstractStruct
11 | {
12 |     /**
13 |      * The topic name.
14 |      *
15 |      * @var string
16 |      */
17 |     protected $name = '';
18 | 
19 |     /**
20 |      * Each partition to delete offsets for.
21 |      *
22 |      * @var OffsetDeleteRequestPartition[]
23 |      */
24 |     protected $partitions = [];
25 | 
26 |     public function __construct()
27 |     {
28 |         if (!isset(self::$maps[self::class])) {
29 |             self::$maps[self::class] = [
30 |                 new ProtocolField('name', 'string', false, [0], [], [], [], null),
31 |                 new ProtocolField('partitions', OffsetDeleteRequestPartition::class, true, [0], [], [], [], null),
32 |             ];
33 |             self::$taggedFieldses[self::class] = [
34 |             ];
35 |         }
36 |     }
37 | 
38 |     public function getFlexibleVersions(): array
39 |     {
40 |         return [];
41 |     }
42 | 
43 |     public function getName(): string
44 |     {
45 |         return $this->name;
46 |     }
47 | 
48 |     public function setName(string $name): self
49 |     {
50 |         $this->name = $name;
51 | 
52 |         return $this;
53 |     }
54 | 
55 |     /**
56 |      * @return OffsetDeleteRequestPartition[]
57 |      */
58 |     public function getPartitions(): array
59 |     {
60 |         return $this->partitions;
61 |     }
62 | 
63 |     /**
64 |      * @param OffsetDeleteRequestPartition[] $partitions
65 |      */
66 |     public function setPartitions(array $partitions): self
67 |     {
68 |         $this->partitions = $partitions;
69 | 
70 |         return $this;
71 |     }
72 | }
73 | 


--------------------------------------------------------------------------------
/src/Protocol/OffsetDelete/OffsetDeleteResponsePartition.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace longlang\phpkafka\Protocol\OffsetDelete;
 6 | 
 7 | use longlang\phpkafka\Protocol\AbstractStruct;
 8 | use longlang\phpkafka\Protocol\ProtocolField;
 9 | 
10 | class OffsetDeleteResponsePartition extends AbstractStruct
11 | {
12 |     /**
13 |      * The partition index.
14 |      *
15 |      * @var int
16 |      */
17 |     protected $partitionIndex = 0;
18 | 
19 |     /**
20 |      * The error code, or 0 if there was no error.
21 |      *
22 |      * @var int
23 |      */
24 |     protected $errorCode = 0;
25 | 
26 |     public function __construct()
27 |     {
28 |         if (!isset(self::$maps[self::class])) {
29 |             self::$maps[self::class] = [
30 |                 new ProtocolField('partitionIndex', 'int32', false, [0], [], [], [], null),
31 |                 new ProtocolField('errorCode', 'int16', false, [0], [], [], [], null),
32 |             ];
33 |             self::$taggedFieldses[self::class] = [
34 |             ];
35 |         }
36 |     }
37 | 
38 |     public function getFlexibleVersions(): array
39 |     {
40 |         return [];
41 |     }
42 | 
43 |     public function getPartitionIndex(): int
44 |     {
45 |         return $this->partitionIndex;
46 |     }
47 | 
48 |     public function setPartitionIndex(int $partitionIndex): self
49 |     {
50 |         $this->partitionIndex = $partitionIndex;
51 | 
52 |         return $this;
53 |     }
54 | 
55 |     public function getErrorCode(): int
56 |     {
57 |         return $this->errorCode;
58 |     }
59 | 
60 |     public function setErrorCode(int $errorCode): self
61 |     {
62 |         $this->errorCode = $errorCode;
63 | 
64 |         return $this;
65 |     }
66 | }
67 | 


--------------------------------------------------------------------------------
/src/Protocol/OffsetDelete/OffsetDeleteResponseTopic.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace longlang\phpkafka\Protocol\OffsetDelete;
 6 | 
 7 | use longlang\phpkafka\Protocol\AbstractStruct;
 8 | use longlang\phpkafka\Protocol\ProtocolField;
 9 | 
10 | class OffsetDeleteResponseTopic extends AbstractStruct
11 | {
12 |     /**
13 |      * The topic name.
14 |      *
15 |      * @var string
16 |      */
17 |     protected $name = '';
18 | 
19 |     /**
20 |      * The responses for each partition in the topic.
21 |      *
22 |      * @var OffsetDeleteResponsePartition[]
23 |      */
24 |     protected $partitions = [];
25 | 
26 |     public function __construct()
27 |     {
28 |         if (!isset(self::$maps[self::class])) {
29 |             self::$maps[self::class] = [
30 |                 new ProtocolField('name', 'string', false, [0], [], [], [], null),
31 |                 new ProtocolField('partitions', OffsetDeleteResponsePartition::class, true, [0], [], [], [], null),
32 |             ];
33 |             self::$taggedFieldses[self::class] = [
34 |             ];
35 |         }
36 |     }
37 | 
38 |     public function getFlexibleVersions(): array
39 |     {
40 |         return [];
41 |     }
42 | 
43 |     public function getName(): string
44 |     {
45 |         return $this->name;
46 |     }
47 | 
48 |     public function setName(string $name): self
49 |     {
50 |         $this->name = $name;
51 | 
52 |         return $this;
53 |     }
54 | 
55 |     /**
56 |      * @return OffsetDeleteResponsePartition[]
57 |      */
58 |     public function getPartitions(): array
59 |     {
60 |         return $this->partitions;
61 |     }
62 | 
63 |     /**
64 |      * @param OffsetDeleteResponsePartition[] $partitions
65 |      */
66 |     public function setPartitions(array $partitions): self
67 |     {
68 |         $this->partitions = $partitions;
69 | 
70 |         return $this;
71 |     }
72 | }
73 | 


--------------------------------------------------------------------------------
/src/Protocol/OffsetFetch/OffsetFetchRequestTopic.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace longlang\phpkafka\Protocol\OffsetFetch;
 6 | 
 7 | use longlang\phpkafka\Protocol\AbstractStruct;
 8 | use longlang\phpkafka\Protocol\ProtocolField;
 9 | 
10 | class OffsetFetchRequestTopic extends AbstractStruct
11 | {
12 |     /**
13 |      * The topic name.
14 |      *
15 |      * @var string
16 |      */
17 |     protected $name = '';
18 | 
19 |     /**
20 |      * The partition indexes we would like to fetch offsets for.
21 |      *
22 |      * @var int[]
23 |      */
24 |     protected $partitionIndexes = [];
25 | 
26 |     public function __construct()
27 |     {
28 |         if (!isset(self::$maps[self::class])) {
29 |             self::$maps[self::class] = [
30 |                 new ProtocolField('name', 'string', false, [0, 1, 2, 3, 4, 5, 6, 7], [6, 7], [], [], null),
31 |                 new ProtocolField('partitionIndexes', 'int32', true, [0, 1, 2, 3, 4, 5, 6, 7], [6, 7], [], [], null),
32 |             ];
33 |             self::$taggedFieldses[self::class] = [
34 |             ];
35 |         }
36 |     }
37 | 
38 |     public function getFlexibleVersions(): array
39 |     {
40 |         return [6, 7];
41 |     }
42 | 
43 |     public function getName(): string
44 |     {
45 |         return $this->name;
46 |     }
47 | 
48 |     public function setName(string $name): self
49 |     {
50 |         $this->name = $name;
51 | 
52 |         return $this;
53 |     }
54 | 
55 |     /**
56 |      * @return int[]
57 |      */
58 |     public function getPartitionIndexes(): array
59 |     {
60 |         return $this->partitionIndexes;
61 |     }
62 | 
63 |     /**
64 |      * @param int[] $partitionIndexes
65 |      */
66 |     public function setPartitionIndexes(array $partitionIndexes): self
67 |     {
68 |         $this->partitionIndexes = $partitionIndexes;
69 | 
70 |         return $this;
71 |     }
72 | }
73 | 


--------------------------------------------------------------------------------
/src/Protocol/OffsetFetch/OffsetFetchResponseTopic.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace longlang\phpkafka\Protocol\OffsetFetch;
 6 | 
 7 | use longlang\phpkafka\Protocol\AbstractStruct;
 8 | use longlang\phpkafka\Protocol\ProtocolField;
 9 | 
10 | class OffsetFetchResponseTopic extends AbstractStruct
11 | {
12 |     /**
13 |      * The topic name.
14 |      *
15 |      * @var string
16 |      */
17 |     protected $name = '';
18 | 
19 |     /**
20 |      * The responses per partition.
21 |      *
22 |      * @var OffsetFetchResponsePartition[]
23 |      */
24 |     protected $partitions = [];
25 | 
26 |     public function __construct()
27 |     {
28 |         if (!isset(self::$maps[self::class])) {
29 |             self::$maps[self::class] = [
30 |                 new ProtocolField('name', 'string', false, [0, 1, 2, 3, 4, 5, 6, 7], [6, 7], [], [], null),
31 |                 new ProtocolField('partitions', OffsetFetchResponsePartition::class, true, [0, 1, 2, 3, 4, 5, 6, 7], [6, 7], [], [], null),
32 |             ];
33 |             self::$taggedFieldses[self::class] = [
34 |             ];
35 |         }
36 |     }
37 | 
38 |     public function getFlexibleVersions(): array
39 |     {
40 |         return [6, 7];
41 |     }
42 | 
43 |     public function getName(): string
44 |     {
45 |         return $this->name;
46 |     }
47 | 
48 |     public function setName(string $name): self
49 |     {
50 |         $this->name = $name;
51 | 
52 |         return $this;
53 |     }
54 | 
55 |     /**
56 |      * @return OffsetFetchResponsePartition[]
57 |      */
58 |     public function getPartitions(): array
59 |     {
60 |         return $this->partitions;
61 |     }
62 | 
63 |     /**
64 |      * @param OffsetFetchResponsePartition[] $partitions
65 |      */
66 |     public function setPartitions(array $partitions): self
67 |     {
68 |         $this->partitions = $partitions;
69 | 
70 |         return $this;
71 |     }
72 | }
73 | 


--------------------------------------------------------------------------------
/src/Protocol/OffsetForLeaderEpoch/OffsetForLeaderTopic.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace longlang\phpkafka\Protocol\OffsetForLeaderEpoch;
 6 | 
 7 | use longlang\phpkafka\Protocol\AbstractStruct;
 8 | use longlang\phpkafka\Protocol\ProtocolField;
 9 | 
10 | class OffsetForLeaderTopic extends AbstractStruct
11 | {
12 |     /**
13 |      * The topic name.
14 |      *
15 |      * @var string
16 |      */
17 |     protected $name = '';
18 | 
19 |     /**
20 |      * Each partition to get offsets for.
21 |      *
22 |      * @var OffsetForLeaderPartition[]
23 |      */
24 |     protected $partitions = [];
25 | 
26 |     public function __construct()
27 |     {
28 |         if (!isset(self::$maps[self::class])) {
29 |             self::$maps[self::class] = [
30 |                 new ProtocolField('name', 'string', false, [0, 1, 2, 3], [], [], [], null),
31 |                 new ProtocolField('partitions', OffsetForLeaderPartition::class, true, [0, 1, 2, 3], [], [], [], null),
32 |             ];
33 |             self::$taggedFieldses[self::class] = [
34 |             ];
35 |         }
36 |     }
37 | 
38 |     public function getFlexibleVersions(): array
39 |     {
40 |         return [];
41 |     }
42 | 
43 |     public function getName(): string
44 |     {
45 |         return $this->name;
46 |     }
47 | 
48 |     public function setName(string $name): self
49 |     {
50 |         $this->name = $name;
51 | 
52 |         return $this;
53 |     }
54 | 
55 |     /**
56 |      * @return OffsetForLeaderPartition[]
57 |      */
58 |     public function getPartitions(): array
59 |     {
60 |         return $this->partitions;
61 |     }
62 | 
63 |     /**
64 |      * @param OffsetForLeaderPartition[] $partitions
65 |      */
66 |     public function setPartitions(array $partitions): self
67 |     {
68 |         $this->partitions = $partitions;
69 | 
70 |         return $this;
71 |     }
72 | }
73 | 


--------------------------------------------------------------------------------
/src/Protocol/OffsetForLeaderEpoch/OffsetForLeaderTopicResult.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace longlang\phpkafka\Protocol\OffsetForLeaderEpoch;
 6 | 
 7 | use longlang\phpkafka\Protocol\AbstractStruct;
 8 | use longlang\phpkafka\Protocol\ProtocolField;
 9 | 
10 | class OffsetForLeaderTopicResult extends AbstractStruct
11 | {
12 |     /**
13 |      * The topic name.
14 |      *
15 |      * @var string
16 |      */
17 |     protected $name = '';
18 | 
19 |     /**
20 |      * Each partition in the topic we fetched offsets for.
21 |      *
22 |      * @var OffsetForLeaderPartitionResult[]
23 |      */
24 |     protected $partitions = [];
25 | 
26 |     public function __construct()
27 |     {
28 |         if (!isset(self::$maps[self::class])) {
29 |             self::$maps[self::class] = [
30 |                 new ProtocolField('name', 'string', false, [0, 1, 2, 3], [], [], [], null),
31 |                 new ProtocolField('partitions', OffsetForLeaderPartitionResult::class, true, [0, 1, 2, 3], [], [], [], null),
32 |             ];
33 |             self::$taggedFieldses[self::class] = [
34 |             ];
35 |         }
36 |     }
37 | 
38 |     public function getFlexibleVersions(): array
39 |     {
40 |         return [];
41 |     }
42 | 
43 |     public function getName(): string
44 |     {
45 |         return $this->name;
46 |     }
47 | 
48 |     public function setName(string $name): self
49 |     {
50 |         $this->name = $name;
51 | 
52 |         return $this;
53 |     }
54 | 
55 |     /**
56 |      * @return OffsetForLeaderPartitionResult[]
57 |      */
58 |     public function getPartitions(): array
59 |     {
60 |         return $this->partitions;
61 |     }
62 | 
63 |     /**
64 |      * @param OffsetForLeaderPartitionResult[] $partitions
65 |      */
66 |     public function setPartitions(array $partitions): self
67 |     {
68 |         $this->partitions = $partitions;
69 | 
70 |         return $this;
71 |     }
72 | }
73 | 


--------------------------------------------------------------------------------
/src/Protocol/Produce/BatchIndexAndErrorMessage.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace longlang\phpkafka\Protocol\Produce;
 6 | 
 7 | use longlang\phpkafka\Protocol\AbstractStruct;
 8 | use longlang\phpkafka\Protocol\ProtocolField;
 9 | 
10 | class BatchIndexAndErrorMessage extends AbstractStruct
11 | {
12 |     /**
13 |      * The batch index of the record that cause the batch to be dropped.
14 |      *
15 |      * @var int
16 |      */
17 |     protected $batchIndex = 0;
18 | 
19 |     /**
20 |      * The error message of the record that caused the batch to be dropped.
21 |      *
22 |      * @var string|null
23 |      */
24 |     protected $batchIndexErrorMessage = null;
25 | 
26 |     public function __construct()
27 |     {
28 |         if (!isset(self::$maps[self::class])) {
29 |             self::$maps[self::class] = [
30 |                 new ProtocolField('batchIndex', 'int32', false, [8], [], [], [], null),
31 |                 new ProtocolField('batchIndexErrorMessage', 'string', false, [8], [], [8], [], null),
32 |             ];
33 |             self::$taggedFieldses[self::class] = [
34 |             ];
35 |         }
36 |     }
37 | 
38 |     public function getFlexibleVersions(): array
39 |     {
40 |         return [];
41 |     }
42 | 
43 |     public function getBatchIndex(): int
44 |     {
45 |         return $this->batchIndex;
46 |     }
47 | 
48 |     public function setBatchIndex(int $batchIndex): self
49 |     {
50 |         $this->batchIndex = $batchIndex;
51 | 
52 |         return $this;
53 |     }
54 | 
55 |     public function getBatchIndexErrorMessage(): ?string
56 |     {
57 |         return $this->batchIndexErrorMessage;
58 |     }
59 | 
60 |     public function setBatchIndexErrorMessage(?string $batchIndexErrorMessage): self
61 |     {
62 |         $this->batchIndexErrorMessage = $batchIndexErrorMessage;
63 | 
64 |         return $this;
65 |     }
66 | }
67 | 


--------------------------------------------------------------------------------
/src/Protocol/Produce/PartitionProduceData.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace longlang\phpkafka\Protocol\Produce;
 6 | 
 7 | use longlang\phpkafka\Protocol\AbstractStruct;
 8 | use longlang\phpkafka\Protocol\ProtocolField;
 9 | 
10 | class PartitionProduceData extends AbstractStruct
11 | {
12 |     /**
13 |      * The partition index.
14 |      *
15 |      * @var int
16 |      */
17 |     protected $partitionIndex = 0;
18 | 
19 |     /**
20 |      * The record data to be produced.
21 |      *
22 |      * @var \longlang\phpkafka\Protocol\RecordBatch\RecordBatch|null
23 |      */
24 |     protected $records = null;
25 | 
26 |     public function __construct()
27 |     {
28 |         if (!isset(self::$maps[self::class])) {
29 |             self::$maps[self::class] = [
30 |                 new ProtocolField('partitionIndex', 'int32', false, [0, 1, 2, 3, 4, 5, 6, 7, 8], [], [], [], null),
31 |                 new ProtocolField('records', '\longlang\phpkafka\Protocol\RecordBatch\RecordBatch', false, [0, 1, 2, 3, 4, 5, 6, 7, 8], [], [0, 1, 2, 3, 4, 5, 6, 7, 8], [], null),
32 |             ];
33 |             self::$taggedFieldses[self::class] = [
34 |             ];
35 |         }
36 |     }
37 | 
38 |     public function getFlexibleVersions(): array
39 |     {
40 |         return [];
41 |     }
42 | 
43 |     public function getPartitionIndex(): int
44 |     {
45 |         return $this->partitionIndex;
46 |     }
47 | 
48 |     public function setPartitionIndex(int $partitionIndex): self
49 |     {
50 |         $this->partitionIndex = $partitionIndex;
51 | 
52 |         return $this;
53 |     }
54 | 
55 |     public function getRecords(): ?\longlang\phpkafka\Protocol\RecordBatch\RecordBatch
56 |     {
57 |         return $this->records;
58 |     }
59 | 
60 |     public function setRecords(?\longlang\phpkafka\Protocol\RecordBatch\RecordBatch $records): self
61 |     {
62 |         $this->records = $records;
63 | 
64 |         return $this;
65 |     }
66 | }
67 | 


--------------------------------------------------------------------------------
/src/Protocol/Produce/TopicProduceData.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace longlang\phpkafka\Protocol\Produce;
 6 | 
 7 | use longlang\phpkafka\Protocol\AbstractStruct;
 8 | use longlang\phpkafka\Protocol\ProtocolField;
 9 | 
10 | class TopicProduceData extends AbstractStruct
11 | {
12 |     /**
13 |      * The topic name.
14 |      *
15 |      * @var string
16 |      */
17 |     protected $name = '';
18 | 
19 |     /**
20 |      * Each partition to produce to.
21 |      *
22 |      * @var PartitionProduceData[]
23 |      */
24 |     protected $partitions = [];
25 | 
26 |     public function __construct()
27 |     {
28 |         if (!isset(self::$maps[self::class])) {
29 |             self::$maps[self::class] = [
30 |                 new ProtocolField('name', 'string', false, [0, 1, 2, 3, 4, 5, 6, 7, 8], [], [], [], null),
31 |                 new ProtocolField('partitions', PartitionProduceData::class, true, [0, 1, 2, 3, 4, 5, 6, 7, 8], [], [], [], null),
32 |             ];
33 |             self::$taggedFieldses[self::class] = [
34 |             ];
35 |         }
36 |     }
37 | 
38 |     public function getFlexibleVersions(): array
39 |     {
40 |         return [];
41 |     }
42 | 
43 |     public function getName(): string
44 |     {
45 |         return $this->name;
46 |     }
47 | 
48 |     public function setName(string $name): self
49 |     {
50 |         $this->name = $name;
51 | 
52 |         return $this;
53 |     }
54 | 
55 |     /**
56 |      * @return PartitionProduceData[]
57 |      */
58 |     public function getPartitions(): array
59 |     {
60 |         return $this->partitions;
61 |     }
62 | 
63 |     /**
64 |      * @param PartitionProduceData[] $partitions
65 |      */
66 |     public function setPartitions(array $partitions): self
67 |     {
68 |         $this->partitions = $partitions;
69 | 
70 |         return $this;
71 |     }
72 | }
73 | 


--------------------------------------------------------------------------------
/src/Protocol/Produce/TopicProduceResponse.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace longlang\phpkafka\Protocol\Produce;
 6 | 
 7 | use longlang\phpkafka\Protocol\AbstractStruct;
 8 | use longlang\phpkafka\Protocol\ProtocolField;
 9 | 
10 | class TopicProduceResponse extends AbstractStruct
11 | {
12 |     /**
13 |      * The topic name.
14 |      *
15 |      * @var string
16 |      */
17 |     protected $name = '';
18 | 
19 |     /**
20 |      * Each partition that we produced to within the topic.
21 |      *
22 |      * @var PartitionProduceResponse[]
23 |      */
24 |     protected $partitions = [];
25 | 
26 |     public function __construct()
27 |     {
28 |         if (!isset(self::$maps[self::class])) {
29 |             self::$maps[self::class] = [
30 |                 new ProtocolField('name', 'string', false, [0, 1, 2, 3, 4, 5, 6, 7, 8], [], [], [], null),
31 |                 new ProtocolField('partitions', PartitionProduceResponse::class, true, [0, 1, 2, 3, 4, 5, 6, 7, 8], [], [], [], null),
32 |             ];
33 |             self::$taggedFieldses[self::class] = [
34 |             ];
35 |         }
36 |     }
37 | 
38 |     public function getFlexibleVersions(): array
39 |     {
40 |         return [];
41 |     }
42 | 
43 |     public function getName(): string
44 |     {
45 |         return $this->name;
46 |     }
47 | 
48 |     public function setName(string $name): self
49 |     {
50 |         $this->name = $name;
51 | 
52 |         return $this;
53 |     }
54 | 
55 |     /**
56 |      * @return PartitionProduceResponse[]
57 |      */
58 |     public function getPartitions(): array
59 |     {
60 |         return $this->partitions;
61 |     }
62 | 
63 |     /**
64 |      * @param PartitionProduceResponse[] $partitions
65 |      */
66 |     public function setPartitions(array $partitions): self
67 |     {
68 |         $this->partitions = $partitions;
69 | 
70 |         return $this;
71 |     }
72 | }
73 | 


--------------------------------------------------------------------------------
/src/Protocol/RecordBatch/Enum/Compression.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace longlang\phpkafka\Protocol\RecordBatch\Enum;
 6 | 
 7 | class Compression
 8 | {
 9 |     public const NONE = 0;
10 | 
11 |     public const GZIP = 1;
12 | 
13 |     public const SNAPPY = 2;
14 | 
15 |     public const LZ4 = 3;
16 | 
17 |     public const ZSTD = 4;
18 | 
19 |     private function __construct()
20 |     {
21 |     }
22 | }
23 | 


--------------------------------------------------------------------------------
/src/Protocol/RecordBatch/Enum/TimestampType.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace longlang\phpkafka\Protocol\RecordBatch\Enum;
 6 | 
 7 | class TimestampType
 8 | {
 9 |     public const CREATE_TIME = 0;
10 | 
11 |     public const LOG_APPEND_TIME = 1;
12 | 
13 |     private function __construct()
14 |     {
15 |     }
16 | }
17 | 


--------------------------------------------------------------------------------
/src/Protocol/RenewDelegationToken/RenewDelegationTokenRequest.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace longlang\phpkafka\Protocol\RenewDelegationToken;
 6 | 
 7 | use longlang\phpkafka\Protocol\AbstractRequest;
 8 | use longlang\phpkafka\Protocol\ProtocolField;
 9 | 
10 | class RenewDelegationTokenRequest extends AbstractRequest
11 | {
12 |     /**
13 |      * The HMAC of the delegation token to be renewed.
14 |      *
15 |      * @var string
16 |      */
17 |     protected $hmac = '';
18 | 
19 |     /**
20 |      * The renewal time period in milliseconds.
21 |      *
22 |      * @var int
23 |      */
24 |     protected $renewPeriodMs = 0;
25 | 
26 |     public function __construct()
27 |     {
28 |         if (!isset(self::$maps[self::class])) {
29 |             self::$maps[self::class] = [
30 |                 new ProtocolField('hmac', 'bytes', false, [0, 1, 2], [2], [], [], null),
31 |                 new ProtocolField('renewPeriodMs', 'int64', false, [0, 1, 2], [2], [], [], null),
32 |             ];
33 |             self::$taggedFieldses[self::class] = [
34 |             ];
35 |         }
36 |     }
37 | 
38 |     public function getRequestApiKey(): ?int
39 |     {
40 |         return 39;
41 |     }
42 | 
43 |     public function getMaxSupportedVersion(): int
44 |     {
45 |         return 2;
46 |     }
47 | 
48 |     public function getFlexibleVersions(): array
49 |     {
50 |         return [2];
51 |     }
52 | 
53 |     public function getHmac(): string
54 |     {
55 |         return $this->hmac;
56 |     }
57 | 
58 |     public function setHmac(string $hmac): self
59 |     {
60 |         $this->hmac = $hmac;
61 | 
62 |         return $this;
63 |     }
64 | 
65 |     public function getRenewPeriodMs(): int
66 |     {
67 |         return $this->renewPeriodMs;
68 |     }
69 | 
70 |     public function setRenewPeriodMs(int $renewPeriodMs): self
71 |     {
72 |         $this->renewPeriodMs = $renewPeriodMs;
73 | 
74 |         return $this;
75 |     }
76 | }
77 | 


--------------------------------------------------------------------------------
/src/Protocol/ResponseHeader/ResponseHeader.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace longlang\phpkafka\Protocol\ResponseHeader;
 6 | 
 7 | use longlang\phpkafka\Protocol\AbstractResponseHeader;
 8 | use longlang\phpkafka\Protocol\ProtocolField;
 9 | 
10 | class ResponseHeader extends AbstractResponseHeader
11 | {
12 |     /**
13 |      * The correlation ID of this response.
14 |      *
15 |      * @var int
16 |      */
17 |     protected $correlationId = 0;
18 | 
19 |     public function __construct()
20 |     {
21 |         if (!isset(self::$maps[self::class])) {
22 |             self::$maps[self::class] = [
23 |                 new ProtocolField('correlationId', 'int32', false, [0, 1], [1], [], [], null),
24 |             ];
25 |             self::$taggedFieldses[self::class] = [
26 |             ];
27 |         }
28 |     }
29 | 
30 |     public function getFlexibleVersions(): array
31 |     {
32 |         return [1];
33 |     }
34 | 
35 |     public function getCorrelationId(): int
36 |     {
37 |         return $this->correlationId;
38 |     }
39 | 
40 |     public function setCorrelationId(int $correlationId): self
41 |     {
42 |         $this->correlationId = $correlationId;
43 | 
44 |         return $this;
45 |     }
46 | }
47 | 


--------------------------------------------------------------------------------
/src/Protocol/SaslAuthenticate/SaslAuthenticateRequest.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace longlang\phpkafka\Protocol\SaslAuthenticate;
 6 | 
 7 | use longlang\phpkafka\Protocol\AbstractRequest;
 8 | use longlang\phpkafka\Protocol\ProtocolField;
 9 | 
10 | class SaslAuthenticateRequest extends AbstractRequest
11 | {
12 |     /**
13 |      * The SASL authentication bytes from the client, as defined by the SASL mechanism.
14 |      *
15 |      * @var string
16 |      */
17 |     protected $authBytes = '';
18 | 
19 |     public function __construct()
20 |     {
21 |         if (!isset(self::$maps[self::class])) {
22 |             self::$maps[self::class] = [
23 |                 new ProtocolField('authBytes', 'bytes', false, [0, 1, 2], [2], [], [], null),
24 |             ];
25 |             self::$taggedFieldses[self::class] = [
26 |             ];
27 |         }
28 |     }
29 | 
30 |     public function getRequestApiKey(): ?int
31 |     {
32 |         return 36;
33 |     }
34 | 
35 |     public function getMaxSupportedVersion(): int
36 |     {
37 |         return 2;
38 |     }
39 | 
40 |     public function getFlexibleVersions(): array
41 |     {
42 |         return [2];
43 |     }
44 | 
45 |     public function getAuthBytes(): string
46 |     {
47 |         return $this->authBytes;
48 |     }
49 | 
50 |     public function setAuthBytes(string $authBytes): self
51 |     {
52 |         $this->authBytes = $authBytes;
53 | 
54 |         return $this;
55 |     }
56 | }
57 | 


--------------------------------------------------------------------------------
/src/Protocol/SaslHandshake/SaslHandshakeRequest.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace longlang\phpkafka\Protocol\SaslHandshake;
 6 | 
 7 | use longlang\phpkafka\Protocol\AbstractRequest;
 8 | use longlang\phpkafka\Protocol\ProtocolField;
 9 | 
10 | class SaslHandshakeRequest extends AbstractRequest
11 | {
12 |     /**
13 |      * The SASL mechanism chosen by the client.
14 |      *
15 |      * @var string
16 |      */
17 |     protected $mechanism = '';
18 | 
19 |     public function __construct()
20 |     {
21 |         if (!isset(self::$maps[self::class])) {
22 |             self::$maps[self::class] = [
23 |                 new ProtocolField('mechanism', 'string', false, [0, 1], [], [], [], null),
24 |             ];
25 |             self::$taggedFieldses[self::class] = [
26 |             ];
27 |         }
28 |     }
29 | 
30 |     public function getRequestApiKey(): ?int
31 |     {
32 |         return 17;
33 |     }
34 | 
35 |     public function getMaxSupportedVersion(): int
36 |     {
37 |         return 1;
38 |     }
39 | 
40 |     public function getFlexibleVersions(): array
41 |     {
42 |         return [];
43 |     }
44 | 
45 |     public function getMechanism(): string
46 |     {
47 |         return $this->mechanism;
48 |     }
49 | 
50 |     public function setMechanism(string $mechanism): self
51 |     {
52 |         $this->mechanism = $mechanism;
53 | 
54 |         return $this;
55 |     }
56 | }
57 | 


--------------------------------------------------------------------------------
/src/Protocol/SaslHandshake/SaslHandshakeResponse.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace longlang\phpkafka\Protocol\SaslHandshake;
 6 | 
 7 | use longlang\phpkafka\Protocol\AbstractResponse;
 8 | use longlang\phpkafka\Protocol\ProtocolField;
 9 | 
10 | class SaslHandshakeResponse extends AbstractResponse
11 | {
12 |     /**
13 |      * The error code, or 0 if there was no error.
14 |      *
15 |      * @var int
16 |      */
17 |     protected $errorCode = 0;
18 | 
19 |     /**
20 |      * The mechanisms enabled in the server.
21 |      *
22 |      * @var string[]
23 |      */
24 |     protected $mechanisms = [];
25 | 
26 |     public function __construct()
27 |     {
28 |         if (!isset(self::$maps[self::class])) {
29 |             self::$maps[self::class] = [
30 |                 new ProtocolField('errorCode', 'int16', false, [0, 1], [], [], [], null),
31 |                 new ProtocolField('mechanisms', 'string', true, [0, 1], [], [], [], null),
32 |             ];
33 |             self::$taggedFieldses[self::class] = [
34 |             ];
35 |         }
36 |     }
37 | 
38 |     public function getRequestApiKey(): ?int
39 |     {
40 |         return 17;
41 |     }
42 | 
43 |     public function getFlexibleVersions(): array
44 |     {
45 |         return [];
46 |     }
47 | 
48 |     public function getErrorCode(): int
49 |     {
50 |         return $this->errorCode;
51 |     }
52 | 
53 |     public function setErrorCode(int $errorCode): self
54 |     {
55 |         $this->errorCode = $errorCode;
56 | 
57 |         return $this;
58 |     }
59 | 
60 |     /**
61 |      * @return string[]
62 |      */
63 |     public function getMechanisms(): array
64 |     {
65 |         return $this->mechanisms;
66 |     }
67 | 
68 |     /**
69 |      * @param string[] $mechanisms
70 |      */
71 |     public function setMechanisms(array $mechanisms): self
72 |     {
73 |         $this->mechanisms = $mechanisms;
74 | 
75 |         return $this;
76 |     }
77 | }
78 | 


--------------------------------------------------------------------------------
/src/Protocol/StopReplica/StopReplicaPartitionV0.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace longlang\phpkafka\Protocol\StopReplica;
 6 | 
 7 | use longlang\phpkafka\Protocol\AbstractStruct;
 8 | use longlang\phpkafka\Protocol\ProtocolField;
 9 | 
10 | class StopReplicaPartitionV0 extends AbstractStruct
11 | {
12 |     /**
13 |      * The topic name.
14 |      *
15 |      * @var string
16 |      */
17 |     protected $topicName = '';
18 | 
19 |     /**
20 |      * The partition index.
21 |      *
22 |      * @var int
23 |      */
24 |     protected $partitionIndex = 0;
25 | 
26 |     public function __construct()
27 |     {
28 |         if (!isset(self::$maps[self::class])) {
29 |             self::$maps[self::class] = [
30 |                 new ProtocolField('topicName', 'string', false, [0], [2, 3], [], [], null),
31 |                 new ProtocolField('partitionIndex', 'int32', false, [0], [2, 3], [], [], null),
32 |             ];
33 |             self::$taggedFieldses[self::class] = [
34 |             ];
35 |         }
36 |     }
37 | 
38 |     public function getFlexibleVersions(): array
39 |     {
40 |         return [2, 3];
41 |     }
42 | 
43 |     public function getTopicName(): string
44 |     {
45 |         return $this->topicName;
46 |     }
47 | 
48 |     public function setTopicName(string $topicName): self
49 |     {
50 |         $this->topicName = $topicName;
51 | 
52 |         return $this;
53 |     }
54 | 
55 |     public function getPartitionIndex(): int
56 |     {
57 |         return $this->partitionIndex;
58 |     }
59 | 
60 |     public function setPartitionIndex(int $partitionIndex): self
61 |     {
62 |         $this->partitionIndex = $partitionIndex;
63 | 
64 |         return $this;
65 |     }
66 | }
67 | 


--------------------------------------------------------------------------------
/src/Protocol/StopReplica/StopReplicaTopicState.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace longlang\phpkafka\Protocol\StopReplica;
 6 | 
 7 | use longlang\phpkafka\Protocol\AbstractStruct;
 8 | use longlang\phpkafka\Protocol\ProtocolField;
 9 | 
10 | class StopReplicaTopicState extends AbstractStruct
11 | {
12 |     /**
13 |      * The topic name.
14 |      *
15 |      * @var string
16 |      */
17 |     protected $topicName = '';
18 | 
19 |     /**
20 |      * The state of each partition.
21 |      *
22 |      * @var StopReplicaPartitionState[]
23 |      */
24 |     protected $partitionStates = [];
25 | 
26 |     public function __construct()
27 |     {
28 |         if (!isset(self::$maps[self::class])) {
29 |             self::$maps[self::class] = [
30 |                 new ProtocolField('topicName', 'string', false, [3], [2, 3], [], [], null),
31 |                 new ProtocolField('partitionStates', StopReplicaPartitionState::class, true, [3], [2, 3], [], [], null),
32 |             ];
33 |             self::$taggedFieldses[self::class] = [
34 |             ];
35 |         }
36 |     }
37 | 
38 |     public function getFlexibleVersions(): array
39 |     {
40 |         return [2, 3];
41 |     }
42 | 
43 |     public function getTopicName(): string
44 |     {
45 |         return $this->topicName;
46 |     }
47 | 
48 |     public function setTopicName(string $topicName): self
49 |     {
50 |         $this->topicName = $topicName;
51 | 
52 |         return $this;
53 |     }
54 | 
55 |     /**
56 |      * @return StopReplicaPartitionState[]
57 |      */
58 |     public function getPartitionStates(): array
59 |     {
60 |         return $this->partitionStates;
61 |     }
62 | 
63 |     /**
64 |      * @param StopReplicaPartitionState[] $partitionStates
65 |      */
66 |     public function setPartitionStates(array $partitionStates): self
67 |     {
68 |         $this->partitionStates = $partitionStates;
69 | 
70 |         return $this;
71 |     }
72 | }
73 | 


--------------------------------------------------------------------------------
/src/Protocol/StopReplica/StopReplicaTopicV1.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace longlang\phpkafka\Protocol\StopReplica;
 6 | 
 7 | use longlang\phpkafka\Protocol\AbstractStruct;
 8 | use longlang\phpkafka\Protocol\ProtocolField;
 9 | 
10 | class StopReplicaTopicV1 extends AbstractStruct
11 | {
12 |     /**
13 |      * The topic name.
14 |      *
15 |      * @var string
16 |      */
17 |     protected $name = '';
18 | 
19 |     /**
20 |      * The partition indexes.
21 |      *
22 |      * @var int[]
23 |      */
24 |     protected $partitionIndexes = [];
25 | 
26 |     public function __construct()
27 |     {
28 |         if (!isset(self::$maps[self::class])) {
29 |             self::$maps[self::class] = [
30 |                 new ProtocolField('name', 'string', false, [1, 2], [2, 3], [], [], null),
31 |                 new ProtocolField('partitionIndexes', 'int32', true, [1, 2], [2, 3], [], [], null),
32 |             ];
33 |             self::$taggedFieldses[self::class] = [
34 |             ];
35 |         }
36 |     }
37 | 
38 |     public function getFlexibleVersions(): array
39 |     {
40 |         return [2, 3];
41 |     }
42 | 
43 |     public function getName(): string
44 |     {
45 |         return $this->name;
46 |     }
47 | 
48 |     public function setName(string $name): self
49 |     {
50 |         $this->name = $name;
51 | 
52 |         return $this;
53 |     }
54 | 
55 |     /**
56 |      * @return int[]
57 |      */
58 |     public function getPartitionIndexes(): array
59 |     {
60 |         return $this->partitionIndexes;
61 |     }
62 | 
63 |     /**
64 |      * @param int[] $partitionIndexes
65 |      */
66 |     public function setPartitionIndexes(array $partitionIndexes): self
67 |     {
68 |         $this->partitionIndexes = $partitionIndexes;
69 | 
70 |         return $this;
71 |     }
72 | }
73 | 


--------------------------------------------------------------------------------
/src/Protocol/SyncGroup/SyncGroupRequestAssignment.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace longlang\phpkafka\Protocol\SyncGroup;
 6 | 
 7 | use longlang\phpkafka\Protocol\AbstractStruct;
 8 | use longlang\phpkafka\Protocol\ProtocolField;
 9 | 
10 | class SyncGroupRequestAssignment extends AbstractStruct
11 | {
12 |     /**
13 |      * The ID of the member to assign.
14 |      *
15 |      * @var string
16 |      */
17 |     protected $memberId = '';
18 | 
19 |     /**
20 |      * The member assignment.
21 |      *
22 |      * @var string
23 |      */
24 |     protected $assignment = '';
25 | 
26 |     public function __construct()
27 |     {
28 |         if (!isset(self::$maps[self::class])) {
29 |             self::$maps[self::class] = [
30 |                 new ProtocolField('memberId', 'string', false, [0, 1, 2, 3, 4, 5], [4, 5], [], [], null),
31 |                 new ProtocolField('assignment', 'bytes', false, [0, 1, 2, 3, 4, 5], [4, 5], [], [], null),
32 |             ];
33 |             self::$taggedFieldses[self::class] = [
34 |             ];
35 |         }
36 |     }
37 | 
38 |     public function getFlexibleVersions(): array
39 |     {
40 |         return [4, 5];
41 |     }
42 | 
43 |     public function getMemberId(): string
44 |     {
45 |         return $this->memberId;
46 |     }
47 | 
48 |     public function setMemberId(string $memberId): self
49 |     {
50 |         $this->memberId = $memberId;
51 | 
52 |         return $this;
53 |     }
54 | 
55 |     public function getAssignment(): string
56 |     {
57 |         return $this->assignment;
58 |     }
59 | 
60 |     public function setAssignment(string $assignment): self
61 |     {
62 |         $this->assignment = $assignment;
63 | 
64 |         return $this;
65 |     }
66 | }
67 | 


--------------------------------------------------------------------------------
/src/Protocol/TxnOffsetCommit/TxnOffsetCommitRequestTopic.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace longlang\phpkafka\Protocol\TxnOffsetCommit;
 6 | 
 7 | use longlang\phpkafka\Protocol\AbstractStruct;
 8 | use longlang\phpkafka\Protocol\ProtocolField;
 9 | 
10 | class TxnOffsetCommitRequestTopic extends AbstractStruct
11 | {
12 |     /**
13 |      * The topic name.
14 |      *
15 |      * @var string
16 |      */
17 |     protected $name = '';
18 | 
19 |     /**
20 |      * The partitions inside the topic that we want to committ offsets for.
21 |      *
22 |      * @var TxnOffsetCommitRequestPartition[]
23 |      */
24 |     protected $partitions = [];
25 | 
26 |     public function __construct()
27 |     {
28 |         if (!isset(self::$maps[self::class])) {
29 |             self::$maps[self::class] = [
30 |                 new ProtocolField('name', 'string', false, [0, 1, 2, 3], [3], [], [], null),
31 |                 new ProtocolField('partitions', TxnOffsetCommitRequestPartition::class, true, [0, 1, 2, 3], [3], [], [], null),
32 |             ];
33 |             self::$taggedFieldses[self::class] = [
34 |             ];
35 |         }
36 |     }
37 | 
38 |     public function getFlexibleVersions(): array
39 |     {
40 |         return [3];
41 |     }
42 | 
43 |     public function getName(): string
44 |     {
45 |         return $this->name;
46 |     }
47 | 
48 |     public function setName(string $name): self
49 |     {
50 |         $this->name = $name;
51 | 
52 |         return $this;
53 |     }
54 | 
55 |     /**
56 |      * @return TxnOffsetCommitRequestPartition[]
57 |      */
58 |     public function getPartitions(): array
59 |     {
60 |         return $this->partitions;
61 |     }
62 | 
63 |     /**
64 |      * @param TxnOffsetCommitRequestPartition[] $partitions
65 |      */
66 |     public function setPartitions(array $partitions): self
67 |     {
68 |         $this->partitions = $partitions;
69 | 
70 |         return $this;
71 |     }
72 | }
73 | 


--------------------------------------------------------------------------------
/src/Protocol/TxnOffsetCommit/TxnOffsetCommitResponsePartition.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace longlang\phpkafka\Protocol\TxnOffsetCommit;
 6 | 
 7 | use longlang\phpkafka\Protocol\AbstractStruct;
 8 | use longlang\phpkafka\Protocol\ProtocolField;
 9 | 
10 | class TxnOffsetCommitResponsePartition extends AbstractStruct
11 | {
12 |     /**
13 |      * The partition index.
14 |      *
15 |      * @var int
16 |      */
17 |     protected $partitionIndex = 0;
18 | 
19 |     /**
20 |      * The error code, or 0 if there was no error.
21 |      *
22 |      * @var int
23 |      */
24 |     protected $errorCode = 0;
25 | 
26 |     public function __construct()
27 |     {
28 |         if (!isset(self::$maps[self::class])) {
29 |             self::$maps[self::class] = [
30 |                 new ProtocolField('partitionIndex', 'int32', false, [0, 1, 2, 3], [3], [], [], null),
31 |                 new ProtocolField('errorCode', 'int16', false, [0, 1, 2, 3], [3], [], [], null),
32 |             ];
33 |             self::$taggedFieldses[self::class] = [
34 |             ];
35 |         }
36 |     }
37 | 
38 |     public function getFlexibleVersions(): array
39 |     {
40 |         return [3];
41 |     }
42 | 
43 |     public function getPartitionIndex(): int
44 |     {
45 |         return $this->partitionIndex;
46 |     }
47 | 
48 |     public function setPartitionIndex(int $partitionIndex): self
49 |     {
50 |         $this->partitionIndex = $partitionIndex;
51 | 
52 |         return $this;
53 |     }
54 | 
55 |     public function getErrorCode(): int
56 |     {
57 |         return $this->errorCode;
58 |     }
59 | 
60 |     public function setErrorCode(int $errorCode): self
61 |     {
62 |         $this->errorCode = $errorCode;
63 | 
64 |         return $this;
65 |     }
66 | }
67 | 


--------------------------------------------------------------------------------
/src/Protocol/TxnOffsetCommit/TxnOffsetCommitResponseTopic.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace longlang\phpkafka\Protocol\TxnOffsetCommit;
 6 | 
 7 | use longlang\phpkafka\Protocol\AbstractStruct;
 8 | use longlang\phpkafka\Protocol\ProtocolField;
 9 | 
10 | class TxnOffsetCommitResponseTopic extends AbstractStruct
11 | {
12 |     /**
13 |      * The topic name.
14 |      *
15 |      * @var string
16 |      */
17 |     protected $name = '';
18 | 
19 |     /**
20 |      * The responses for each partition in the topic.
21 |      *
22 |      * @var TxnOffsetCommitResponsePartition[]
23 |      */
24 |     protected $partitions = [];
25 | 
26 |     public function __construct()
27 |     {
28 |         if (!isset(self::$maps[self::class])) {
29 |             self::$maps[self::class] = [
30 |                 new ProtocolField('name', 'string', false, [0, 1, 2, 3], [3], [], [], null),
31 |                 new ProtocolField('partitions', TxnOffsetCommitResponsePartition::class, true, [0, 1, 2, 3], [3], [], [], null),
32 |             ];
33 |             self::$taggedFieldses[self::class] = [
34 |             ];
35 |         }
36 |     }
37 | 
38 |     public function getFlexibleVersions(): array
39 |     {
40 |         return [3];
41 |     }
42 | 
43 |     public function getName(): string
44 |     {
45 |         return $this->name;
46 |     }
47 | 
48 |     public function setName(string $name): self
49 |     {
50 |         $this->name = $name;
51 | 
52 |         return $this;
53 |     }
54 | 
55 |     /**
56 |      * @return TxnOffsetCommitResponsePartition[]
57 |      */
58 |     public function getPartitions(): array
59 |     {
60 |         return $this->partitions;
61 |     }
62 | 
63 |     /**
64 |      * @param TxnOffsetCommitResponsePartition[] $partitions
65 |      */
66 |     public function setPartitions(array $partitions): self
67 |     {
68 |         $this->partitions = $partitions;
69 | 
70 |         return $this;
71 |     }
72 | }
73 | 


--------------------------------------------------------------------------------
/src/Protocol/Type/AbstractType.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace longlang\phpkafka\Protocol\Type;
 6 | 
 7 | abstract class AbstractType
 8 | {
 9 |     private function __construct()
10 |     {
11 |     }
12 | }
13 | 


--------------------------------------------------------------------------------
/src/Protocol/Type/Boolean.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace longlang\phpkafka\Protocol\Type;
 6 | 
 7 | class Boolean extends AbstractType
 8 | {
 9 |     public const FORAMT = 'c';
10 | 
11 |     private function __construct()
12 |     {
13 |     }
14 | 
15 |     public static function pack(bool $value): string
16 |     {
17 |         return pack(self::FORAMT, $value);
18 |     }
19 | 
20 |     public static function unpack(string $value, ?int &$size = null): bool
21 |     {
22 |         $size = 1;
23 | 
24 |         return 1 === unpack(self::FORAMT, $value)[1];
25 |     }
26 | }
27 | 


--------------------------------------------------------------------------------
/src/Protocol/Type/CompactNullableString.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace longlang\phpkafka\Protocol\Type;
 6 | 
 7 | class CompactNullableString extends AbstractType
 8 | {
 9 |     private function __construct()
10 |     {
11 |     }
12 | 
13 |     public static function pack(?string $value): string
14 |     {
15 |         if (null === $value) {
16 |             $length = 0;
17 |         } else {
18 |             $length = \strlen($value) + 1;
19 |         }
20 | 
21 |         return UVarInt::pack($length) . $value;
22 |     }
23 | 
24 |     public static function unpack(string $value, ?int &$size = null): ?string
25 |     {
26 |         $length = UVarInt::unpack($value, $size) - 1;
27 |         if (-1 === $length) {
28 |             return null;
29 |         }
30 |         $result = substr($value, $size, $length);
31 |         $size += $length;
32 | 
33 |         return $result;
34 |     }
35 | }
36 | 


--------------------------------------------------------------------------------
/src/Protocol/Type/CompactString.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace longlang\phpkafka\Protocol\Type;
 6 | 
 7 | class CompactString extends AbstractType
 8 | {
 9 |     private function __construct()
10 |     {
11 |     }
12 | 
13 |     public static function pack(string $value): string
14 |     {
15 |         return UVarInt::pack(\strlen($value) + 1) . $value;
16 |     }
17 | 
18 |     public static function unpack(string $value, ?int &$size = null): string
19 |     {
20 |         $length = UVarInt::unpack($value, $size) - 1;
21 |         $result = substr($value, $size, $length);
22 |         $size += $length;
23 | 
24 |         return $result;
25 |     }
26 | }
27 | 


--------------------------------------------------------------------------------
/src/Protocol/Type/Float64.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace longlang\phpkafka\Protocol\Type;
 6 | 
 7 | class Float64 extends AbstractType
 8 | {
 9 |     public const FORAMT = 'E';
10 | 
11 |     private function __construct()
12 |     {
13 |     }
14 | 
15 |     public static function pack(float $value): string
16 |     {
17 |         return pack(self::FORAMT, $value);
18 |     }
19 | 
20 |     public static function unpack(string $value, ?int &$size = null): float
21 |     {
22 |         $size = 8;
23 | 
24 |         return unpack(self::FORAMT, $value)[1];
25 |     }
26 | }
27 | 


--------------------------------------------------------------------------------
/src/Protocol/Type/Int16.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace longlang\phpkafka\Protocol\Type;
 6 | 
 7 | use InvalidArgumentException;
 8 | use longlang\phpkafka\Protocol\ProtocolUtil;
 9 | 
10 | class Int16 extends AbstractType
11 | {
12 |     public const FORAMT = 's';
13 | 
14 |     public const MIN_VALUE = -32768;
15 | 
16 |     public const MAX_VALUE = 32767;
17 | 
18 |     private function __construct()
19 |     {
20 |     }
21 | 
22 |     public static function pack(int $value): string
23 |     {
24 |         if ($value < self::MIN_VALUE || $value > self::MAX_VALUE) {
25 |             throw new InvalidArgumentException(sprintf('%s is outside the range of Int16', $value));
26 |         }
27 |         $result = pack(self::FORAMT, $value);
28 |         if (!ProtocolUtil::nativeIsBigEndian()) {
29 |             $result = strrev($result);
30 |         }
31 | 
32 |         return $result;
33 |     }
34 | 
35 |     public static function unpack(string $value, ?int &$size = null): int
36 |     {
37 |         $value = substr($value, 0, 2);
38 |         if (!ProtocolUtil::nativeIsBigEndian()) {
39 |             $value = strrev($value);
40 |         }
41 |         $size = 2;
42 | 
43 |         return unpack(self::FORAMT, $value)[1];
44 |     }
45 | }
46 | 


--------------------------------------------------------------------------------
/src/Protocol/Type/Int32.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace longlang\phpkafka\Protocol\Type;
 6 | 
 7 | use InvalidArgumentException;
 8 | use longlang\phpkafka\Protocol\ProtocolUtil;
 9 | 
10 | class Int32 extends AbstractType
11 | {
12 |     public const FORAMT = 'l';
13 | 
14 |     public const MIN_VALUE = -2147483648;
15 | 
16 |     public const MAX_VALUE = 2147483647;
17 | 
18 |     private function __construct()
19 |     {
20 |     }
21 | 
22 |     public static function pack(int $value): string
23 |     {
24 |         if ($value < self::MIN_VALUE || $value > self::MAX_VALUE) {
25 |             throw new InvalidArgumentException(sprintf('%s is outside the range of Int32', $value));
26 |         }
27 |         $result = pack(self::FORAMT, $value);
28 |         if (!ProtocolUtil::nativeIsBigEndian()) {
29 |             $result = strrev($result);
30 |         }
31 | 
32 |         return $result;
33 |     }
34 | 
35 |     public static function unpack(string $value, ?int &$size = null): int
36 |     {
37 |         $value = substr($value, 0, 4);
38 |         if (!ProtocolUtil::nativeIsBigEndian()) {
39 |             $value = strrev($value);
40 |         }
41 |         $size = 4;
42 | 
43 |         return unpack(self::FORAMT, $value)[1];
44 |     }
45 | }
46 | 


--------------------------------------------------------------------------------
/src/Protocol/Type/Int64.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace longlang\phpkafka\Protocol\Type;
 6 | 
 7 | use InvalidArgumentException;
 8 | use longlang\phpkafka\Protocol\ProtocolUtil;
 9 | 
10 | class Int64 extends AbstractType
11 | {
12 |     public const FORAMT = 'q';
13 | 
14 |     public const MIN_VALUE = \PHP_INT_MIN;
15 | 
16 |     public const MAX_VALUE = \PHP_INT_MAX;
17 | 
18 |     private function __construct()
19 |     {
20 |     }
21 | 
22 |     public static function pack(int $value): string
23 |     {
24 |         if ($value < self::MIN_VALUE || $value > self::MAX_VALUE) {
25 |             throw new InvalidArgumentException(sprintf('%s is outside the range of Int64', $value));
26 |         }
27 |         $result = pack(self::FORAMT, $value);
28 |         if (!ProtocolUtil::nativeIsBigEndian()) {
29 |             $result = strrev($result);
30 |         }
31 | 
32 |         return $result;
33 |     }
34 | 
35 |     public static function unpack(string $value, ?int &$size = null): int
36 |     {
37 |         $value = substr($value, 0, 8);
38 |         if (!ProtocolUtil::nativeIsBigEndian()) {
39 |             $value = strrev($value);
40 |         }
41 |         $size = 8;
42 | 
43 |         return unpack(self::FORAMT, $value)[1];
44 |     }
45 | }
46 | 


--------------------------------------------------------------------------------
/src/Protocol/Type/Int8.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace longlang\phpkafka\Protocol\Type;
 6 | 
 7 | use InvalidArgumentException;
 8 | 
 9 | class Int8 extends AbstractType
10 | {
11 |     public const FORAMT = 'c';
12 | 
13 |     public const MIN_VALUE = -128;
14 | 
15 |     public const MAX_VALUE = 127;
16 | 
17 |     private function __construct()
18 |     {
19 |     }
20 | 
21 |     public static function pack(int $value): string
22 |     {
23 |         if ($value < self::MIN_VALUE || $value > self::MAX_VALUE) {
24 |             throw new InvalidArgumentException(sprintf('%s is outside the range of Int8', $value));
25 |         }
26 | 
27 |         return pack(self::FORAMT, $value);
28 |     }
29 | 
30 |     public static function unpack(string $value, ?int &$size = null): int
31 |     {
32 |         $size = 1;
33 | 
34 |         return unpack(self::FORAMT, $value)[1];
35 |     }
36 | }
37 | 


--------------------------------------------------------------------------------
/src/Protocol/Type/NullableString.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace longlang\phpkafka\Protocol\Type;
 6 | 
 7 | class NullableString extends AbstractType
 8 | {
 9 |     private function __construct()
10 |     {
11 |     }
12 | 
13 |     public static function pack(?string $value): string
14 |     {
15 |         if (null === $value) {
16 |             $length = -1;
17 |         } else {
18 |             $length = \strlen($value);
19 |         }
20 | 
21 |         return Int16::pack($length) . $value;
22 |     }
23 | 
24 |     public static function unpack(string $value, ?int &$size = null): ?string
25 |     {
26 |         $length = Int16::unpack($value, $size);
27 |         if (-1 === $length) {
28 |             return null;
29 |         }
30 |         $result = substr($value, $size, $length);
31 |         $size += $length;
32 | 
33 |         return $result;
34 |     }
35 | }
36 | 


--------------------------------------------------------------------------------
/src/Protocol/Type/NullableString32.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace longlang\phpkafka\Protocol\Type;
 6 | 
 7 | class NullableString32 extends AbstractType
 8 | {
 9 |     private function __construct()
10 |     {
11 |     }
12 | 
13 |     public static function pack(?string $value): string
14 |     {
15 |         if (null === $value) {
16 |             $length = -1;
17 |         } else {
18 |             $length = \strlen($value);
19 |         }
20 | 
21 |         return Int32::pack($length) . $value;
22 |     }
23 | 
24 |     public static function unpack(string $value, ?int &$size = null): ?string
25 |     {
26 |         $length = Int32::unpack($value, $size);
27 |         if (-1 === $length) {
28 |             return null;
29 |         }
30 |         $result = substr($value, $size, $length);
31 |         $size += $length;
32 | 
33 |         return $result;
34 |     }
35 | }
36 | 


--------------------------------------------------------------------------------
/src/Protocol/Type/String16.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace longlang\phpkafka\Protocol\Type;
 6 | 
 7 | class String16 extends AbstractType
 8 | {
 9 |     private function __construct()
10 |     {
11 |     }
12 | 
13 |     public static function pack(string $value): string
14 |     {
15 |         return Int16::pack(\strlen($value)) . $value;
16 |     }
17 | 
18 |     public static function unpack(string $value, ?int &$size = null): string
19 |     {
20 |         $length = Int16::unpack(substr($value, 0, 2), $size);
21 |         $result = substr($value, $size, $length);
22 |         $size += $length;
23 | 
24 |         return $result;
25 |     }
26 | }
27 | 


--------------------------------------------------------------------------------
/src/Protocol/Type/String32.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace longlang\phpkafka\Protocol\Type;
 6 | 
 7 | class String32 extends AbstractType
 8 | {
 9 |     private function __construct()
10 |     {
11 |     }
12 | 
13 |     public static function pack(string $value): string
14 |     {
15 |         return Int32::pack(\strlen($value)) . $value;
16 |     }
17 | 
18 |     public static function unpack(string $value, ?int &$size = null): string
19 |     {
20 |         $length = Int32::unpack(substr($value, 0, 4), $size);
21 |         $result = substr($value, $size, $length);
22 |         $size += $length;
23 | 
24 |         return $result;
25 |     }
26 | }
27 | 


--------------------------------------------------------------------------------
/src/Protocol/Type/TypeRelation.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace longlang\phpkafka\Protocol\Type;
 6 | 
 7 | class TypeRelation
 8 | {
 9 |     public const INDEX_PHP_TYPE = 0;
10 | 
11 |     public const INDEX_UNCOMPACT_TYPE = 1;
12 | 
13 |     public const INDEX_COMPACT_TYPE = 2;
14 | 
15 |     public const INDEX_NULLABLE_TYPE = 3;
16 | 
17 |     public const INDEX_COMPACT_NULLABLE_TYPE = 4;
18 | 
19 |     public const TYPE_RELATION = [
20 |         // kafka type => phptype, uncompactType, compactType, nullableType, compactNullableType
21 |         '[]'          => ['array', 'ArrayInt32', 'CompactArray', 'ArrayInt32', 'CompactArray'],
22 |         'bool'        => ['bool', 'Boolean', 'Boolean', 'Boolean', 'Boolean'],
23 |         'float64'     => ['float', 'Float64', 'Float64', 'Float64', 'Float64'],
24 |         'int8'        => ['int', 'Int8', 'Int8', 'Int8', 'Int8'],
25 |         'int16'       => ['int', 'Int16', 'Int16', 'Int16', 'Int16'],
26 |         'int32'       => ['int', 'Int32', 'Int32', 'Int32', 'Int32'],
27 |         'int64'       => ['int', 'Int64', 'Int64', 'Int64', 'Int64'],
28 |         'string'      => ['string', 'String16', 'CompactString', 'NullableString', 'CompactNullableString'],
29 |         'bytes'       => ['string', 'String32', 'CompactString', 'NullableString32', 'CompactNullableString'],
30 |         'varint'      => ['int', 'varint', 'varint', 'varint', 'varint'],
31 |         'RecordBatch' => ['\longlang\phpkafka\Protocol\RecordBatch\RecordBatch', '\longlang\phpkafka\Protocol\RecordBatch\RecordBatch', '\longlang\phpkafka\Protocol\RecordBatch\RecordBatch', '\longlang\phpkafka\Protocol\RecordBatch\RecordBatch'],
32 |     ];
33 | 
34 |     private function __construct()
35 |     {
36 |     }
37 | }
38 | 


--------------------------------------------------------------------------------
/src/Protocol/Type/UInt32.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace longlang\phpkafka\Protocol\Type;
 6 | 
 7 | use InvalidArgumentException;
 8 | 
 9 | class UInt32 extends AbstractType
10 | {
11 |     public const FORAMT = 'N';
12 | 
13 |     public const MIN_VALUE = 0;
14 | 
15 |     public const MAX_VALUE = 4294967295;
16 | 
17 |     private function __construct()
18 |     {
19 |     }
20 | 
21 |     public static function pack(int $value): string
22 |     {
23 |         if ($value < self::MIN_VALUE || $value > self::MAX_VALUE) {
24 |             throw new InvalidArgumentException(sprintf('%s is outside the range of UInt32', $value));
25 |         }
26 | 
27 |         return pack(self::FORAMT, $value);
28 |     }
29 | 
30 |     public static function unpack(string $value, ?int &$size = null): int
31 |     {
32 |         $size = 4;
33 | 
34 |         return unpack(self::FORAMT, $value)[1];
35 |     }
36 | }
37 | 


--------------------------------------------------------------------------------
/src/Protocol/Type/UVarInt.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace longlang\phpkafka\Protocol\Type;
 6 | 
 7 | use InvalidArgumentException;
 8 | use longlang\phpkafka\Protocol\ProtocolUtil;
 9 | 
10 | class UVarInt extends AbstractType
11 | {
12 |     public const MIN_VALUE = 0;
13 | 
14 |     public const MAX_VALUE = 4294967295;
15 | 
16 |     private function __construct()
17 |     {
18 |     }
19 | 
20 |     public static function pack(int $value): string
21 |     {
22 |         if ($value < self::MIN_VALUE || $value > self::MAX_VALUE) {
23 |             throw new InvalidArgumentException(sprintf('%s is outside the range of VarInt', $value));
24 |         }
25 |         $buffer = '';
26 |         while (0 != ($value & 0xffffff80)) {
27 |             $b = \chr(($value & 0x7f) | 0x80);
28 |             $buffer .= $b;
29 |             $value = ProtocolUtil::shr32($value, 7);
30 |         }
31 |         $buffer .= \chr($value);
32 | 
33 |         return $buffer;
34 |     }
35 | 
36 |     public static function unpack(string $value, ?int &$size = null): int
37 |     {
38 |         $result = 0;
39 |         $i = 0;
40 |         $size = 0;
41 |         while (0 != (($b = \ord($value[$size++])) & 0x80)) {
42 |             $result |= ($b & 0x7f) << $i;
43 |             $i += 7;
44 |             if ($i > 28) {
45 |                 throw new \InvalidArgumentException('illegal Varint');
46 |             }
47 |         }
48 |         $result |= $b << $i;
49 | 
50 |         return $result;
51 |     }
52 | 
53 |     public static function size(int $value): int
54 |     {
55 |         if (\PHP_INT_SIZE == 4 && $value < 0) {
56 |             return 5;
57 |         }
58 |         if ($value < (1 << 7)) {
59 |             return 1;
60 |         }
61 |         if ($value < (1 << 14)) {
62 |             return 2;
63 |         }
64 |         if ($value < (1 << 21)) {
65 |             return 3;
66 |         }
67 |         if ($value < (1 << 28)) {
68 |             return 4;
69 |         }
70 | 
71 |         return 5;
72 |     }
73 | }
74 | 


--------------------------------------------------------------------------------
/src/Protocol/Type/VarInt.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace longlang\phpkafka\Protocol\Type;
 6 | 
 7 | use longlang\phpkafka\Protocol\ProtocolUtil;
 8 | 
 9 | class VarInt extends AbstractType
10 | {
11 |     public const MIN_VALUE = -2147483648;
12 | 
13 |     public const MAX_VALUE = 2147483647;
14 | 
15 |     public static function pack(int $value): string
16 |     {
17 |         return UVarInt::pack(($value << 1) ^ ($value >> 31));
18 |     }
19 | 
20 |     public static function unpack(string $value, ?int &$size = null): int
21 |     {
22 |         $result = UVarInt::unpack($value, $size);
23 | 
24 |         return ProtocolUtil::shr32($result, 1) ^ -($result & 1);
25 |     }
26 | 
27 |     private function __construct()
28 |     {
29 |     }
30 | }
31 | 


--------------------------------------------------------------------------------
/src/Protocol/UpdateMetadata/UpdateMetadataResponse.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace longlang\phpkafka\Protocol\UpdateMetadata;
 6 | 
 7 | use longlang\phpkafka\Protocol\AbstractResponse;
 8 | use longlang\phpkafka\Protocol\ProtocolField;
 9 | 
10 | class UpdateMetadataResponse extends AbstractResponse
11 | {
12 |     /**
13 |      * The error code, or 0 if there was no error.
14 |      *
15 |      * @var int
16 |      */
17 |     protected $errorCode = 0;
18 | 
19 |     public function __construct()
20 |     {
21 |         if (!isset(self::$maps[self::class])) {
22 |             self::$maps[self::class] = [
23 |                 new ProtocolField('errorCode', 'int16', false, [0, 1, 2, 3, 4, 5, 6], [6], [], [], null),
24 |             ];
25 |             self::$taggedFieldses[self::class] = [
26 |             ];
27 |         }
28 |     }
29 | 
30 |     public function getRequestApiKey(): ?int
31 |     {
32 |         return 6;
33 |     }
34 | 
35 |     public function getFlexibleVersions(): array
36 |     {
37 |         return [6];
38 |     }
39 | 
40 |     public function getErrorCode(): int
41 |     {
42 |         return $this->errorCode;
43 |     }
44 | 
45 |     public function setErrorCode(int $errorCode): self
46 |     {
47 |         $this->errorCode = $errorCode;
48 | 
49 |         return $this;
50 |     }
51 | }
52 | 


--------------------------------------------------------------------------------
/src/Protocol/UpdateMetadata/UpdateMetadataTopicState.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace longlang\phpkafka\Protocol\UpdateMetadata;
 6 | 
 7 | use longlang\phpkafka\Protocol\AbstractStruct;
 8 | use longlang\phpkafka\Protocol\ProtocolField;
 9 | 
10 | class UpdateMetadataTopicState extends AbstractStruct
11 | {
12 |     /**
13 |      * The topic name.
14 |      *
15 |      * @var string
16 |      */
17 |     protected $topicName = '';
18 | 
19 |     /**
20 |      * The partition that we would like to update.
21 |      *
22 |      * @var UpdateMetadataPartitionState[]
23 |      */
24 |     protected $partitionStates = [];
25 | 
26 |     public function __construct()
27 |     {
28 |         if (!isset(self::$maps[self::class])) {
29 |             self::$maps[self::class] = [
30 |                 new ProtocolField('topicName', 'string', false, [5, 6], [6], [], [], null),
31 |                 new ProtocolField('partitionStates', UpdateMetadataPartitionState::class, true, [5, 6], [6], [], [], null),
32 |             ];
33 |             self::$taggedFieldses[self::class] = [
34 |             ];
35 |         }
36 |     }
37 | 
38 |     public function getFlexibleVersions(): array
39 |     {
40 |         return [6];
41 |     }
42 | 
43 |     public function getTopicName(): string
44 |     {
45 |         return $this->topicName;
46 |     }
47 | 
48 |     public function setTopicName(string $topicName): self
49 |     {
50 |         $this->topicName = $topicName;
51 | 
52 |         return $this;
53 |     }
54 | 
55 |     /**
56 |      * @return UpdateMetadataPartitionState[]
57 |      */
58 |     public function getPartitionStates(): array
59 |     {
60 |         return $this->partitionStates;
61 |     }
62 | 
63 |     /**
64 |      * @param UpdateMetadataPartitionState[] $partitionStates
65 |      */
66 |     public function setPartitionStates(array $partitionStates): self
67 |     {
68 |         $this->partitionStates = $partitionStates;
69 | 
70 |         return $this;
71 |     }
72 | }
73 | 


--------------------------------------------------------------------------------
/src/Protocol/WriteTxnMarkers/WritableTxnMarkerPartitionResult.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace longlang\phpkafka\Protocol\WriteTxnMarkers;
 6 | 
 7 | use longlang\phpkafka\Protocol\AbstractStruct;
 8 | use longlang\phpkafka\Protocol\ProtocolField;
 9 | 
10 | class WritableTxnMarkerPartitionResult extends AbstractStruct
11 | {
12 |     /**
13 |      * The partition index.
14 |      *
15 |      * @var int
16 |      */
17 |     protected $partitionIndex = 0;
18 | 
19 |     /**
20 |      * The error code, or 0 if there was no error.
21 |      *
22 |      * @var int
23 |      */
24 |     protected $errorCode = 0;
25 | 
26 |     public function __construct()
27 |     {
28 |         if (!isset(self::$maps[self::class])) {
29 |             self::$maps[self::class] = [
30 |                 new ProtocolField('partitionIndex', 'int32', false, [0], [], [], [], null),
31 |                 new ProtocolField('errorCode', 'int16', false, [0], [], [], [], null),
32 |             ];
33 |             self::$taggedFieldses[self::class] = [
34 |             ];
35 |         }
36 |     }
37 | 
38 |     public function getFlexibleVersions(): array
39 |     {
40 |         return [];
41 |     }
42 | 
43 |     public function getPartitionIndex(): int
44 |     {
45 |         return $this->partitionIndex;
46 |     }
47 | 
48 |     public function setPartitionIndex(int $partitionIndex): self
49 |     {
50 |         $this->partitionIndex = $partitionIndex;
51 | 
52 |         return $this;
53 |     }
54 | 
55 |     public function getErrorCode(): int
56 |     {
57 |         return $this->errorCode;
58 |     }
59 | 
60 |     public function setErrorCode(int $errorCode): self
61 |     {
62 |         $this->errorCode = $errorCode;
63 | 
64 |         return $this;
65 |     }
66 | }
67 | 


--------------------------------------------------------------------------------
/src/Protocol/WriteTxnMarkers/WritableTxnMarkerResult.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace longlang\phpkafka\Protocol\WriteTxnMarkers;
 6 | 
 7 | use longlang\phpkafka\Protocol\AbstractStruct;
 8 | use longlang\phpkafka\Protocol\ProtocolField;
 9 | 
10 | class WritableTxnMarkerResult extends AbstractStruct
11 | {
12 |     /**
13 |      * The current producer ID in use by the transactional ID.
14 |      *
15 |      * @var int
16 |      */
17 |     protected $producerId = 0;
18 | 
19 |     /**
20 |      * The results by topic.
21 |      *
22 |      * @var WritableTxnMarkerTopicResult[]
23 |      */
24 |     protected $topics = [];
25 | 
26 |     public function __construct()
27 |     {
28 |         if (!isset(self::$maps[self::class])) {
29 |             self::$maps[self::class] = [
30 |                 new ProtocolField('producerId', 'int64', false, [0], [], [], [], null),
31 |                 new ProtocolField('topics', WritableTxnMarkerTopicResult::class, true, [0], [], [], [], null),
32 |             ];
33 |             self::$taggedFieldses[self::class] = [
34 |             ];
35 |         }
36 |     }
37 | 
38 |     public function getFlexibleVersions(): array
39 |     {
40 |         return [];
41 |     }
42 | 
43 |     public function getProducerId(): int
44 |     {
45 |         return $this->producerId;
46 |     }
47 | 
48 |     public function setProducerId(int $producerId): self
49 |     {
50 |         $this->producerId = $producerId;
51 | 
52 |         return $this;
53 |     }
54 | 
55 |     /**
56 |      * @return WritableTxnMarkerTopicResult[]
57 |      */
58 |     public function getTopics(): array
59 |     {
60 |         return $this->topics;
61 |     }
62 | 
63 |     /**
64 |      * @param WritableTxnMarkerTopicResult[] $topics
65 |      */
66 |     public function setTopics(array $topics): self
67 |     {
68 |         $this->topics = $topics;
69 | 
70 |         return $this;
71 |     }
72 | }
73 | 


--------------------------------------------------------------------------------
/src/Protocol/WriteTxnMarkers/WritableTxnMarkerTopic.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace longlang\phpkafka\Protocol\WriteTxnMarkers;
 6 | 
 7 | use longlang\phpkafka\Protocol\AbstractStruct;
 8 | use longlang\phpkafka\Protocol\ProtocolField;
 9 | 
10 | class WritableTxnMarkerTopic extends AbstractStruct
11 | {
12 |     /**
13 |      * The topic name.
14 |      *
15 |      * @var string
16 |      */
17 |     protected $name = '';
18 | 
19 |     /**
20 |      * The indexes of the partitions to write transaction markers for.
21 |      *
22 |      * @var int[]
23 |      */
24 |     protected $partitionIndexes = [];
25 | 
26 |     public function __construct()
27 |     {
28 |         if (!isset(self::$maps[self::class])) {
29 |             self::$maps[self::class] = [
30 |                 new ProtocolField('name', 'string', false, [0], [], [], [], null),
31 |                 new ProtocolField('partitionIndexes', 'int32', true, [0], [], [], [], null),
32 |             ];
33 |             self::$taggedFieldses[self::class] = [
34 |             ];
35 |         }
36 |     }
37 | 
38 |     public function getFlexibleVersions(): array
39 |     {
40 |         return [];
41 |     }
42 | 
43 |     public function getName(): string
44 |     {
45 |         return $this->name;
46 |     }
47 | 
48 |     public function setName(string $name): self
49 |     {
50 |         $this->name = $name;
51 | 
52 |         return $this;
53 |     }
54 | 
55 |     /**
56 |      * @return int[]
57 |      */
58 |     public function getPartitionIndexes(): array
59 |     {
60 |         return $this->partitionIndexes;
61 |     }
62 | 
63 |     /**
64 |      * @param int[] $partitionIndexes
65 |      */
66 |     public function setPartitionIndexes(array $partitionIndexes): self
67 |     {
68 |         $this->partitionIndexes = $partitionIndexes;
69 | 
70 |         return $this;
71 |     }
72 | }
73 | 


--------------------------------------------------------------------------------
/src/Protocol/WriteTxnMarkers/WritableTxnMarkerTopicResult.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace longlang\phpkafka\Protocol\WriteTxnMarkers;
 6 | 
 7 | use longlang\phpkafka\Protocol\AbstractStruct;
 8 | use longlang\phpkafka\Protocol\ProtocolField;
 9 | 
10 | class WritableTxnMarkerTopicResult extends AbstractStruct
11 | {
12 |     /**
13 |      * The topic name.
14 |      *
15 |      * @var string
16 |      */
17 |     protected $name = '';
18 | 
19 |     /**
20 |      * The results by partition.
21 |      *
22 |      * @var WritableTxnMarkerPartitionResult[]
23 |      */
24 |     protected $partitions = [];
25 | 
26 |     public function __construct()
27 |     {
28 |         if (!isset(self::$maps[self::class])) {
29 |             self::$maps[self::class] = [
30 |                 new ProtocolField('name', 'string', false, [0], [], [], [], null),
31 |                 new ProtocolField('partitions', WritableTxnMarkerPartitionResult::class, true, [0], [], [], [], null),
32 |             ];
33 |             self::$taggedFieldses[self::class] = [
34 |             ];
35 |         }
36 |     }
37 | 
38 |     public function getFlexibleVersions(): array
39 |     {
40 |         return [];
41 |     }
42 | 
43 |     public function getName(): string
44 |     {
45 |         return $this->name;
46 |     }
47 | 
48 |     public function setName(string $name): self
49 |     {
50 |         $this->name = $name;
51 | 
52 |         return $this;
53 |     }
54 | 
55 |     /**
56 |      * @return WritableTxnMarkerPartitionResult[]
57 |      */
58 |     public function getPartitions(): array
59 |     {
60 |         return $this->partitions;
61 |     }
62 | 
63 |     /**
64 |      * @param WritableTxnMarkerPartitionResult[] $partitions
65 |      */
66 |     public function setPartitions(array $partitions): self
67 |     {
68 |         $this->partitions = $partitions;
69 | 
70 |         return $this;
71 |     }
72 | }
73 | 


--------------------------------------------------------------------------------
/src/Protocol/WriteTxnMarkers/WriteTxnMarkersRequest.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace longlang\phpkafka\Protocol\WriteTxnMarkers;
 6 | 
 7 | use longlang\phpkafka\Protocol\AbstractRequest;
 8 | use longlang\phpkafka\Protocol\ProtocolField;
 9 | 
10 | class WriteTxnMarkersRequest extends AbstractRequest
11 | {
12 |     /**
13 |      * The transaction markers to be written.
14 |      *
15 |      * @var WritableTxnMarker[]
16 |      */
17 |     protected $markers = [];
18 | 
19 |     public function __construct()
20 |     {
21 |         if (!isset(self::$maps[self::class])) {
22 |             self::$maps[self::class] = [
23 |                 new ProtocolField('markers', WritableTxnMarker::class, true, [0], [], [], [], null),
24 |             ];
25 |             self::$taggedFieldses[self::class] = [
26 |             ];
27 |         }
28 |     }
29 | 
30 |     public function getRequestApiKey(): ?int
31 |     {
32 |         return 27;
33 |     }
34 | 
35 |     public function getMaxSupportedVersion(): int
36 |     {
37 |         return 0;
38 |     }
39 | 
40 |     public function getFlexibleVersions(): array
41 |     {
42 |         return [];
43 |     }
44 | 
45 |     /**
46 |      * @return WritableTxnMarker[]
47 |      */
48 |     public function getMarkers(): array
49 |     {
50 |         return $this->markers;
51 |     }
52 | 
53 |     /**
54 |      * @param WritableTxnMarker[] $markers
55 |      */
56 |     public function setMarkers(array $markers): self
57 |     {
58 |         $this->markers = $markers;
59 | 
60 |         return $this;
61 |     }
62 | }
63 | 


--------------------------------------------------------------------------------
/src/Protocol/WriteTxnMarkers/WriteTxnMarkersResponse.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace longlang\phpkafka\Protocol\WriteTxnMarkers;
 6 | 
 7 | use longlang\phpkafka\Protocol\AbstractResponse;
 8 | use longlang\phpkafka\Protocol\ProtocolField;
 9 | 
10 | class WriteTxnMarkersResponse extends AbstractResponse
11 | {
12 |     /**
13 |      * The results for writing makers.
14 |      *
15 |      * @var WritableTxnMarkerResult[]
16 |      */
17 |     protected $markers = [];
18 | 
19 |     public function __construct()
20 |     {
21 |         if (!isset(self::$maps[self::class])) {
22 |             self::$maps[self::class] = [
23 |                 new ProtocolField('markers', WritableTxnMarkerResult::class, true, [0], [], [], [], null),
24 |             ];
25 |             self::$taggedFieldses[self::class] = [
26 |             ];
27 |         }
28 |     }
29 | 
30 |     public function getRequestApiKey(): ?int
31 |     {
32 |         return 27;
33 |     }
34 | 
35 |     public function getFlexibleVersions(): array
36 |     {
37 |         return [];
38 |     }
39 | 
40 |     /**
41 |      * @return WritableTxnMarkerResult[]
42 |      */
43 |     public function getMarkers(): array
44 |     {
45 |         return $this->markers;
46 |     }
47 | 
48 |     /**
49 |      * @param WritableTxnMarkerResult[] $markers
50 |      */
51 |     public function setMarkers(array $markers): self
52 |     {
53 |         $this->markers = $markers;
54 | 
55 |         return $this;
56 |     }
57 | }
58 | 


--------------------------------------------------------------------------------
/src/Sasl/PlainSasl.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace longlang\phpkafka\Sasl;
 6 | 
 7 | use longlang\phpkafka\Config\CommonConfig;
 8 | use longlang\phpkafka\Exception\KafkaErrorException;
 9 | 
10 | class PlainSasl implements SaslInterface
11 | {
12 |     /**
13 |      * @var CommonConfig
14 |      */
15 |     protected $config;
16 | 
17 |     public function __construct(CommonConfig $config)
18 |     {
19 |         $this->config = $config;
20 |     }
21 | 
22 |     /**
23 |      * 授权模式.
24 |      */
25 |     public function getName(): string
26 |     {
27 |         return 'PLAIN';
28 |     }
29 | 
30 |     /**
31 |      * 获得加密串.
32 |      */
33 |     public function getAuthBytes(): string
34 |     {
35 |         $config = $this->config->getSasl();
36 |         if (empty($config['username']) || empty($config['password'])) {
37 |             // 不存在就报错
38 |             throw new KafkaErrorException('sasl not found auth info');
39 |         }
40 | 
41 |         return sprintf("\x00%s\x00%s", $config['username'], $config['password']);
42 |     }
43 | }
44 | 


--------------------------------------------------------------------------------
/src/Sasl/SaslInterface.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace longlang\phpkafka\Sasl;
 6 | 
 7 | use longlang\phpkafka\Config\CommonConfig;
 8 | 
 9 | interface SaslInterface
10 | {
11 |     public function __construct(CommonConfig $config);
12 | 
13 |     /**
14 |      * 获得授权名称.
15 |      */
16 |     public function getName(): string;
17 | 
18 |     /**
19 |      * 返回授权信息.
20 |      */
21 |     public function getAuthBytes(): string;
22 | }
23 | 


--------------------------------------------------------------------------------
/src/Socket/SocketInterface.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace longlang\phpkafka\Socket;
 6 | 
 7 | use longlang\phpkafka\Config\CommonConfig;
 8 | 
 9 | interface SocketInterface
10 | {
11 |     public function __construct(string $host, int $port, ?CommonConfig $config = null);
12 | 
13 |     public function getHost(): string;
14 | 
15 |     public function getPort(): int;
16 | 
17 |     public function getConfig(): CommonConfig;
18 | 
19 |     public function isConnected(): bool;
20 | 
21 |     public function connect(): void;
22 | 
23 |     public function close(): bool;
24 | 
25 |     public function send(string $data, ?float $timeout = null): int;
26 | 
27 |     public function recv(int $length, ?float $timeout = null): string;
28 | }
29 | 


--------------------------------------------------------------------------------
/src/Timer/NoopTimer.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace longlang\phpkafka\Timer;
 6 | 
 7 | class NoopTimer implements TimerInterface
 8 | {
 9 |     public function tick(int $interval, callable $callback): int
10 |     {
11 |         return 0;
12 |     }
13 | 
14 |     public function clear(int $timerId): void
15 |     {
16 |     }
17 | }
18 | 


--------------------------------------------------------------------------------
/src/Timer/SwooleTimer.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace longlang\phpkafka\Timer;
 6 | 
 7 | use Swoole\Timer;
 8 | 
 9 | class SwooleTimer implements TimerInterface
10 | {
11 |     public function tick(int $interval, callable $callback): int
12 |     {
13 |         return Timer::tick($interval, $callback);
14 |     }
15 | 
16 |     public function clear(int $timerId): void
17 |     {
18 |         Timer::clear($timerId);
19 |     }
20 | }
21 | 


--------------------------------------------------------------------------------
/src/Timer/TimerInterface.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace longlang\phpkafka\Timer;
 6 | 
 7 | interface TimerInterface
 8 | {
 9 |     public function tick(int $interval, callable $callback): int;
10 | 
11 |     public function clear(int $timerId): void;
12 | }
13 | 


--------------------------------------------------------------------------------
/src/Util/ArrayUtil.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace longlang\phpkafka\Util;
 6 | 
 7 | class ArrayUtil
 8 | {
 9 |     private function __construct()
10 |     {
11 |     }
12 | 
13 |     public static function indexOfSubList(array $source, array $target): int
14 |     {
15 |         if (!$source || !$target) {
16 |             return -1;
17 |         }
18 |         $sourceSize = \count($source);
19 |         $targetSize = \count($target);
20 |         $maxCandidate = $sourceSize - $targetSize;
21 | 
22 |         for ($i = 0; $i <= $maxCandidate; ++$i) {
23 |             $targetFirstValue = reset($target);
24 |             next($target);
25 |             $sourceValue = current($source);
26 |             next($source);
27 |             if ($sourceValue !== $targetFirstValue) {
28 |                 continue;
29 |             }
30 |             for ($j = 1; $j < $targetSize; ++$j) {
31 |                 $sourceValue = current($source);
32 |                 next($source);
33 |                 $targetValue = current($target);
34 |                 next($target);
35 |                 if ($sourceValue !== $targetValue) {
36 |                     for ($k = 0; $k < $j; ++$k) {
37 |                         prev($source);
38 |                     }
39 |                     continue 2;
40 |                 }
41 |             }
42 | 
43 |             return $i;
44 |         }
45 | 
46 |         return -1;
47 |     }
48 | }
49 | 


--------------------------------------------------------------------------------