codec

package
v1.0.0-preview.3 Latest Latest
Warning

This package is not in the latest version of its module.

 Go to latest Published: Jun 8, 2021 License: Apache-2.0 Imports: 7 Imported by: 0

Documentation

Overview

  • Copyright (c) 2008-2021, Hazelcast, Inc. All Rights Reserved. *

  • Licensed under the Apache License, Version 2.0 (the "License")

  • you may not use this file except in compliance with the License.

  • You may obtain a copy of the License at *

  • http://www.apache.org/licenses/LICENSE-2.0 *

  • Unless required by applicable law or agreed to in writing, software

  • distributed under the License is distributed on an "AS IS" BASIS,

  • WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

  • See the License for the specific language governing permissions and

  • limitations under the License.

  • Copyright (c) 2008-2021, Hazelcast, Inc. All Rights Reserved. *

  • Licensed under the Apache License, Version 2.0 (the "License")

  • you may not use this file except in compliance with the License.

  • You may obtain a copy of the License at *

  • http://www.apache.org/licenses/LICENSE-2.0 *

  • Unless required by applicable law or agreed to in writing, software

  • distributed under the License is distributed on an "AS IS" BASIS,

  • WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

  • See the License for the specific language governing permissions and

  • limitations under the License.

  • Copyright (c) 2008-2021, Hazelcast, Inc. All Rights Reserved. *

  • Licensed under the Apache License, Version 2.0 (the "License")

  • you may not use this file except in compliance with the License.

  • You may obtain a copy of the License at *

  • http://www.apache.org/licenses/LICENSE-2.0 *

  • Unless required by applicable law or agreed to in writing, software

  • distributed under the License is distributed on an "AS IS" BASIS,

  • WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

  • See the License for the specific language governing permissions and

  • limitations under the License.

  • Copyright (c) 2008-2021, Hazelcast, Inc. All Rights Reserved. *

  • Licensed under the Apache License, Version 2.0 (the "License")

  • you may not use this file except in compliance with the License.

  • You may obtain a copy of the License at *

  • http://www.apache.org/licenses/LICENSE-2.0 *

  • Unless required by applicable law or agreed to in writing, software

  • distributed under the License is distributed on an "AS IS" BASIS,

  • WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

  • See the License for the specific language governing permissions and

  • limitations under the License.

  • Copyright (c) 2008-2021, Hazelcast, Inc. All Rights Reserved. *

  • Licensed under the Apache License, Version 2.0 (the "License")

  • you may not use this file except in compliance with the License.

  • You may obtain a copy of the License at *

  • http://www.apache.org/licenses/LICENSE-2.0 *

  • Unless required by applicable law or agreed to in writing, software

  • distributed under the License is distributed on an "AS IS" BASIS,

  • WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

  • See the License for the specific language governing permissions and

  • limitations under the License.

  • Copyright (c) 2008-2021, Hazelcast, Inc. All Rights Reserved. *

  • Licensed under the Apache License, Version 2.0 (the "License")

  • you may not use this file except in compliance with the License.

  • You may obtain a copy of the License at *

  • http://www.apache.org/licenses/LICENSE-2.0 *

  • Unless required by applicable law or agreed to in writing, software

  • distributed under the License is distributed on an "AS IS" BASIS,

  • WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

  • See the License for the specific language governing permissions and

  • limitations under the License.

  • Copyright (c) 2008-2021, Hazelcast, Inc. All Rights Reserved. *

  • Licensed under the Apache License, Version 2.0 (the "License")

  • you may not use this file except in compliance with the License.

  • You may obtain a copy of the License at *

  • http://www.apache.org/licenses/LICENSE-2.0 *

  • Unless required by applicable law or agreed to in writing, software

  • distributed under the License is distributed on an "AS IS" BASIS,

  • WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

  • See the License for the specific language governing permissions and

  • limitations under the License.

  • Copyright (c) 2008-2021, Hazelcast, Inc. All Rights Reserved. *

  • Licensed under the Apache License, Version 2.0 (the "License")

  • you may not use this file except in compliance with the License.

  • You may obtain a copy of the License at *

  • http://www.apache.org/licenses/LICENSE-2.0 *

  • Unless required by applicable law or agreed to in writing, software

  • distributed under the License is distributed on an "AS IS" BASIS,

  • WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

  • See the License for the specific language governing permissions and

  • limitations under the License.

  • Copyright (c) 2008-2021, Hazelcast, Inc. All Rights Reserved. *

  • Licensed under the Apache License, Version 2.0 (the "License")

  • you may not use this file except in compliance with the License.

  • You may obtain a copy of the License at *

  • http://www.apache.org/licenses/LICENSE-2.0 *

  • Unless required by applicable law or agreed to in writing, software

  • distributed under the License is distributed on an "AS IS" BASIS,

  • WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

  • See the License for the specific language governing permissions and

  • limitations under the License.

  • Copyright (c) 2008-2021, Hazelcast, Inc. All Rights Reserved. *

  • Licensed under the Apache License, Version 2.0 (the "License")

  • you may not use this file except in compliance with the License.

  • You may obtain a copy of the License at *

  • http://www.apache.org/licenses/LICENSE-2.0 *

  • Unless required by applicable law or agreed to in writing, software

  • distributed under the License is distributed on an "AS IS" BASIS,

  • WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

  • See the License for the specific language governing permissions and

  • limitations under the License.

  • Copyright (c) 2008-2021, Hazelcast, Inc. All Rights Reserved. *

  • Licensed under the Apache License, Version 2.0 (the "License")

  • you may not use this file except in compliance with the License.

  • You may obtain a copy of the License at *

  • http://www.apache.org/licenses/LICENSE-2.0 *

  • Unless required by applicable law or agreed to in writing, software

  • distributed under the License is distributed on an "AS IS" BASIS,

  • WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

  • See the License for the specific language governing permissions and

  • limitations under the License.

  • Copyright (c) 2008-2021, Hazelcast, Inc. All Rights Reserved. *

  • Licensed under the Apache License, Version 2.0 (the "License")

  • you may not use this file except in compliance with the License.

  • You may obtain a copy of the License at *

  • http://www.apache.org/licenses/LICENSE-2.0 *

  • Unless required by applicable law or agreed to in writing, software

  • distributed under the License is distributed on an "AS IS" BASIS,

  • WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

  • See the License for the specific language governing permissions and

  • limitations under the License.

  • Copyright (c) 2008-2021, Hazelcast, Inc. All Rights Reserved. *

  • Licensed under the Apache License, Version 2.0 (the "License")

  • you may not use this file except in compliance with the License.

  • You may obtain a copy of the License at *

  • http://www.apache.org/licenses/LICENSE-2.0 *

  • Unless required by applicable law or agreed to in writing, software

  • distributed under the License is distributed on an "AS IS" BASIS,

  • WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

  • See the License for the specific language governing permissions and

  • limitations under the License.

  • Copyright (c) 2008-2021, Hazelcast, Inc. All Rights Reserved. *

  • Licensed under the Apache License, Version 2.0 (the "License")

  • you may not use this file except in compliance with the License.

  • You may obtain a copy of the License at *

  • http://www.apache.org/licenses/LICENSE-2.0 *

  • Unless required by applicable law or agreed to in writing, software

  • distributed under the License is distributed on an "AS IS" BASIS,

  • WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

  • See the License for the specific language governing permissions and

  • limitations under the License.

  • Copyright (c) 2008-2021, Hazelcast, Inc. All Rights Reserved. *

  • Licensed under the Apache License, Version 2.0 (the "License")

  • you may not use this file except in compliance with the License.

  • You may obtain a copy of the License at *

  • http://www.apache.org/licenses/LICENSE-2.0 *

  • Unless required by applicable law or agreed to in writing, software

  • distributed under the License is distributed on an "AS IS" BASIS,

  • WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

  • See the License for the specific language governing permissions and

  • limitations under the License.

  • Copyright (c) 2008-2021, Hazelcast, Inc. All Rights Reserved. *

  • Licensed under the Apache License, Version 2.0 (the "License")

  • you may not use this file except in compliance with the License.

  • You may obtain a copy of the License at *

  • http://www.apache.org/licenses/LICENSE-2.0 *

  • Unless required by applicable law or agreed to in writing, software

  • distributed under the License is distributed on an "AS IS" BASIS,

  • WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

  • See the License for the specific language governing permissions and

  • limitations under the License.

  • Copyright (c) 2008-2021, Hazelcast, Inc. All Rights Reserved. *

  • Licensed under the Apache License, Version 2.0 (the "License")

  • you may not use this file except in compliance with the License.

  • You may obtain a copy of the License at *

  • http://www.apache.org/licenses/LICENSE-2.0 *

  • Unless required by applicable law or agreed to in writing, software

  • distributed under the License is distributed on an "AS IS" BASIS,

  • WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

  • See the License for the specific language governing permissions and

  • limitations under the License.

  • Copyright (c) 2008-2021, Hazelcast, Inc. All Rights Reserved. *

  • Licensed under the Apache License, Version 2.0 (the "License")

  • you may not use this file except in compliance with the License.

  • You may obtain a copy of the License at *

  • http://www.apache.org/licenses/LICENSE-2.0 *

  • Unless required by applicable law or agreed to in writing, software

  • distributed under the License is distributed on an "AS IS" BASIS,

  • WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

  • See the License for the specific language governing permissions and

  • limitations under the License.

  • Copyright (c) 2008-2021, Hazelcast, Inc. All Rights Reserved. *

  • Licensed under the Apache License, Version 2.0 (the "License")

  • you may not use this file except in compliance with the License.

  • You may obtain a copy of the License at *

  • http://www.apache.org/licenses/LICENSE-2.0 *

  • Unless required by applicable law or agreed to in writing, software

  • distributed under the License is distributed on an "AS IS" BASIS,

  • WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

  • See the License for the specific language governing permissions and

  • limitations under the License.

  • Copyright (c) 2008-2021, Hazelcast, Inc. All Rights Reserved. *

  • Licensed under the Apache License, Version 2.0 (the "License")

  • you may not use this file except in compliance with the License.

  • You may obtain a copy of the License at *

  • http://www.apache.org/licenses/LICENSE-2.0 *

  • Unless required by applicable law or agreed to in writing, software

  • distributed under the License is distributed on an "AS IS" BASIS,

  • WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

  • See the License for the specific language governing permissions and

  • limitations under the License.

  • Copyright (c) 2008-2021, Hazelcast, Inc. All Rights Reserved. *

  • Licensed under the Apache License, Version 2.0 (the "License")

  • you may not use this file except in compliance with the License.

  • You may obtain a copy of the License at *

  • http://www.apache.org/licenses/LICENSE-2.0 *

  • Unless required by applicable law or agreed to in writing, software

  • distributed under the License is distributed on an "AS IS" BASIS,

  • WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

  • See the License for the specific language governing permissions and

  • limitations under the License.

  • Copyright (c) 2008-2021, Hazelcast, Inc. All Rights Reserved. *

  • Licensed under the Apache License, Version 2.0 (the "License")

  • you may not use this file except in compliance with the License.

  • You may obtain a copy of the License at *

  • http://www.apache.org/licenses/LICENSE-2.0 *

  • Unless required by applicable law or agreed to in writing, software

  • distributed under the License is distributed on an "AS IS" BASIS,

  • WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

  • See the License for the specific language governing permissions and

  • limitations under the License.

  • Copyright (c) 2008-2021, Hazelcast, Inc. All Rights Reserved. *

  • Licensed under the Apache License, Version 2.0 (the "License")

  • you may not use this file except in compliance with the License.

  • You may obtain a copy of the License at *

  • http://www.apache.org/licenses/LICENSE-2.0 *

  • Unless required by applicable law or agreed to in writing, software

  • distributed under the License is distributed on an "AS IS" BASIS,

  • WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

  • See the License for the specific language governing permissions and

  • limitations under the License.

  • Copyright (c) 2008-2021, Hazelcast, Inc. All Rights Reserved. *

  • Licensed under the Apache License, Version 2.0 (the "License")

  • you may not use this file except in compliance with the License.

  • You may obtain a copy of the License at *

  • http://www.apache.org/licenses/LICENSE-2.0 *

  • Unless required by applicable law or agreed to in writing, software

  • distributed under the License is distributed on an "AS IS" BASIS,

  • WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

  • See the License for the specific language governing permissions and

  • limitations under the License.

  • Copyright (c) 2008-2021, Hazelcast, Inc. All Rights Reserved. *

  • Licensed under the Apache License, Version 2.0 (the "License")

  • you may not use this file except in compliance with the License.

  • You may obtain a copy of the License at *

  • http://www.apache.org/licenses/LICENSE-2.0 *

  • Unless required by applicable law or agreed to in writing, software

  • distributed under the License is distributed on an "AS IS" BASIS,

  • WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

  • See the License for the specific language governing permissions and

  • limitations under the License.

  • Copyright (c) 2008-2021, Hazelcast, Inc. All Rights Reserved. *

  • Licensed under the Apache License, Version 2.0 (the "License")

  • you may not use this file except in compliance with the License.

  • You may obtain a copy of the License at *

  • http://www.apache.org/licenses/LICENSE-2.0 *

  • Unless required by applicable law or agreed to in writing, software

  • distributed under the License is distributed on an "AS IS" BASIS,

  • WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

  • See the License for the specific language governing permissions and

  • limitations under the License.

  • Copyright (c) 2008-2021, Hazelcast, Inc. All Rights Reserved. *

  • Licensed under the Apache License, Version 2.0 (the "License")

  • you may not use this file except in compliance with the License.

  • You may obtain a copy of the License at *

  • http://www.apache.org/licenses/LICENSE-2.0 *

  • Unless required by applicable law or agreed to in writing, software

  • distributed under the License is distributed on an "AS IS" BASIS,

  • WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

  • See the License for the specific language governing permissions and

  • limitations under the License.

  • Copyright (c) 2008-2021, Hazelcast, Inc. All Rights Reserved. *

  • Licensed under the Apache License, Version 2.0 (the "License")

  • you may not use this file except in compliance with the License.

  • You may obtain a copy of the License at *

  • http://www.apache.org/licenses/LICENSE-2.0 *

  • Unless required by applicable law or agreed to in writing, software

  • distributed under the License is distributed on an "AS IS" BASIS,

  • WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

  • See the License for the specific language governing permissions and

  • limitations under the License.

  • Copyright (c) 2008-2021, Hazelcast, Inc. All Rights Reserved. *

  • Licensed under the Apache License, Version 2.0 (the "License")

  • you may not use this file except in compliance with the License.

  • You may obtain a copy of the License at *

  • http://www.apache.org/licenses/LICENSE-2.0 *

  • Unless required by applicable law or agreed to in writing, software

  • distributed under the License is distributed on an "AS IS" BASIS,

  • WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

  • See the License for the specific language governing permissions and

  • limitations under the License.

  • Copyright (c) 2008-2021, Hazelcast, Inc. All Rights Reserved. *

  • Licensed under the Apache License, Version 2.0 (the "License")

  • you may not use this file except in compliance with the License.

  • You may obtain a copy of the License at *

  • http://www.apache.org/licenses/LICENSE-2.0 *

  • Unless required by applicable law or agreed to in writing, software

  • distributed under the License is distributed on an "AS IS" BASIS,

  • WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

  • See the License for the specific language governing permissions and

  • limitations under the License.

  • Copyright (c) 2008-2021, Hazelcast, Inc. All Rights Reserved. *

  • Licensed under the Apache License, Version 2.0 (the "License")

  • you may not use this file except in compliance with the License.

  • You may obtain a copy of the License at *

  • http://www.apache.org/licenses/LICENSE-2.0 *

  • Unless required by applicable law or agreed to in writing, software

  • distributed under the License is distributed on an "AS IS" BASIS,

  • WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

  • See the License for the specific language governing permissions and

  • limitations under the License.

  • Copyright (c) 2008-2021, Hazelcast, Inc. All Rights Reserved. *

  • Licensed under the Apache License, Version 2.0 (the "License")

  • you may not use this file except in compliance with the License.

  • You may obtain a copy of the License at *

  • http://www.apache.org/licenses/LICENSE-2.0 *

  • Unless required by applicable law or agreed to in writing, software

  • distributed under the License is distributed on an "AS IS" BASIS,

  • WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

  • See the License for the specific language governing permissions and

  • limitations under the License.

  • Copyright (c) 2008-2021, Hazelcast, Inc. All Rights Reserved. *

  • Licensed under the Apache License, Version 2.0 (the "License")

  • you may not use this file except in compliance with the License.

  • You may obtain a copy of the License at *

  • http://www.apache.org/licenses/LICENSE-2.0 *

  • Unless required by applicable law or agreed to in writing, software

  • distributed under the License is distributed on an "AS IS" BASIS,

  • WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

  • See the License for the specific language governing permissions and

  • limitations under the License.

  • Copyright (c) 2008-2021, Hazelcast, Inc. All Rights Reserved. *

  • Licensed under the Apache License, Version 2.0 (the "License")

  • you may not use this file except in compliance with the License.

  • You may obtain a copy of the License at *

  • http://www.apache.org/licenses/LICENSE-2.0 *

  • Unless required by applicable law or agreed to in writing, software

  • distributed under the License is distributed on an "AS IS" BASIS,

  • WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

  • See the License for the specific language governing permissions and

  • limitations under the License.

  • Copyright (c) 2008-2021, Hazelcast, Inc. All Rights Reserved. *

  • Licensed under the Apache License, Version 2.0 (the "License")

  • you may not use this file except in compliance with the License.

  • You may obtain a copy of the License at *

  • http://www.apache.org/licenses/LICENSE-2.0 *

  • Unless required by applicable law or agreed to in writing, software

  • distributed under the License is distributed on an "AS IS" BASIS,

  • WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

  • See the License for the specific language governing permissions and

  • limitations under the License.

  • Copyright (c) 2008-2021, Hazelcast, Inc. All Rights Reserved. *

  • Licensed under the Apache License, Version 2.0 (the "License")

  • you may not use this file except in compliance with the License.

  • You may obtain a copy of the License at *

  • http://www.apache.org/licenses/LICENSE-2.0 *

  • Unless required by applicable law or agreed to in writing, software

  • distributed under the License is distributed on an "AS IS" BASIS,

  • WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

  • See the License for the specific language governing permissions and

  • limitations under the License.

  • Copyright (c) 2008-2021, Hazelcast, Inc. All Rights Reserved. *

  • Licensed under the Apache License, Version 2.0 (the "License")

  • you may not use this file except in compliance with the License.

  • You may obtain a copy of the License at *

  • http://www.apache.org/licenses/LICENSE-2.0 *

  • Unless required by applicable law or agreed to in writing, software

  • distributed under the License is distributed on an "AS IS" BASIS,

  • WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

  • See the License for the specific language governing permissions and

  • limitations under the License.

  • Copyright (c) 2008-2021, Hazelcast, Inc. All Rights Reserved. *

  • Licensed under the Apache License, Version 2.0 (the "License")

  • you may not use this file except in compliance with the License.

  • You may obtain a copy of the License at *

  • http://www.apache.org/licenses/LICENSE-2.0 *

  • Unless required by applicable law or agreed to in writing, software

  • distributed under the License is distributed on an "AS IS" BASIS,

  • WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

  • See the License for the specific language governing permissions and

  • limitations under the License.

  • Copyright (c) 2008-2021, Hazelcast, Inc. All Rights Reserved. *

  • Licensed under the Apache License, Version 2.0 (the "License")

  • you may not use this file except in compliance with the License.

  • You may obtain a copy of the License at *

  • http://www.apache.org/licenses/LICENSE-2.0 *

  • Unless required by applicable law or agreed to in writing, software

  • distributed under the License is distributed on an "AS IS" BASIS,

  • WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

  • See the License for the specific language governing permissions and

  • limitations under the License.

  • Copyright (c) 2008-2021, Hazelcast, Inc. All Rights Reserved. *

  • Licensed under the Apache License, Version 2.0 (the "License")

  • you may not use this file except in compliance with the License.

  • You may obtain a copy of the License at *

  • http://www.apache.org/licenses/LICENSE-2.0 *

  • Unless required by applicable law or agreed to in writing, software

  • distributed under the License is distributed on an "AS IS" BASIS,

  • WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

  • See the License for the specific language governing permissions and

  • limitations under the License.

  • Copyright (c) 2008-2021, Hazelcast, Inc. All Rights Reserved. *

  • Licensed under the Apache License, Version 2.0 (the "License")

  • you may not use this file except in compliance with the License.

  • You may obtain a copy of the License at *

  • http://www.apache.org/licenses/LICENSE-2.0 *

  • Unless required by applicable law or agreed to in writing, software

  • distributed under the License is distributed on an "AS IS" BASIS,

  • WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

  • See the License for the specific language governing permissions and

  • limitations under the License.

  • Copyright (c) 2008-2021, Hazelcast, Inc. All Rights Reserved. *

  • Licensed under the Apache License, Version 2.0 (the "License")

  • you may not use this file except in compliance with the License.

  • You may obtain a copy of the License at *

  • http://www.apache.org/licenses/LICENSE-2.0 *

  • Unless required by applicable law or agreed to in writing, software

  • distributed under the License is distributed on an "AS IS" BASIS,

  • WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

  • See the License for the specific language governing permissions and

  • limitations under the License.

  • Copyright (c) 2008-2021, Hazelcast, Inc. All Rights Reserved. *

  • Licensed under the Apache License, Version 2.0 (the "License")

  • you may not use this file except in compliance with the License.

  • You may obtain a copy of the License at *

  • http://www.apache.org/licenses/LICENSE-2.0 *

  • Unless required by applicable law or agreed to in writing, software

  • distributed under the License is distributed on an "AS IS" BASIS,

  • WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

  • See the License for the specific language governing permissions and

  • limitations under the License.

  • Copyright (c) 2008-2021, Hazelcast, Inc. All Rights Reserved. *

  • Licensed under the Apache License, Version 2.0 (the "License")

  • you may not use this file except in compliance with the License.

  • You may obtain a copy of the License at *

  • http://www.apache.org/licenses/LICENSE-2.0 *

  • Unless required by applicable law or agreed to in writing, software

  • distributed under the License is distributed on an "AS IS" BASIS,

  • WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

  • See the License for the specific language governing permissions and

  • limitations under the License.

  • Copyright (c) 2008-2021, Hazelcast, Inc. All Rights Reserved. *

  • Licensed under the Apache License, Version 2.0 (the "License")

  • you may not use this file except in compliance with the License.

  • You may obtain a copy of the License at *

  • http://www.apache.org/licenses/LICENSE-2.0 *

  • Unless required by applicable law or agreed to in writing, software

  • distributed under the License is distributed on an "AS IS" BASIS,

  • WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

  • See the License for the specific language governing permissions and

  • limitations under the License.

  • Copyright (c) 2008-2021, Hazelcast, Inc. All Rights Reserved. *

  • Licensed under the Apache License, Version 2.0 (the "License")

  • you may not use this file except in compliance with the License.

  • You may obtain a copy of the License at *

  • http://www.apache.org/licenses/LICENSE-2.0 *

  • Unless required by applicable law or agreed to in writing, software

  • distributed under the License is distributed on an "AS IS" BASIS,

  • WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

  • See the License for the specific language governing permissions and

  • limitations under the License.

  • Copyright (c) 2008-2021, Hazelcast, Inc. All Rights Reserved. *

  • Licensed under the Apache License, Version 2.0 (the "License")

  • you may not use this file except in compliance with the License.

  • You may obtain a copy of the License at *

  • http://www.apache.org/licenses/LICENSE-2.0 *

  • Unless required by applicable law or agreed to in writing, software

  • distributed under the License is distributed on an "AS IS" BASIS,

  • WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

  • See the License for the specific language governing permissions and

  • limitations under the License.

  • Copyright (c) 2008-2021, Hazelcast, Inc. All Rights Reserved. *

  • Licensed under the Apache License, Version 2.0 (the "License")

  • you may not use this file except in compliance with the License.

  • You may obtain a copy of the License at *

  • http://www.apache.org/licenses/LICENSE-2.0 *

  • Unless required by applicable law or agreed to in writing, software

  • distributed under the License is distributed on an "AS IS" BASIS,

  • WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

  • See the License for the specific language governing permissions and

  • limitations under the License.

  • Copyright (c) 2008-2021, Hazelcast, Inc. All Rights Reserved. *

  • Licensed under the Apache License, Version 2.0 (the "License")

  • you may not use this file except in compliance with the License.

  • You may obtain a copy of the License at *

  • http://www.apache.org/licenses/LICENSE-2.0 *

  • Unless required by applicable law or agreed to in writing, software

  • distributed under the License is distributed on an "AS IS" BASIS,

  • WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

  • See the License for the specific language governing permissions and

  • limitations under the License.

  • Copyright (c) 2008-2021, Hazelcast, Inc. All Rights Reserved. *

  • Licensed under the Apache License, Version 2.0 (the "License")

  • you may not use this file except in compliance with the License.

  • You may obtain a copy of the License at *

  • http://www.apache.org/licenses/LICENSE-2.0 *

  • Unless required by applicable law or agreed to in writing, software

  • distributed under the License is distributed on an "AS IS" BASIS,

  • WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

  • See the License for the specific language governing permissions and

  • limitations under the License.

  • Copyright (c) 2008-2021, Hazelcast, Inc. All Rights Reserved. *

  • Licensed under the Apache License, Version 2.0 (the "License")

  • you may not use this file except in compliance with the License.

  • You may obtain a copy of the License at *

  • http://www.apache.org/licenses/LICENSE-2.0 *

  • Unless required by applicable law or agreed to in writing, software

  • distributed under the License is distributed on an "AS IS" BASIS,

  • WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

  • See the License for the specific language governing permissions and

  • limitations under the License.

  • Copyright (c) 2008-2021, Hazelcast, Inc. All Rights Reserved. *

  • Licensed under the Apache License, Version 2.0 (the "License")

  • you may not use this file except in compliance with the License.

  • You may obtain a copy of the License at *

  • http://www.apache.org/licenses/LICENSE-2.0 *

  • Unless required by applicable law or agreed to in writing, software

  • distributed under the License is distributed on an "AS IS" BASIS,

  • WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

  • See the License for the specific language governing permissions and

  • limitations under the License.

  • Copyright (c) 2008-2021, Hazelcast, Inc. All Rights Reserved. *

  • Licensed under the Apache License, Version 2.0 (the "License")

  • you may not use this file except in compliance with the License.

  • You may obtain a copy of the License at *

  • http://www.apache.org/licenses/LICENSE-2.0 *

  • Unless required by applicable law or agreed to in writing, software

  • distributed under the License is distributed on an "AS IS" BASIS,

  • WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

  • See the License for the specific language governing permissions and

  • limitations under the License.

  • Copyright (c) 2008-2021, Hazelcast, Inc. All Rights Reserved. *

  • Licensed under the Apache License, Version 2.0 (the "License")

  • you may not use this file except in compliance with the License.

  • You may obtain a copy of the License at *

  • http://www.apache.org/licenses/LICENSE-2.0 *

  • Unless required by applicable law or agreed to in writing, software

  • distributed under the License is distributed on an "AS IS" BASIS,

  • WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

  • See the License for the specific language governing permissions and

  • limitations under the License.

  • Copyright (c) 2008-2021, Hazelcast, Inc. All Rights Reserved. *

  • Licensed under the Apache License, Version 2.0 (the "License")

  • you may not use this file except in compliance with the License.

  • You may obtain a copy of the License at *

  • http://www.apache.org/licenses/LICENSE-2.0 *

  • Unless required by applicable law or agreed to in writing, software

  • distributed under the License is distributed on an "AS IS" BASIS,

  • WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

  • See the License for the specific language governing permissions and

  • limitations under the License.

  • Copyright (c) 2008-2021, Hazelcast, Inc. All Rights Reserved. *

  • Licensed under the Apache License, Version 2.0 (the "License")

  • you may not use this file except in compliance with the License.

  • You may obtain a copy of the License at *

  • http://www.apache.org/licenses/LICENSE-2.0 *

  • Unless required by applicable law or agreed to in writing, software

  • distributed under the License is distributed on an "AS IS" BASIS,

  • WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

  • See the License for the specific language governing permissions and

  • limitations under the License.

  • Copyright (c) 2008-2021, Hazelcast, Inc. All Rights Reserved. *

  • Licensed under the Apache License, Version 2.0 (the "License")

  • you may not use this file except in compliance with the License.

  • You may obtain a copy of the License at *

  • http://www.apache.org/licenses/LICENSE-2.0 *

  • Unless required by applicable law or agreed to in writing, software

  • distributed under the License is distributed on an "AS IS" BASIS,

  • WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

  • See the License for the specific language governing permissions and

  • limitations under the License.

  • Copyright (c) 2008-2021, Hazelcast, Inc. All Rights Reserved. *

  • Licensed under the Apache License, Version 2.0 (the "License")

  • you may not use this file except in compliance with the License.

  • You may obtain a copy of the License at *

  • http://www.apache.org/licenses/LICENSE-2.0 *

  • Unless required by applicable law or agreed to in writing, software

  • distributed under the License is distributed on an "AS IS" BASIS,

  • WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

  • See the License for the specific language governing permissions and

  • limitations under the License.

  • Copyright (c) 2008-2021, Hazelcast, Inc. All Rights Reserved. *

  • Licensed under the Apache License, Version 2.0 (the "License")

  • you may not use this file except in compliance with the License.

  • You may obtain a copy of the License at *

  • http://www.apache.org/licenses/LICENSE-2.0 *

  • Unless required by applicable law or agreed to in writing, software

  • distributed under the License is distributed on an "AS IS" BASIS,

  • WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

  • See the License for the specific language governing permissions and

  • limitations under the License.

  • Copyright (c) 2008-2021, Hazelcast, Inc. All Rights Reserved. *

  • Licensed under the Apache License, Version 2.0 (the "License")

  • you may not use this file except in compliance with the License.

  • You may obtain a copy of the License at *

  • http://www.apache.org/licenses/LICENSE-2.0 *

  • Unless required by applicable law or agreed to in writing, software

  • distributed under the License is distributed on an "AS IS" BASIS,

  • WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

  • See the License for the specific language governing permissions and

  • limitations under the License.

  • Copyright (c) 2008-2021, Hazelcast, Inc. All Rights Reserved. *

  • Licensed under the Apache License, Version 2.0 (the "License")

  • you may not use this file except in compliance with the License.

  • You may obtain a copy of the License at *

  • http://www.apache.org/licenses/LICENSE-2.0 *

  • Unless required by applicable law or agreed to in writing, software

  • distributed under the License is distributed on an "AS IS" BASIS,

  • WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

  • See the License for the specific language governing permissions and

  • limitations under the License.

  • Copyright (c) 2008-2021, Hazelcast, Inc. All Rights Reserved. *

  • Licensed under the Apache License, Version 2.0 (the "License")

  • you may not use this file except in compliance with the License.

  • You may obtain a copy of the License at *

  • http://www.apache.org/licenses/LICENSE-2.0 *

  • Unless required by applicable law or agreed to in writing, software

  • distributed under the License is distributed on an "AS IS" BASIS,

  • WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

  • See the License for the specific language governing permissions and

  • limitations under the License.

  • Copyright (c) 2008-2021, Hazelcast, Inc. All Rights Reserved. *

  • Licensed under the Apache License, Version 2.0 (the "License")

  • you may not use this file except in compliance with the License.

  • You may obtain a copy of the License at *

  • http://www.apache.org/licenses/LICENSE-2.0 *

  • Unless required by applicable law or agreed to in writing, software

  • distributed under the License is distributed on an "AS IS" BASIS,

  • WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

  • See the License for the specific language governing permissions and

  • limitations under the License.

  • Copyright (c) 2008-2021, Hazelcast, Inc. All Rights Reserved. *

  • Licensed under the Apache License, Version 2.0 (the "License")

  • you may not use this file except in compliance with the License.

  • You may obtain a copy of the License at *

  • http://www.apache.org/licenses/LICENSE-2.0 *

  • Unless required by applicable law or agreed to in writing, software

  • distributed under the License is distributed on an "AS IS" BASIS,

  • WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

  • See the License for the specific language governing permissions and

  • limitations under the License.

  • Copyright (c) 2008-2021, Hazelcast, Inc. All Rights Reserved. *

  • Licensed under the Apache License, Version 2.0 (the "License")

  • you may not use this file except in compliance with the License.

  • You may obtain a copy of the License at *

  • http://www.apache.org/licenses/LICENSE-2.0 *

  • Unless required by applicable law or agreed to in writing, software

  • distributed under the License is distributed on an "AS IS" BASIS,

  • WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

  • See the License for the specific language governing permissions and

  • limitations under the License.

  • Copyright (c) 2008-2021, Hazelcast, Inc. All Rights Reserved. *

  • Licensed under the Apache License, Version 2.0 (the "License")

  • you may not use this file except in compliance with the License.

  • You may obtain a copy of the License at *

  • http://www.apache.org/licenses/LICENSE-2.0 *

  • Unless required by applicable law or agreed to in writing, software

  • distributed under the License is distributed on an "AS IS" BASIS,

  • WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

  • See the License for the specific language governing permissions and

  • limitations under the License.

  • Copyright (c) 2008-2021, Hazelcast, Inc. All Rights Reserved. *

  • Licensed under the Apache License, Version 2.0 (the "License")

  • you may not use this file except in compliance with the License.

  • You may obtain a copy of the License at *

  • http://www.apache.org/licenses/LICENSE-2.0 *

  • Unless required by applicable law or agreed to in writing, software

  • distributed under the License is distributed on an "AS IS" BASIS,

  • WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

  • See the License for the specific language governing permissions and

  • limitations under the License.

  • Copyright (c) 2008-2021, Hazelcast, Inc. All Rights Reserved. *

  • Licensed under the Apache License, Version 2.0 (the "License")

  • you may not use this file except in compliance with the License.

  • You may obtain a copy of the License at *

  • http://www.apache.org/licenses/LICENSE-2.0 *

  • Unless required by applicable law or agreed to in writing, software

  • distributed under the License is distributed on an "AS IS" BASIS,

  • WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

  • See the License for the specific language governing permissions and

  • limitations under the License.

  • Copyright (c) 2008-2021, Hazelcast, Inc. All Rights Reserved. *

  • Licensed under the Apache License, Version 2.0 (the "License")

  • you may not use this file except in compliance with the License.

  • You may obtain a copy of the License at *

  • http://www.apache.org/licenses/LICENSE-2.0 *

  • Unless required by applicable law or agreed to in writing, software

  • distributed under the License is distributed on an "AS IS" BASIS,

  • WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

  • See the License for the specific language governing permissions and

  • limitations under the License.

  • Copyright (c) 2008-2021, Hazelcast, Inc. All Rights Reserved. *

  • Licensed under the Apache License, Version 2.0 (the "License")

  • you may not use this file except in compliance with the License.

  • You may obtain a copy of the License at *

  • http://www.apache.org/licenses/LICENSE-2.0 *

  • Unless required by applicable law or agreed to in writing, software

  • distributed under the License is distributed on an "AS IS" BASIS,

  • WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

  • See the License for the specific language governing permissions and

  • limitations under the License.

  • Copyright (c) 2008-2021, Hazelcast, Inc. All Rights Reserved. *

  • Licensed under the Apache License, Version 2.0 (the "License")

  • you may not use this file except in compliance with the License.

  • You may obtain a copy of the License at *

  • http://www.apache.org/licenses/LICENSE-2.0 *

  • Unless required by applicable law or agreed to in writing, software

  • distributed under the License is distributed on an "AS IS" BASIS,

  • WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

  • See the License for the specific language governing permissions and

  • limitations under the License.

  • Copyright (c) 2008-2021, Hazelcast, Inc. All Rights Reserved. *

  • Licensed under the Apache License, Version 2.0 (the "License")

  • you may not use this file except in compliance with the License.

  • You may obtain a copy of the License at *

  • http://www.apache.org/licenses/LICENSE-2.0 *

  • Unless required by applicable law or agreed to in writing, software

  • distributed under the License is distributed on an "AS IS" BASIS,

  • WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

  • See the License for the specific language governing permissions and

  • limitations under the License.

  • Copyright (c) 2008-2021, Hazelcast, Inc. All Rights Reserved. *

  • Licensed under the Apache License, Version 2.0 (the "License")

  • you may not use this file except in compliance with the License.

  • You may obtain a copy of the License at *

  • http://www.apache.org/licenses/LICENSE-2.0 *

  • Unless required by applicable law or agreed to in writing, software

  • distributed under the License is distributed on an "AS IS" BASIS,

  • WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

  • See the License for the specific language governing permissions and

  • limitations under the License.

  • Copyright (c) 2008-2021, Hazelcast, Inc. All Rights Reserved. *

  • Licensed under the Apache License, Version 2.0 (the "License")

  • you may not use this file except in compliance with the License.

  • You may obtain a copy of the License at *

  • http://www.apache.org/licenses/LICENSE-2.0 *

  • Unless required by applicable law or agreed to in writing, software

  • distributed under the License is distributed on an "AS IS" BASIS,

  • WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

  • See the License for the specific language governing permissions and

  • limitations under the License.

  • Copyright (c) 2008-2021, Hazelcast, Inc. All Rights Reserved. *

  • Licensed under the Apache License, Version 2.0 (the "License")

  • you may not use this file except in compliance with the License.

  • You may obtain a copy of the License at *

  • http://www.apache.org/licenses/LICENSE-2.0 *

  • Unless required by applicable law or agreed to in writing, software

  • distributed under the License is distributed on an "AS IS" BASIS,

  • WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

  • See the License for the specific language governing permissions and

  • limitations under the License.

  • Copyright (c) 2008-2021, Hazelcast, Inc. All Rights Reserved. *

  • Licensed under the Apache License, Version 2.0 (the "License")

  • you may not use this file except in compliance with the License.

  • You may obtain a copy of the License at *

  • http://www.apache.org/licenses/LICENSE-2.0 *

  • Unless required by applicable law or agreed to in writing, software

  • distributed under the License is distributed on an "AS IS" BASIS,

  • WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

  • See the License for the specific language governing permissions and

  • limitations under the License.

  • Copyright (c) 2008-2021, Hazelcast, Inc. All Rights Reserved. *

  • Licensed under the Apache License, Version 2.0 (the "License")

  • you may not use this file except in compliance with the License.

  • You may obtain a copy of the License at *

  • http://www.apache.org/licenses/LICENSE-2.0 *

  • Unless required by applicable law or agreed to in writing, software

  • distributed under the License is distributed on an "AS IS" BASIS,

  • WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

  • See the License for the specific language governing permissions and

  • limitations under the License.

  • Copyright (c) 2008-2021, Hazelcast, Inc. All Rights Reserved. *

  • Licensed under the Apache License, Version 2.0 (the "License")

  • you may not use this file except in compliance with the License.

  • You may obtain a copy of the License at *

  • http://www.apache.org/licenses/LICENSE-2.0 *

  • Unless required by applicable law or agreed to in writing, software

  • distributed under the License is distributed on an "AS IS" BASIS,

  • WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

  • See the License for the specific language governing permissions and

  • limitations under the License.

  • Copyright (c) 2008-2021, Hazelcast, Inc. All Rights Reserved. *

  • Licensed under the Apache License, Version 2.0 (the "License")

  • you may not use this file except in compliance with the License.

  • You may obtain a copy of the License at *

  • http://www.apache.org/licenses/LICENSE-2.0 *

  • Unless required by applicable law or agreed to in writing, software

  • distributed under the License is distributed on an "AS IS" BASIS,

  • WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

  • See the License for the specific language governing permissions and

  • limitations under the License.

  • Copyright (c) 2008-2021, Hazelcast, Inc. All Rights Reserved. *

  • Licensed under the Apache License, Version 2.0 (the "License")

  • you may not use this file except in compliance with the License.

  • You may obtain a copy of the License at *

  • http://www.apache.org/licenses/LICENSE-2.0 *

  • Unless required by applicable law or agreed to in writing, software

  • distributed under the License is distributed on an "AS IS" BASIS,

  • WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

  • See the License for the specific language governing permissions and

  • limitations under the License.

  • Copyright (c) 2008-2021, Hazelcast, Inc. All Rights Reserved. *

  • Licensed under the Apache License, Version 2.0 (the "License")

  • you may not use this file except in compliance with the License.

  • You may obtain a copy of the License at *

  • http://www.apache.org/licenses/LICENSE-2.0 *

  • Unless required by applicable law or agreed to in writing, software

  • distributed under the License is distributed on an "AS IS" BASIS,

  • WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

  • See the License for the specific language governing permissions and

  • limitations under the License.

  • Copyright (c) 2008-2021, Hazelcast, Inc. All Rights Reserved. *

  • Licensed under the Apache License, Version 2.0 (the "License")

  • you may not use this file except in compliance with the License.

  • You may obtain a copy of the License at *

  • http://www.apache.org/licenses/LICENSE-2.0 *

  • Unless required by applicable law or agreed to in writing, software

  • distributed under the License is distributed on an "AS IS" BASIS,

  • WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

  • See the License for the specific language governing permissions and

  • limitations under the License.

  • Copyright (c) 2008-2021, Hazelcast, Inc. All Rights Reserved. *

  • Licensed under the Apache License, Version 2.0 (the "License")

  • you may not use this file except in compliance with the License.

  • You may obtain a copy of the License at *

  • http://www.apache.org/licenses/LICENSE-2.0 *

  • Unless required by applicable law or agreed to in writing, software

  • distributed under the License is distributed on an "AS IS" BASIS,

  • WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

  • See the License for the specific language governing permissions and

  • limitations under the License.

  • Copyright (c) 2008-2021, Hazelcast, Inc. All Rights Reserved. *

  • Licensed under the Apache License, Version 2.0 (the "License")

  • you may not use this file except in compliance with the License.

  • You may obtain a copy of the License at *

  • http://www.apache.org/licenses/LICENSE-2.0 *

  • Unless required by applicable law or agreed to in writing, software

  • distributed under the License is distributed on an "AS IS" BASIS,

  • WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

  • See the License for the specific language governing permissions and

  • limitations under the License.

  • Copyright (c) 2008-2021, Hazelcast, Inc. All Rights Reserved. *

  • Licensed under the Apache License, Version 2.0 (the "License")

  • you may not use this file except in compliance with the License.

  • You may obtain a copy of the License at *

  • http://www.apache.org/licenses/LICENSE-2.0 *

  • Unless required by applicable law or agreed to in writing, software

  • distributed under the License is distributed on an "AS IS" BASIS,

  • WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

  • See the License for the specific language governing permissions and

  • limitations under the License.

  • Copyright (c) 2008-2021, Hazelcast, Inc. All Rights Reserved. *

  • Licensed under the Apache License, Version 2.0 (the "License")

  • you may not use this file except in compliance with the License.

  • You may obtain a copy of the License at *

  • http://www.apache.org/licenses/LICENSE-2.0 *

  • Unless required by applicable law or agreed to in writing, software

  • distributed under the License is distributed on an "AS IS" BASIS,

  • WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

  • See the License for the specific language governing permissions and

  • limitations under the License.

  • Copyright (c) 2008-2021, Hazelcast, Inc. All Rights Reserved. *

  • Licensed under the Apache License, Version 2.0 (the "License")

  • you may not use this file except in compliance with the License.

  • You may obtain a copy of the License at *

  • http://www.apache.org/licenses/LICENSE-2.0 *

  • Unless required by applicable law or agreed to in writing, software

  • distributed under the License is distributed on an "AS IS" BASIS,

  • WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

  • See the License for the specific language governing permissions and

  • limitations under the License.

  • Copyright (c) 2008-2021, Hazelcast, Inc. All Rights Reserved. *

  • Licensed under the Apache License, Version 2.0 (the "License")

  • you may not use this file except in compliance with the License.

  • You may obtain a copy of the License at *

  • http://www.apache.org/licenses/LICENSE-2.0 *

  • Unless required by applicable law or agreed to in writing, software

  • distributed under the License is distributed on an "AS IS" BASIS,

  • WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

  • See the License for the specific language governing permissions and

  • limitations under the License.

  • Copyright (c) 2008-2021, Hazelcast, Inc. All Rights Reserved. *

  • Licensed under the Apache License, Version 2.0 (the "License")

  • you may not use this file except in compliance with the License.

  • You may obtain a copy of the License at *

  • http://www.apache.org/licenses/LICENSE-2.0 *

  • Unless required by applicable law or agreed to in writing, software

  • distributed under the License is distributed on an "AS IS" BASIS,

  • WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

  • See the License for the specific language governing permissions and

  • limitations under the License.

  • Copyright (c) 2008-2021, Hazelcast, Inc. All Rights Reserved. *

  • Licensed under the Apache License, Version 2.0 (the "License")

  • you may not use this file except in compliance with the License.

  • You may obtain a copy of the License at *

  • http://www.apache.org/licenses/LICENSE-2.0 *

  • Unless required by applicable law or agreed to in writing, software

  • distributed under the License is distributed on an "AS IS" BASIS,

  • WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

  • See the License for the specific language governing permissions and

  • limitations under the License.

  • Copyright (c) 2008-2021, Hazelcast, Inc. All Rights Reserved. *

  • Licensed under the Apache License, Version 2.0 (the "License")

  • you may not use this file except in compliance with the License.

  • You may obtain a copy of the License at *

  • http://www.apache.org/licenses/LICENSE-2.0 *

  • Unless required by applicable law or agreed to in writing, software

  • distributed under the License is distributed on an "AS IS" BASIS,

  • WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

  • See the License for the specific language governing permissions and

  • limitations under the License.

  • Copyright (c) 2008-2021, Hazelcast, Inc. All Rights Reserved. *

  • Licensed under the Apache License, Version 2.0 (the "License")

  • you may not use this file except in compliance with the License.

  • You may obtain a copy of the License at *

  • http://www.apache.org/licenses/LICENSE-2.0 *

  • Unless required by applicable law or agreed to in writing, software

  • distributed under the License is distributed on an "AS IS" BASIS,

  • WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

  • See the License for the specific language governing permissions and

  • limitations under the License.

  • Copyright (c) 2008-2021, Hazelcast, Inc. All Rights Reserved. *

  • Licensed under the Apache License, Version 2.0 (the "License")

  • you may not use this file except in compliance with the License.

  • You may obtain a copy of the License at *

  • http://www.apache.org/licenses/LICENSE-2.0 *

  • Unless required by applicable law or agreed to in writing, software

  • distributed under the License is distributed on an "AS IS" BASIS,

  • WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

  • See the License for the specific language governing permissions and

  • limitations under the License.

  • Copyright (c) 2008-2021, Hazelcast, Inc. All Rights Reserved. *

  • Licensed under the Apache License, Version 2.0 (the "License")

  • you may not use this file except in compliance with the License.

  • You may obtain a copy of the License at *

  • http://www.apache.org/licenses/LICENSE-2.0 *

  • Unless required by applicable law or agreed to in writing, software

  • distributed under the License is distributed on an "AS IS" BASIS,

  • WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

  • See the License for the specific language governing permissions and

  • limitations under the License.

  • Copyright (c) 2008-2021, Hazelcast, Inc. All Rights Reserved. *

  • Licensed under the Apache License, Version 2.0 (the "License")

  • you may not use this file except in compliance with the License.

  • You may obtain a copy of the License at *

  • http://www.apache.org/licenses/LICENSE-2.0 *

  • Unless required by applicable law or agreed to in writing, software

  • distributed under the License is distributed on an "AS IS" BASIS,

  • WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

  • See the License for the specific language governing permissions and

  • limitations under the License.

Copyright (c) 2008-2020, Hazelcast, Inc. All Rights Reserved.

Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at

http://www.apache.org/licenses/LICENSE-2.0

Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License.

  • Copyright (c) 2008-2021, Hazelcast, Inc. All Rights Reserved. *

  • Licensed under the Apache License, Version 2.0 (the "License")

  • you may not use this file except in compliance with the License.

  • You may obtain a copy of the License at *

  • http://www.apache.org/licenses/LICENSE-2.0 *

  • Unless required by applicable law or agreed to in writing, software

  • distributed under the License is distributed on an "AS IS" BASIS,

  • WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

  • See the License for the specific language governing permissions and

  • limitations under the License.

  • Copyright (c) 2008-2021, Hazelcast, Inc. All Rights Reserved. *

  • Licensed under the Apache License, Version 2.0 (the "License")

  • you may not use this file except in compliance with the License.

  • You may obtain a copy of the License at *

  • http://www.apache.org/licenses/LICENSE-2.0 *

  • Unless required by applicable law or agreed to in writing, software

  • distributed under the License is distributed on an "AS IS" BASIS,

  • WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

  • See the License for the specific language governing permissions and

  • limitations under the License.

  • Copyright (c) 2008-2021, Hazelcast, Inc. All Rights Reserved. *

  • Licensed under the Apache License, Version 2.0 (the "License")

  • you may not use this file except in compliance with the License.

  • You may obtain a copy of the License at *

  • http://www.apache.org/licenses/LICENSE-2.0 *

  • Unless required by applicable law or agreed to in writing, software

  • distributed under the License is distributed on an "AS IS" BASIS,

  • WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

  • See the License for the specific language governing permissions and

  • limitations under the License.

  • Copyright (c) 2008-2021, Hazelcast, Inc. All Rights Reserved. *

  • Licensed under the Apache License, Version 2.0 (the "License")

  • you may not use this file except in compliance with the License.

  • You may obtain a copy of the License at *

  • http://www.apache.org/licenses/LICENSE-2.0 *

  • Unless required by applicable law or agreed to in writing, software

  • distributed under the License is distributed on an "AS IS" BASIS,

  • WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

  • See the License for the specific language governing permissions and

  • limitations under the License.

  • Copyright (c) 2008-2021, Hazelcast, Inc. All Rights Reserved. *

  • Licensed under the Apache License, Version 2.0 (the "License")

  • you may not use this file except in compliance with the License.

  • You may obtain a copy of the License at *

  • http://www.apache.org/licenses/LICENSE-2.0 *

  • Unless required by applicable law or agreed to in writing, software

  • distributed under the License is distributed on an "AS IS" BASIS,

  • WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

  • See the License for the specific language governing permissions and

  • limitations under the License.

  • Copyright (c) 2008-2021, Hazelcast, Inc. All Rights Reserved. *

  • Licensed under the Apache License, Version 2.0 (the "License")

  • you may not use this file except in compliance with the License.

  • You may obtain a copy of the License at *

  • http://www.apache.org/licenses/LICENSE-2.0 *

  • Unless required by applicable law or agreed to in writing, software

  • distributed under the License is distributed on an "AS IS" BASIS,

  • WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

  • See the License for the specific language governing permissions and

  • limitations under the License.

Copyright (c) 2008-2020, Hazelcast, Inc. All Rights Reserved.

Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at

http://www.apache.org/licenses/LICENSE-2.0

Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License.

  • Copyright (c) 2008-2021, Hazelcast, Inc. All Rights Reserved. *

  • Licensed under the Apache License, Version 2.0 (the "License")

  • you may not use this file except in compliance with the License.

  • You may obtain a copy of the License at *

  • http://www.apache.org/licenses/LICENSE-2.0 *

  • Unless required by applicable law or agreed to in writing, software

  • distributed under the License is distributed on an "AS IS" BASIS,

  • WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

  • See the License for the specific language governing permissions and

  • limitations under the License.

  • Copyright (c) 2008-2021, Hazelcast, Inc. All Rights Reserved. *

  • Licensed under the Apache License, Version 2.0 (the "License")

  • you may not use this file except in compliance with the License.

  • You may obtain a copy of the License at *

  • http://www.apache.org/licenses/LICENSE-2.0 *

  • Unless required by applicable law or agreed to in writing, software

  • distributed under the License is distributed on an "AS IS" BASIS,

  • WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

  • See the License for the specific language governing permissions and

  • limitations under the License.

  • Copyright (c) 2008-2021, Hazelcast, Inc. All Rights Reserved. *

  • Licensed under the Apache License, Version 2.0 (the "License")

  • you may not use this file except in compliance with the License.

  • You may obtain a copy of the License at *

  • http://www.apache.org/licenses/LICENSE-2.0 *

  • Unless required by applicable law or agreed to in writing, software

  • distributed under the License is distributed on an "AS IS" BASIS,

  • WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

  • See the License for the specific language governing permissions and

  • limitations under the License.

  • Copyright (c) 2008-2021, Hazelcast, Inc. All Rights Reserved. *

  • Licensed under the Apache License, Version 2.0 (the "License")

  • you may not use this file except in compliance with the License.

  • You may obtain a copy of the License at *

  • http://www.apache.org/licenses/LICENSE-2.0 *

  • Unless required by applicable law or agreed to in writing, software

  • distributed under the License is distributed on an "AS IS" BASIS,

  • WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

  • See the License for the specific language governing permissions and

  • limitations under the License.

  • Copyright (c) 2008-2021, Hazelcast, Inc. All Rights Reserved. *

  • Licensed under the Apache License, Version 2.0 (the "License")

  • you may not use this file except in compliance with the License.

  • You may obtain a copy of the License at *

  • http://www.apache.org/licenses/LICENSE-2.0 *

  • Unless required by applicable law or agreed to in writing, software

  • distributed under the License is distributed on an "AS IS" BASIS,

  • WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

  • See the License for the specific language governing permissions and

  • limitations under the License.

Copyright (c) 2008-2020, Hazelcast, Inc. All Rights Reserved.

Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at

http://www.apache.org/licenses/LICENSE-2.0

Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License.

  • Copyright (c) 2008-2021, Hazelcast, Inc. All Rights Reserved. *
  • Licensed under the Apache License, Version 2.0 (the "License")
  • you may not use this file except in compliance with the License.
  • You may obtain a copy of the License at *
  • http://www.apache.org/licenses/LICENSE-2.0 *
  • Unless required by applicable law or agreed to in writing, software
  • distributed under the License is distributed on an "AS IS" BASIS,
  • WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  • See the License for the specific language governing permissions and
  • limitations under the License.

Copyright (c) 2008-2020, Hazelcast, Inc. All Rights Reserved.

Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at

http://www.apache.org/licenses/LICENSE-2.0

Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License.

Copyright (c) 2008-2020, Hazelcast, Inc. All Rights Reserved.

Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at

http://www.apache.org/licenses/LICENSE-2.0

Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License.

  • Copyright (c) 2008-2021, Hazelcast, Inc. All Rights Reserved. *

  • Licensed under the Apache License, Version 2.0 (the "License")

  • you may not use this file except in compliance with the License.

  • You may obtain a copy of the License at *

  • http://www.apache.org/licenses/LICENSE-2.0 *

  • Unless required by applicable law or agreed to in writing, software

  • distributed under the License is distributed on an "AS IS" BASIS,

  • WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

  • See the License for the specific language governing permissions and

  • limitations under the License.

  • Copyright (c) 2008-2021, Hazelcast, Inc. All Rights Reserved. *

  • Licensed under the Apache License, Version 2.0 (the "License")

  • you may not use this file except in compliance with the License.

  • You may obtain a copy of the License at *

  • http://www.apache.org/licenses/LICENSE-2.0 *

  • Unless required by applicable law or agreed to in writing, software

  • distributed under the License is distributed on an "AS IS" BASIS,

  • WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

  • See the License for the specific language governing permissions and

  • limitations under the License.

  • Copyright (c) 2008-2021, Hazelcast, Inc. All Rights Reserved. *

  • Licensed under the Apache License, Version 2.0 (the "License")

  • you may not use this file except in compliance with the License.

  • You may obtain a copy of the License at *

  • http://www.apache.org/licenses/LICENSE-2.0 *

  • Unless required by applicable law or agreed to in writing, software

  • distributed under the License is distributed on an "AS IS" BASIS,

  • WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

  • See the License for the specific language governing permissions and

  • limitations under the License.

  • Copyright (c) 2008-2021, Hazelcast, Inc. All Rights Reserved. *

  • Licensed under the Apache License, Version 2.0 (the "License")

  • you may not use this file except in compliance with the License.

  • You may obtain a copy of the License at *

  • http://www.apache.org/licenses/LICENSE-2.0 *

  • Unless required by applicable law or agreed to in writing, software

  • distributed under the License is distributed on an "AS IS" BASIS,

  • WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

  • See the License for the specific language governing permissions and

  • limitations under the License.

  • Copyright (c) 2008-2021, Hazelcast, Inc. All Rights Reserved. *

  • Licensed under the Apache License, Version 2.0 (the "License")

  • you may not use this file except in compliance with the License.

  • You may obtain a copy of the License at *

  • http://www.apache.org/licenses/LICENSE-2.0 *

  • Unless required by applicable law or agreed to in writing, software

  • distributed under the License is distributed on an "AS IS" BASIS,

  • WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

  • See the License for the specific language governing permissions and

  • limitations under the License.

  • Copyright (c) 2008-2021, Hazelcast, Inc. All Rights Reserved. *

  • Licensed under the Apache License, Version 2.0 (the "License")

  • you may not use this file except in compliance with the License.

  • You may obtain a copy of the License at *

  • http://www.apache.org/licenses/LICENSE-2.0 *

  • Unless required by applicable law or agreed to in writing, software

  • distributed under the License is distributed on an "AS IS" BASIS,

  • WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

  • See the License for the specific language governing permissions and

  • limitations under the License.

  • Copyright (c) 2008-2021, Hazelcast, Inc. All Rights Reserved. *

  • Licensed under the Apache License, Version 2.0 (the "License")

  • you may not use this file except in compliance with the License.

  • You may obtain a copy of the License at *

  • http://www.apache.org/licenses/LICENSE-2.0 *

  • Unless required by applicable law or agreed to in writing, software

  • distributed under the License is distributed on an "AS IS" BASIS,

  • WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

  • See the License for the specific language governing permissions and

  • limitations under the License.

  • Copyright (c) 2008-2021, Hazelcast, Inc. All Rights Reserved. *

  • Licensed under the Apache License, Version 2.0 (the "License")

  • you may not use this file except in compliance with the License.

  • You may obtain a copy of the License at *

  • http://www.apache.org/licenses/LICENSE-2.0 *

  • Unless required by applicable law or agreed to in writing, software

  • distributed under the License is distributed on an "AS IS" BASIS,

  • WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

  • See the License for the specific language governing permissions and

  • limitations under the License.

  • Copyright (c) 2008-2021, Hazelcast, Inc. All Rights Reserved. *

  • Licensed under the Apache License, Version 2.0 (the "License")

  • you may not use this file except in compliance with the License.

  • You may obtain a copy of the License at *

  • http://www.apache.org/licenses/LICENSE-2.0 *

  • Unless required by applicable law or agreed to in writing, software

  • distributed under the License is distributed on an "AS IS" BASIS,

  • WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

  • See the License for the specific language governing permissions and

  • limitations under the License.

  • Copyright (c) 2008-2021, Hazelcast, Inc. All Rights Reserved. *

  • Licensed under the Apache License, Version 2.0 (the "License")

  • you may not use this file except in compliance with the License.

  • You may obtain a copy of the License at *

  • http://www.apache.org/licenses/LICENSE-2.0 *

  • Unless required by applicable law or agreed to in writing, software

  • distributed under the License is distributed on an "AS IS" BASIS,

  • WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

  • See the License for the specific language governing permissions and

  • limitations under the License.

  • Copyright (c) 2008-2021, Hazelcast, Inc. All Rights Reserved. *

  • Licensed under the Apache License, Version 2.0 (the "License")

  • you may not use this file except in compliance with the License.

  • You may obtain a copy of the License at *

  • http://www.apache.org/licenses/LICENSE-2.0 *

  • Unless required by applicable law or agreed to in writing, software

  • distributed under the License is distributed on an "AS IS" BASIS,

  • WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

  • See the License for the specific language governing permissions and

  • limitations under the License.

  • Copyright (c) 2008-2021, Hazelcast, Inc. All Rights Reserved. *

  • Licensed under the Apache License, Version 2.0 (the "License")

  • you may not use this file except in compliance with the License.

  • You may obtain a copy of the License at *

  • http://www.apache.org/licenses/LICENSE-2.0 *

  • Unless required by applicable law or agreed to in writing, software

  • distributed under the License is distributed on an "AS IS" BASIS,

  • WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

  • See the License for the specific language governing permissions and

  • limitations under the License.

  • Copyright (c) 2008-2021, Hazelcast, Inc. All Rights Reserved. *

  • Licensed under the Apache License, Version 2.0 (the "License")

  • you may not use this file except in compliance with the License.

  • You may obtain a copy of the License at *

  • http://www.apache.org/licenses/LICENSE-2.0 *

  • Unless required by applicable law or agreed to in writing, software

  • distributed under the License is distributed on an "AS IS" BASIS,

  • WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

  • See the License for the specific language governing permissions and

  • limitations under the License.

  • Copyright (c) 2008-2021, Hazelcast, Inc. All Rights Reserved. *

  • Licensed under the Apache License, Version 2.0 (the "License")

  • you may not use this file except in compliance with the License.

  • You may obtain a copy of the License at *

  • http://www.apache.org/licenses/LICENSE-2.0 *

  • Unless required by applicable law or agreed to in writing, software

  • distributed under the License is distributed on an "AS IS" BASIS,

  • WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

  • See the License for the specific language governing permissions and

  • limitations under the License.

  • Copyright (c) 2008-2021, Hazelcast, Inc. All Rights Reserved. *

  • Licensed under the Apache License, Version 2.0 (the "License")

  • you may not use this file except in compliance with the License.

  • You may obtain a copy of the License at *

  • http://www.apache.org/licenses/LICENSE-2.0 *

  • Unless required by applicable law or agreed to in writing, software

  • distributed under the License is distributed on an "AS IS" BASIS,

  • WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

  • See the License for the specific language governing permissions and

  • limitations under the License.

  • Copyright (c) 2008-2021, Hazelcast, Inc. All Rights Reserved. *

  • Licensed under the Apache License, Version 2.0 (the "License")

  • you may not use this file except in compliance with the License.

  • You may obtain a copy of the License at *

  • http://www.apache.org/licenses/LICENSE-2.0 *

  • Unless required by applicable law or agreed to in writing, software

  • distributed under the License is distributed on an "AS IS" BASIS,

  • WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

  • See the License for the specific language governing permissions and

  • limitations under the License.

  • Copyright (c) 2008-2021, Hazelcast, Inc. All Rights Reserved. *

  • Licensed under the Apache License, Version 2.0 (the "License")

  • you may not use this file except in compliance with the License.

  • You may obtain a copy of the License at *

  • http://www.apache.org/licenses/LICENSE-2.0 *

  • Unless required by applicable law or agreed to in writing, software

  • distributed under the License is distributed on an "AS IS" BASIS,

  • WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

  • See the License for the specific language governing permissions and

  • limitations under the License.

  • Copyright (c) 2008-2021, Hazelcast, Inc. All Rights Reserved. *

  • Licensed under the Apache License, Version 2.0 (the "License")

  • you may not use this file except in compliance with the License.

  • You may obtain a copy of the License at *

  • http://www.apache.org/licenses/LICENSE-2.0 *

  • Unless required by applicable law or agreed to in writing, software

  • distributed under the License is distributed on an "AS IS" BASIS,

  • WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

  • See the License for the specific language governing permissions and

  • limitations under the License.

  • Copyright (c) 2008-2021, Hazelcast, Inc. All Rights Reserved. *

  • Licensed under the Apache License, Version 2.0 (the "License")

  • you may not use this file except in compliance with the License.

  • You may obtain a copy of the License at *

  • http://www.apache.org/licenses/LICENSE-2.0 *

  • Unless required by applicable law or agreed to in writing, software

  • distributed under the License is distributed on an "AS IS" BASIS,

  • WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

  • See the License for the specific language governing permissions and

  • limitations under the License.

  • Copyright (c) 2008-2021, Hazelcast, Inc. All Rights Reserved. *

  • Licensed under the Apache License, Version 2.0 (the "License")

  • you may not use this file except in compliance with the License.

  • You may obtain a copy of the License at *

  • http://www.apache.org/licenses/LICENSE-2.0 *

  • Unless required by applicable law or agreed to in writing, software

  • distributed under the License is distributed on an "AS IS" BASIS,

  • WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

  • See the License for the specific language governing permissions and

  • limitations under the License.

  • Copyright (c) 2008-2021, Hazelcast, Inc. All Rights Reserved. *

  • Licensed under the Apache License, Version 2.0 (the "License")

  • you may not use this file except in compliance with the License.

  • You may obtain a copy of the License at *

  • http://www.apache.org/licenses/LICENSE-2.0 *

  • Unless required by applicable law or agreed to in writing, software

  • distributed under the License is distributed on an "AS IS" BASIS,

  • WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

  • See the License for the specific language governing permissions and

  • limitations under the License.

  • Copyright (c) 2008-2021, Hazelcast, Inc. All Rights Reserved. *

  • Licensed under the Apache License, Version 2.0 (the "License")

  • you may not use this file except in compliance with the License.

  • You may obtain a copy of the License at *

  • http://www.apache.org/licenses/LICENSE-2.0 *

  • Unless required by applicable law or agreed to in writing, software

  • distributed under the License is distributed on an "AS IS" BASIS,

  • WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

  • See the License for the specific language governing permissions and

  • limitations under the License.

  • Copyright (c) 2008-2021, Hazelcast, Inc. All Rights Reserved. *

  • Licensed under the Apache License, Version 2.0 (the "License")

  • you may not use this file except in compliance with the License.

  • You may obtain a copy of the License at *

  • http://www.apache.org/licenses/LICENSE-2.0 *

  • Unless required by applicable law or agreed to in writing, software

  • distributed under the License is distributed on an "AS IS" BASIS,

  • WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

  • See the License for the specific language governing permissions and

  • limitations under the License.

  • Copyright (c) 2008-2021, Hazelcast, Inc. All Rights Reserved. *

  • Licensed under the Apache License, Version 2.0 (the "License")

  • you may not use this file except in compliance with the License.

  • You may obtain a copy of the License at *

  • http://www.apache.org/licenses/LICENSE-2.0 *

  • Unless required by applicable law or agreed to in writing, software

  • distributed under the License is distributed on an "AS IS" BASIS,

  • WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

  • See the License for the specific language governing permissions and

  • limitations under the License.

  • Copyright (c) 2008-2021, Hazelcast, Inc. All Rights Reserved. *

  • Licensed under the Apache License, Version 2.0 (the "License")

  • you may not use this file except in compliance with the License.

  • You may obtain a copy of the License at *

  • http://www.apache.org/licenses/LICENSE-2.0 *

  • Unless required by applicable law or agreed to in writing, software

  • distributed under the License is distributed on an "AS IS" BASIS,

  • WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

  • See the License for the specific language governing permissions and

  • limitations under the License.

  • Copyright (c) 2008-2021, Hazelcast, Inc. All Rights Reserved. *

  • Licensed under the Apache License, Version 2.0 (the "License")

  • you may not use this file except in compliance with the License.

  • You may obtain a copy of the License at *

  • http://www.apache.org/licenses/LICENSE-2.0 *

  • Unless required by applicable law or agreed to in writing, software

  • distributed under the License is distributed on an "AS IS" BASIS,

  • WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

  • See the License for the specific language governing permissions and

  • limitations under the License.

  • Copyright (c) 2008-2021, Hazelcast, Inc. All Rights Reserved. *

  • Licensed under the Apache License, Version 2.0 (the "License")

  • you may not use this file except in compliance with the License.

  • You may obtain a copy of the License at *

  • http://www.apache.org/licenses/LICENSE-2.0 *

  • Unless required by applicable law or agreed to in writing, software

  • distributed under the License is distributed on an "AS IS" BASIS,

  • WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

  • See the License for the specific language governing permissions and

  • limitations under the License.

  • Copyright (c) 2008-2021, Hazelcast, Inc. All Rights Reserved. *

  • Licensed under the Apache License, Version 2.0 (the "License")

  • you may not use this file except in compliance with the License.

  • You may obtain a copy of the License at *

  • http://www.apache.org/licenses/LICENSE-2.0 *

  • Unless required by applicable law or agreed to in writing, software

  • distributed under the License is distributed on an "AS IS" BASIS,

  • WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

  • See the License for the specific language governing permissions and

  • limitations under the License.

  • Copyright (c) 2008-2021, Hazelcast, Inc. All Rights Reserved. *

  • Licensed under the Apache License, Version 2.0 (the "License")

  • you may not use this file except in compliance with the License.

  • You may obtain a copy of the License at *

  • http://www.apache.org/licenses/LICENSE-2.0 *

  • Unless required by applicable law or agreed to in writing, software

  • distributed under the License is distributed on an "AS IS" BASIS,

  • WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

  • See the License for the specific language governing permissions and

  • limitations under the License.

  • Copyright (c) 2008-2021, Hazelcast, Inc. All Rights Reserved. *

  • Licensed under the Apache License, Version 2.0 (the "License")

  • you may not use this file except in compliance with the License.

  • You may obtain a copy of the License at *

  • http://www.apache.org/licenses/LICENSE-2.0 *

  • Unless required by applicable law or agreed to in writing, software

  • distributed under the License is distributed on an "AS IS" BASIS,

  • WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

  • See the License for the specific language governing permissions and

  • limitations under the License.

  • Copyright (c) 2008-2021, Hazelcast, Inc. All Rights Reserved. *

  • Licensed under the Apache License, Version 2.0 (the "License")

  • you may not use this file except in compliance with the License.

  • You may obtain a copy of the License at *

  • http://www.apache.org/licenses/LICENSE-2.0 *

  • Unless required by applicable law or agreed to in writing, software

  • distributed under the License is distributed on an "AS IS" BASIS,

  • WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

  • See the License for the specific language governing permissions and

  • limitations under the License.

  • Copyright (c) 2008-2021, Hazelcast, Inc. All Rights Reserved. *

  • Licensed under the Apache License, Version 2.0 (the "License")

  • you may not use this file except in compliance with the License.

  • You may obtain a copy of the License at *

  • http://www.apache.org/licenses/LICENSE-2.0 *

  • Unless required by applicable law or agreed to in writing, software

  • distributed under the License is distributed on an "AS IS" BASIS,

  • WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

  • See the License for the specific language governing permissions and

  • limitations under the License.

  • Copyright (c) 2008-2021, Hazelcast, Inc. All Rights Reserved. *

  • Licensed under the Apache License, Version 2.0 (the "License")

  • you may not use this file except in compliance with the License.

  • You may obtain a copy of the License at *

  • http://www.apache.org/licenses/LICENSE-2.0 *

  • Unless required by applicable law or agreed to in writing, software

  • distributed under the License is distributed on an "AS IS" BASIS,

  • WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

  • See the License for the specific language governing permissions and

  • limitations under the License.

  • Copyright (c) 2008-2021, Hazelcast, Inc. All Rights Reserved. *

  • Licensed under the Apache License, Version 2.0 (the "License")

  • you may not use this file except in compliance with the License.

  • You may obtain a copy of the License at *

  • http://www.apache.org/licenses/LICENSE-2.0 *

  • Unless required by applicable law or agreed to in writing, software

  • distributed under the License is distributed on an "AS IS" BASIS,

  • WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

  • See the License for the specific language governing permissions and

  • limitations under the License.

  • Copyright (c) 2008-2021, Hazelcast, Inc. All Rights Reserved. *

  • Licensed under the Apache License, Version 2.0 (the "License")

  • you may not use this file except in compliance with the License.

  • You may obtain a copy of the License at *

  • http://www.apache.org/licenses/LICENSE-2.0 *

  • Unless required by applicable law or agreed to in writing, software

  • distributed under the License is distributed on an "AS IS" BASIS,

  • WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

  • See the License for the specific language governing permissions and

  • limitations under the License.

  • Copyright (c) 2008-2021, Hazelcast, Inc. All Rights Reserved. *

  • Licensed under the Apache License, Version 2.0 (the "License")

  • you may not use this file except in compliance with the License.

  • You may obtain a copy of the License at *

  • http://www.apache.org/licenses/LICENSE-2.0 *

  • Unless required by applicable law or agreed to in writing, software

  • distributed under the License is distributed on an "AS IS" BASIS,

  • WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

  • See the License for the specific language governing permissions and

  • limitations under the License.

  • Copyright (c) 2008-2021, Hazelcast, Inc. All Rights Reserved. *

  • Licensed under the Apache License, Version 2.0 (the "License")

  • you may not use this file except in compliance with the License.

  • You may obtain a copy of the License at *

  • http://www.apache.org/licenses/LICENSE-2.0 *

  • Unless required by applicable law or agreed to in writing, software

  • distributed under the License is distributed on an "AS IS" BASIS,

  • WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

  • See the License for the specific language governing permissions and

  • limitations under the License.

Copyright (c) 2008-2020, Hazelcast, Inc. All Rights Reserved.

Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at

http://www.apache.org/licenses/LICENSE-2.0

Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License.

Index

Constants

View Source 
const (
	AddressCodecPortFieldOffset      = 0
	AddressCodecPortInitialFrameSize = AddressCodecPortFieldOffset + proto.IntSizeInBytes
)
View Source 
const (
	BitmapIndexOptionsCodecUniqueKeyTransformationFieldOffset      = 0
	BitmapIndexOptionsCodecUniqueKeyTransformationInitialFrameSize = BitmapIndexOptionsCodecUniqueKeyTransformationFieldOffset + proto.IntSizeInBytes
)
View Source 
const (
	// hex: 0x000300
	ClientAddClusterViewListenerCodecRequestMessageType = int32(768)
	// hex: 0x000301
	ClientAddClusterViewListenerCodecResponseMessageType = int32(769)

	// hex: 0x000302
	ClientAddClusterViewListenerCodecEventMembersViewMessageType = int32(770)

	// hex: 0x000303
	ClientAddClusterViewListenerCodecEventPartitionsViewMessageType = int32(771)

	ClientAddClusterViewListenerCodecRequestInitialFrameSize = proto.PartitionIDOffset + proto.IntSizeInBytes

	ClientAddClusterViewListenerEventMembersViewVersionOffset    = proto.PartitionIDOffset + proto.IntSizeInBytes
	ClientAddClusterViewListenerEventPartitionsViewVersionOffset = proto.PartitionIDOffset + proto.IntSizeInBytes
)
View Source 
const (
	// hex: 0x000100
	ClientAuthenticationCodecRequestMessageType = int32(256)
	// hex: 0x000101
	ClientAuthenticationCodecResponseMessageType = int32(257)

	ClientAuthenticationCodecRequestUuidOffset                 = proto.PartitionIDOffset + proto.IntSizeInBytes
	ClientAuthenticationCodecRequestSerializationVersionOffset = ClientAuthenticationCodecRequestUuidOffset + proto.UuidSizeInBytes
	ClientAuthenticationCodecRequestInitialFrameSize           = ClientAuthenticationCodecRequestSerializationVersionOffset + proto.ByteSizeInBytes

	ClientAuthenticationResponseStatusOffset               = proto.ResponseBackupAcksOffset + proto.ByteSizeInBytes
	ClientAuthenticationResponseMemberUuidOffset           = ClientAuthenticationResponseStatusOffset + proto.ByteSizeInBytes
	ClientAuthenticationResponseSerializationVersionOffset = ClientAuthenticationResponseMemberUuidOffset + proto.UuidSizeInBytes
	ClientAuthenticationResponsePartitionCountOffset       = ClientAuthenticationResponseSerializationVersionOffset + proto.ByteSizeInBytes
	ClientAuthenticationResponseClusterIdOffset            = ClientAuthenticationResponsePartitionCountOffset + proto.IntSizeInBytes
	ClientAuthenticationResponseFailoverSupportedOffset    = ClientAuthenticationResponseClusterIdOffset + proto.UuidSizeInBytes
)
View Source 
const (
	// hex: 0x000400
	ClientCreateProxyCodecRequestMessageType = int32(1024)
	// hex: 0x000401
	ClientCreateProxyCodecResponseMessageType = int32(1025)

	ClientCreateProxyCodecRequestInitialFrameSize = proto.PartitionIDOffset + proto.IntSizeInBytes
)
View Source 
const (
	// hex: 0x000500
	ClientDestroyProxyCodecRequestMessageType = int32(1280)
	// hex: 0x000501
	ClientDestroyProxyCodecResponseMessageType = int32(1281)

	ClientDestroyProxyCodecRequestInitialFrameSize = proto.PartitionIDOffset + proto.IntSizeInBytes
)
View Source 
const (
	// hex: 0x000B00
	ClientPingCodecRequestMessageType = int32(2816)
	// hex: 0x000B01
	ClientPingCodecResponseMessageType = int32(2817)

	ClientPingCodecRequestInitialFrameSize = proto.PartitionIDOffset + proto.IntSizeInBytes
)
View Source 
const (
	EndpointQualifierCodecTypeFieldOffset      = 0
	EndpointQualifierCodecTypeInitialFrameSize = EndpointQualifierCodecTypeFieldOffset + proto.IntSizeInBytes
)
View Source 
const (
	ErrorHolderCodecErrorCodeFieldOffset      = 0
	ErrorHolderCodecErrorCodeInitialFrameSize = ErrorHolderCodecErrorCodeFieldOffset + proto.IntSizeInBytes
)
View Source 
const (
	IndexConfigCodecTypeFieldOffset      = 0
	IndexConfigCodecTypeInitialFrameSize = IndexConfigCodecTypeFieldOffset + proto.IntSizeInBytes
)
View Source 
const (
	// hex: 0x050600
	ListAddAllCodecRequestMessageType = int32(329216)
	// hex: 0x050601
	ListAddAllCodecResponseMessageType = int32(329217)

	ListAddAllCodecRequestInitialFrameSize = proto.PartitionIDOffset + proto.IntSizeInBytes

	ListAddAllResponseResponseOffset = proto.ResponseBackupAcksOffset + proto.ByteSizeInBytes
)
View Source 
const (
	// hex: 0x050E00
	ListAddAllWithIndexCodecRequestMessageType = int32(331264)
	// hex: 0x050E01
	ListAddAllWithIndexCodecResponseMessageType = int32(331265)

	ListAddAllWithIndexCodecRequestIndexOffset      = proto.PartitionIDOffset + proto.IntSizeInBytes
	ListAddAllWithIndexCodecRequestInitialFrameSize = ListAddAllWithIndexCodecRequestIndexOffset + proto.IntSizeInBytes

	ListAddAllWithIndexResponseResponseOffset = proto.ResponseBackupAcksOffset + proto.ByteSizeInBytes
)
View Source 
const (
	// hex: 0x050400
	ListAddCodecRequestMessageType = int32(328704)
	// hex: 0x050401
	ListAddCodecResponseMessageType = int32(328705)

	ListAddCodecRequestInitialFrameSize = proto.PartitionIDOffset + proto.IntSizeInBytes

	ListAddResponseResponseOffset = proto.ResponseBackupAcksOffset + proto.ByteSizeInBytes
)
View Source 
const (
	// hex: 0x050B00
	ListAddListenerCodecRequestMessageType = int32(330496)
	// hex: 0x050B01
	ListAddListenerCodecResponseMessageType = int32(330497)

	// hex: 0x050B02
	ListAddListenerCodecEventItemMessageType = int32(330498)

	ListAddListenerCodecRequestIncludeValueOffset = proto.PartitionIDOffset + proto.IntSizeInBytes
	ListAddListenerCodecRequestLocalOnlyOffset    = ListAddListenerCodecRequestIncludeValueOffset + proto.BooleanSizeInBytes
	ListAddListenerCodecRequestInitialFrameSize   = ListAddListenerCodecRequestLocalOnlyOffset + proto.BooleanSizeInBytes

	ListAddListenerResponseResponseOffset   = proto.ResponseBackupAcksOffset + proto.ByteSizeInBytes
	ListAddListenerEventItemUuidOffset      = proto.PartitionIDOffset + proto.IntSizeInBytes
	ListAddListenerEventItemEventTypeOffset = ListAddListenerEventItemUuidOffset + proto.UuidSizeInBytes
)
View Source 
const (
	// hex: 0x051100
	ListAddWithIndexCodecRequestMessageType = int32(332032)
	// hex: 0x051101
	ListAddWithIndexCodecResponseMessageType = int32(332033)

	ListAddWithIndexCodecRequestIndexOffset      = proto.PartitionIDOffset + proto.IntSizeInBytes
	ListAddWithIndexCodecRequestInitialFrameSize = ListAddWithIndexCodecRequestIndexOffset + proto.IntSizeInBytes
)
View Source 
const (
	// hex: 0x050900
	ListClearCodecRequestMessageType = int32(329984)
	// hex: 0x050901
	ListClearCodecResponseMessageType = int32(329985)

	ListClearCodecRequestInitialFrameSize = proto.PartitionIDOffset + proto.IntSizeInBytes
)
View Source 
const (
	// hex: 0x050700
	ListCompareAndRemoveAllCodecRequestMessageType = int32(329472)
	// hex: 0x050701
	ListCompareAndRemoveAllCodecResponseMessageType = int32(329473)

	ListCompareAndRemoveAllCodecRequestInitialFrameSize = proto.PartitionIDOffset + proto.IntSizeInBytes

	ListCompareAndRemoveAllResponseResponseOffset = proto.ResponseBackupAcksOffset + proto.ByteSizeInBytes
)
View Source 
const (
	// hex: 0x050800
	ListCompareAndRetainAllCodecRequestMessageType = int32(329728)
	// hex: 0x050801
	ListCompareAndRetainAllCodecResponseMessageType = int32(329729)

	ListCompareAndRetainAllCodecRequestInitialFrameSize = proto.PartitionIDOffset + proto.IntSizeInBytes

	ListCompareAndRetainAllResponseResponseOffset = proto.ResponseBackupAcksOffset + proto.ByteSizeInBytes
)
View Source 
const (
	// hex: 0x050300
	ListContainsAllCodecRequestMessageType = int32(328448)
	// hex: 0x050301
	ListContainsAllCodecResponseMessageType = int32(328449)

	ListContainsAllCodecRequestInitialFrameSize = proto.PartitionIDOffset + proto.IntSizeInBytes

	ListContainsAllResponseResponseOffset = proto.ResponseBackupAcksOffset + proto.ByteSizeInBytes
)
View Source 
const (
	// hex: 0x050200
	ListContainsCodecRequestMessageType = int32(328192)
	// hex: 0x050201
	ListContainsCodecResponseMessageType = int32(328193)

	ListContainsCodecRequestInitialFrameSize = proto.PartitionIDOffset + proto.IntSizeInBytes

	ListContainsResponseResponseOffset = proto.ResponseBackupAcksOffset + proto.ByteSizeInBytes
)
View Source 
const (
	// hex: 0x050A00
	ListGetAllCodecRequestMessageType = int32(330240)
	// hex: 0x050A01
	ListGetAllCodecResponseMessageType = int32(330241)

	ListGetAllCodecRequestInitialFrameSize = proto.PartitionIDOffset + proto.IntSizeInBytes
)
View Source 
const (
	// hex: 0x050F00
	ListGetCodecRequestMessageType = int32(331520)
	// hex: 0x050F01
	ListGetCodecResponseMessageType = int32(331521)

	ListGetCodecRequestIndexOffset      = proto.PartitionIDOffset + proto.IntSizeInBytes
	ListGetCodecRequestInitialFrameSize = ListGetCodecRequestIndexOffset + proto.IntSizeInBytes
)
View Source 
const (
	// hex: 0x051400
	ListIndexOfCodecRequestMessageType = int32(332800)
	// hex: 0x051401
	ListIndexOfCodecResponseMessageType = int32(332801)

	ListIndexOfCodecRequestInitialFrameSize = proto.PartitionIDOffset + proto.IntSizeInBytes

	ListIndexOfResponseResponseOffset = proto.ResponseBackupAcksOffset + proto.ByteSizeInBytes
)
View Source 
const (
	// hex: 0x050D00
	ListIsEmptyCodecRequestMessageType = int32(331008)
	// hex: 0x050D01
	ListIsEmptyCodecResponseMessageType = int32(331009)

	ListIsEmptyCodecRequestInitialFrameSize = proto.PartitionIDOffset + proto.IntSizeInBytes

	ListIsEmptyResponseResponseOffset = proto.ResponseBackupAcksOffset + proto.ByteSizeInBytes
)
View Source 
const (
	// hex: 0x051600
	ListIteratorCodecRequestMessageType = int32(333312)
	// hex: 0x051601
	ListIteratorCodecResponseMessageType = int32(333313)

	ListIteratorCodecRequestInitialFrameSize = proto.PartitionIDOffset + proto.IntSizeInBytes
)
View Source 
const (
	// hex: 0x051300
	ListLastIndexOfCodecRequestMessageType = int32(332544)
	// hex: 0x051301
	ListLastIndexOfCodecResponseMessageType = int32(332545)

	ListLastIndexOfCodecRequestInitialFrameSize = proto.PartitionIDOffset + proto.IntSizeInBytes

	ListLastIndexOfResponseResponseOffset = proto.ResponseBackupAcksOffset + proto.ByteSizeInBytes
)
View Source 
const (
	// hex: 0x051700
	ListListIteratorCodecRequestMessageType = int32(333568)
	// hex: 0x051701
	ListListIteratorCodecResponseMessageType = int32(333569)

	ListListIteratorCodecRequestIndexOffset      = proto.PartitionIDOffset + proto.IntSizeInBytes
	ListListIteratorCodecRequestInitialFrameSize = ListListIteratorCodecRequestIndexOffset + proto.IntSizeInBytes
)
View Source 
const (
	// hex: 0x050500
	ListRemoveCodecRequestMessageType = int32(328960)
	// hex: 0x050501
	ListRemoveCodecResponseMessageType = int32(328961)

	ListRemoveCodecRequestInitialFrameSize = proto.PartitionIDOffset + proto.IntSizeInBytes

	ListRemoveResponseResponseOffset = proto.ResponseBackupAcksOffset + proto.ByteSizeInBytes
)
View Source 
const (
	// hex: 0x050C00
	ListRemoveListenerCodecRequestMessageType = int32(330752)
	// hex: 0x050C01
	ListRemoveListenerCodecResponseMessageType = int32(330753)

	ListRemoveListenerCodecRequestRegistrationIdOffset = proto.PartitionIDOffset + proto.IntSizeInBytes
	ListRemoveListenerCodecRequestInitialFrameSize     = ListRemoveListenerCodecRequestRegistrationIdOffset + proto.UuidSizeInBytes

	ListRemoveListenerResponseResponseOffset = proto.ResponseBackupAcksOffset + proto.ByteSizeInBytes
)
View Source 
const (
	// hex: 0x051200
	ListRemoveWithIndexCodecRequestMessageType = int32(332288)
	// hex: 0x051201
	ListRemoveWithIndexCodecResponseMessageType = int32(332289)

	ListRemoveWithIndexCodecRequestIndexOffset      = proto.PartitionIDOffset + proto.IntSizeInBytes
	ListRemoveWithIndexCodecRequestInitialFrameSize = ListRemoveWithIndexCodecRequestIndexOffset + proto.IntSizeInBytes
)
View Source 
const (
	// hex: 0x051000
	ListSetCodecRequestMessageType = int32(331776)
	// hex: 0x051001
	ListSetCodecResponseMessageType = int32(331777)

	ListSetCodecRequestIndexOffset      = proto.PartitionIDOffset + proto.IntSizeInBytes
	ListSetCodecRequestInitialFrameSize = ListSetCodecRequestIndexOffset + proto.IntSizeInBytes
)
View Source 
const (
	// hex: 0x050100
	ListSizeCodecRequestMessageType = int32(327936)
	// hex: 0x050101
	ListSizeCodecResponseMessageType = int32(327937)

	ListSizeCodecRequestInitialFrameSize = proto.PartitionIDOffset + proto.IntSizeInBytes

	ListSizeResponseResponseOffset = proto.ResponseBackupAcksOffset + proto.ByteSizeInBytes
)
View Source 
const (
	// hex: 0x051500
	ListSubCodecRequestMessageType = int32(333056)
	// hex: 0x051501
	ListSubCodecResponseMessageType = int32(333057)

	ListSubCodecRequestFromOffset       = proto.PartitionIDOffset + proto.IntSizeInBytes
	ListSubCodecRequestToOffset         = ListSubCodecRequestFromOffset + proto.IntSizeInBytes
	ListSubCodecRequestInitialFrameSize = ListSubCodecRequestToOffset + proto.IntSizeInBytes
)
View Source 
const (
	// hex: 0x011900
	MapAddEntryListenerCodecRequestMessageType = int32(71936)
	// hex: 0x011901
	MapAddEntryListenerCodecResponseMessageType = int32(71937)

	// hex: 0x011902
	MapAddEntryListenerCodecEventEntryMessageType = int32(71938)

	MapAddEntryListenerCodecRequestIncludeValueOffset  = proto.PartitionIDOffset + proto.IntSizeInBytes
	MapAddEntryListenerCodecRequestListenerFlagsOffset = MapAddEntryListenerCodecRequestIncludeValueOffset + proto.BooleanSizeInBytes
	MapAddEntryListenerCodecRequestLocalOnlyOffset     = MapAddEntryListenerCodecRequestListenerFlagsOffset + proto.IntSizeInBytes
	MapAddEntryListenerCodecRequestInitialFrameSize    = MapAddEntryListenerCodecRequestLocalOnlyOffset + proto.BooleanSizeInBytes

	MapAddEntryListenerResponseResponseOffset                  = proto.ResponseBackupAcksOffset + proto.ByteSizeInBytes
	MapAddEntryListenerEventEntryEventTypeOffset               = proto.PartitionIDOffset + proto.IntSizeInBytes
	MapAddEntryListenerEventEntryUuidOffset                    = MapAddEntryListenerEventEntryEventTypeOffset + proto.IntSizeInBytes
	MapAddEntryListenerEventEntryNumberOfAffectedEntriesOffset = MapAddEntryListenerEventEntryUuidOffset + proto.UuidSizeInBytes
)
View Source 
const (
	// hex: 0x011800
	MapAddEntryListenerToKeyCodecRequestMessageType = int32(71680)
	// hex: 0x011801
	MapAddEntryListenerToKeyCodecResponseMessageType = int32(71681)

	// hex: 0x011802
	MapAddEntryListenerToKeyCodecEventEntryMessageType = int32(71682)

	MapAddEntryListenerToKeyCodecRequestIncludeValueOffset  = proto.PartitionIDOffset + proto.IntSizeInBytes
	MapAddEntryListenerToKeyCodecRequestListenerFlagsOffset = MapAddEntryListenerToKeyCodecRequestIncludeValueOffset + proto.BooleanSizeInBytes
	MapAddEntryListenerToKeyCodecRequestLocalOnlyOffset     = MapAddEntryListenerToKeyCodecRequestListenerFlagsOffset + proto.IntSizeInBytes
	MapAddEntryListenerToKeyCodecRequestInitialFrameSize    = MapAddEntryListenerToKeyCodecRequestLocalOnlyOffset + proto.BooleanSizeInBytes

	MapAddEntryListenerToKeyResponseResponseOffset                  = proto.ResponseBackupAcksOffset + proto.ByteSizeInBytes
	MapAddEntryListenerToKeyEventEntryEventTypeOffset               = proto.PartitionIDOffset + proto.IntSizeInBytes
	MapAddEntryListenerToKeyEventEntryUuidOffset                    = MapAddEntryListenerToKeyEventEntryEventTypeOffset + proto.IntSizeInBytes
	MapAddEntryListenerToKeyEventEntryNumberOfAffectedEntriesOffset = MapAddEntryListenerToKeyEventEntryUuidOffset + proto.UuidSizeInBytes
)
View Source 
const (
	// hex: 0x011600
	MapAddEntryListenerToKeyWithPredicateCodecRequestMessageType = int32(71168)
	// hex: 0x011601
	MapAddEntryListenerToKeyWithPredicateCodecResponseMessageType = int32(71169)

	// hex: 0x011602
	MapAddEntryListenerToKeyWithPredicateCodecEventEntryMessageType = int32(71170)

	MapAddEntryListenerToKeyWithPredicateCodecRequestIncludeValueOffset  = proto.PartitionIDOffset + proto.IntSizeInBytes
	MapAddEntryListenerToKeyWithPredicateCodecRequestListenerFlagsOffset = MapAddEntryListenerToKeyWithPredicateCodecRequestIncludeValueOffset + proto.BooleanSizeInBytes
	MapAddEntryListenerToKeyWithPredicateCodecRequestLocalOnlyOffset     = MapAddEntryListenerToKeyWithPredicateCodecRequestListenerFlagsOffset + proto.IntSizeInBytes
	MapAddEntryListenerToKeyWithPredicateCodecRequestInitialFrameSize    = MapAddEntryListenerToKeyWithPredicateCodecRequestLocalOnlyOffset + proto.BooleanSizeInBytes

	MapAddEntryListenerToKeyWithPredicateResponseResponseOffset                  = proto.ResponseBackupAcksOffset + proto.ByteSizeInBytes
	MapAddEntryListenerToKeyWithPredicateEventEntryEventTypeOffset               = proto.PartitionIDOffset + proto.IntSizeInBytes
	MapAddEntryListenerToKeyWithPredicateEventEntryUuidOffset                    = MapAddEntryListenerToKeyWithPredicateEventEntryEventTypeOffset + proto.IntSizeInBytes
	MapAddEntryListenerToKeyWithPredicateEventEntryNumberOfAffectedEntriesOffset = MapAddEntryListenerToKeyWithPredicateEventEntryUuidOffset + proto.UuidSizeInBytes
)
View Source 
const (
	// hex: 0x011700
	MapAddEntryListenerWithPredicateCodecRequestMessageType = int32(71424)
	// hex: 0x011701
	MapAddEntryListenerWithPredicateCodecResponseMessageType = int32(71425)

	// hex: 0x011702
	MapAddEntryListenerWithPredicateCodecEventEntryMessageType = int32(71426)

	MapAddEntryListenerWithPredicateCodecRequestIncludeValueOffset  = proto.PartitionIDOffset + proto.IntSizeInBytes
	MapAddEntryListenerWithPredicateCodecRequestListenerFlagsOffset = MapAddEntryListenerWithPredicateCodecRequestIncludeValueOffset + proto.BooleanSizeInBytes
	MapAddEntryListenerWithPredicateCodecRequestLocalOnlyOffset     = MapAddEntryListenerWithPredicateCodecRequestListenerFlagsOffset + proto.IntSizeInBytes
	MapAddEntryListenerWithPredicateCodecRequestInitialFrameSize    = MapAddEntryListenerWithPredicateCodecRequestLocalOnlyOffset + proto.BooleanSizeInBytes

	MapAddEntryListenerWithPredicateResponseResponseOffset                  = proto.ResponseBackupAcksOffset + proto.ByteSizeInBytes
	MapAddEntryListenerWithPredicateEventEntryEventTypeOffset               = proto.PartitionIDOffset + proto.IntSizeInBytes
	MapAddEntryListenerWithPredicateEventEntryUuidOffset                    = MapAddEntryListenerWithPredicateEventEntryEventTypeOffset + proto.IntSizeInBytes
	MapAddEntryListenerWithPredicateEventEntryNumberOfAffectedEntriesOffset = MapAddEntryListenerWithPredicateEventEntryUuidOffset + proto.UuidSizeInBytes
)
View Source 
const (
	// hex: 0x012900
	MapAddIndexCodecRequestMessageType = int32(76032)
	// hex: 0x012901
	MapAddIndexCodecResponseMessageType = int32(76033)

	MapAddIndexCodecRequestInitialFrameSize = proto.PartitionIDOffset + proto.IntSizeInBytes
)
View Source 
const (
	// hex: 0x011400
	MapAddInterceptorCodecRequestMessageType = int32(70656)
	// hex: 0x011401
	MapAddInterceptorCodecResponseMessageType = int32(70657)

	MapAddInterceptorCodecRequestInitialFrameSize = proto.PartitionIDOffset + proto.IntSizeInBytes
)
View Source 
const (
	// hex: 0x012D00
	MapClearCodecRequestMessageType = int32(77056)
	// hex: 0x012D01
	MapClearCodecResponseMessageType = int32(77057)

	MapClearCodecRequestInitialFrameSize = proto.PartitionIDOffset + proto.IntSizeInBytes
)
View Source 
const (
	// hex: 0x010600
	MapContainsKeyCodecRequestMessageType = int32(67072)
	// hex: 0x010601
	MapContainsKeyCodecResponseMessageType = int32(67073)

	MapContainsKeyCodecRequestThreadIdOffset   = proto.PartitionIDOffset + proto.IntSizeInBytes
	MapContainsKeyCodecRequestInitialFrameSize = MapContainsKeyCodecRequestThreadIdOffset + proto.LongSizeInBytes

	MapContainsKeyResponseResponseOffset = proto.ResponseBackupAcksOffset + proto.ByteSizeInBytes
)
View Source 
const (
	// hex: 0x010700
	MapContainsValueCodecRequestMessageType = int32(67328)
	// hex: 0x010701
	MapContainsValueCodecResponseMessageType = int32(67329)

	MapContainsValueCodecRequestInitialFrameSize = proto.PartitionIDOffset + proto.IntSizeInBytes

	MapContainsValueResponseResponseOffset = proto.ResponseBackupAcksOffset + proto.ByteSizeInBytes
)
View Source 
const (
	// hex: 0x010900
	MapDeleteCodecRequestMessageType = int32(67840)
	// hex: 0x010901
	MapDeleteCodecResponseMessageType = int32(67841)

	MapDeleteCodecRequestThreadIdOffset   = proto.PartitionIDOffset + proto.IntSizeInBytes
	MapDeleteCodecRequestInitialFrameSize = MapDeleteCodecRequestThreadIdOffset + proto.LongSizeInBytes
)
View Source 
const (
	// hex: 0x012800
	MapEntriesWithPredicateCodecRequestMessageType = int32(75776)
	// hex: 0x012801
	MapEntriesWithPredicateCodecResponseMessageType = int32(75777)

	MapEntriesWithPredicateCodecRequestInitialFrameSize = proto.PartitionIDOffset + proto.IntSizeInBytes
)
View Source 
const (
	// hex: 0x012500
	MapEntrySetCodecRequestMessageType = int32(75008)
	// hex: 0x012501
	MapEntrySetCodecResponseMessageType = int32(75009)

	MapEntrySetCodecRequestInitialFrameSize = proto.PartitionIDOffset + proto.IntSizeInBytes
)
View Source 
const (
	// hex: 0x011F00
	MapEvictAllCodecRequestMessageType = int32(73472)
	// hex: 0x011F01
	MapEvictAllCodecResponseMessageType = int32(73473)

	MapEvictAllCodecRequestInitialFrameSize = proto.PartitionIDOffset + proto.IntSizeInBytes
)
View Source 
const (
	// hex: 0x011E00
	MapEvictCodecRequestMessageType = int32(73216)
	// hex: 0x011E01
	MapEvictCodecResponseMessageType = int32(73217)

	MapEvictCodecRequestThreadIdOffset   = proto.PartitionIDOffset + proto.IntSizeInBytes
	MapEvictCodecRequestInitialFrameSize = MapEvictCodecRequestThreadIdOffset + proto.LongSizeInBytes

	MapEvictResponseResponseOffset = proto.ResponseBackupAcksOffset + proto.ByteSizeInBytes
)
View Source 
const (
	// hex: 0x013000
	MapExecuteOnAllKeysCodecRequestMessageType = int32(77824)
	// hex: 0x013001
	MapExecuteOnAllKeysCodecResponseMessageType = int32(77825)

	MapExecuteOnAllKeysCodecRequestInitialFrameSize = proto.PartitionIDOffset + proto.IntSizeInBytes
)
View Source 
const (
	// hex: 0x012E00
	MapExecuteOnKeyCodecRequestMessageType = int32(77312)
	// hex: 0x012E01
	MapExecuteOnKeyCodecResponseMessageType = int32(77313)

	MapExecuteOnKeyCodecRequestThreadIdOffset   = proto.PartitionIDOffset + proto.IntSizeInBytes
	MapExecuteOnKeyCodecRequestInitialFrameSize = MapExecuteOnKeyCodecRequestThreadIdOffset + proto.LongSizeInBytes
)
View Source 
const (
	// hex: 0x013200
	MapExecuteOnKeysCodecRequestMessageType = int32(78336)
	// hex: 0x013201
	MapExecuteOnKeysCodecResponseMessageType = int32(78337)

	MapExecuteOnKeysCodecRequestInitialFrameSize = proto.PartitionIDOffset + proto.IntSizeInBytes
)
View Source 
const (
	// hex: 0x013100
	MapExecuteWithPredicateCodecRequestMessageType = int32(78080)
	// hex: 0x013101
	MapExecuteWithPredicateCodecResponseMessageType = int32(78081)

	MapExecuteWithPredicateCodecRequestInitialFrameSize = proto.PartitionIDOffset + proto.IntSizeInBytes
)
View Source 
const (
	// hex: 0x013800
	MapFetchEntriesCodecRequestMessageType = int32(79872)
	// hex: 0x013801
	MapFetchEntriesCodecResponseMessageType = int32(79873)

	MapFetchEntriesCodecRequestBatchOffset      = proto.PartitionIDOffset + proto.IntSizeInBytes
	MapFetchEntriesCodecRequestInitialFrameSize = MapFetchEntriesCodecRequestBatchOffset + proto.IntSizeInBytes
)
View Source 
const (
	// hex: 0x013700
	MapFetchKeysCodecRequestMessageType = int32(79616)
	// hex: 0x013701
	MapFetchKeysCodecResponseMessageType = int32(79617)

	MapFetchKeysCodecRequestBatchOffset      = proto.PartitionIDOffset + proto.IntSizeInBytes
	MapFetchKeysCodecRequestInitialFrameSize = MapFetchKeysCodecRequestBatchOffset + proto.IntSizeInBytes
)
View Source 
const (
	// hex: 0x013D00
	MapFetchNearCacheInvalidationMetadataCodecRequestMessageType = int32(81152)
	// hex: 0x013D01
	MapFetchNearCacheInvalidationMetadataCodecResponseMessageType = int32(81153)

	MapFetchNearCacheInvalidationMetadataCodecRequestUuidOffset       = proto.PartitionIDOffset + proto.IntSizeInBytes
	MapFetchNearCacheInvalidationMetadataCodecRequestInitialFrameSize = MapFetchNearCacheInvalidationMetadataCodecRequestUuidOffset + proto.UuidSizeInBytes
)
View Source 
const (
	// hex: 0x010A00
	MapFlushCodecRequestMessageType = int32(68096)
	// hex: 0x010A01
	MapFlushCodecResponseMessageType = int32(68097)

	MapFlushCodecRequestInitialFrameSize = proto.PartitionIDOffset + proto.IntSizeInBytes
)
View Source 
const (
	// hex: 0x013300
	MapForceUnlockCodecRequestMessageType = int32(78592)
	// hex: 0x013301
	MapForceUnlockCodecResponseMessageType = int32(78593)

	MapForceUnlockCodecRequestReferenceIdOffset = proto.PartitionIDOffset + proto.IntSizeInBytes
	MapForceUnlockCodecRequestInitialFrameSize  = MapForceUnlockCodecRequestReferenceIdOffset + proto.LongSizeInBytes
)
View Source 
const (
	// hex: 0x012300
	MapGetAllCodecRequestMessageType = int32(74496)
	// hex: 0x012301
	MapGetAllCodecResponseMessageType = int32(74497)

	MapGetAllCodecRequestInitialFrameSize = proto.PartitionIDOffset + proto.IntSizeInBytes
)
View Source 
const (
	// hex: 0x010200
	MapGetCodecRequestMessageType = int32(66048)
	// hex: 0x010201
	MapGetCodecResponseMessageType = int32(66049)

	MapGetCodecRequestThreadIdOffset   = proto.PartitionIDOffset + proto.IntSizeInBytes
	MapGetCodecRequestInitialFrameSize = MapGetCodecRequestThreadIdOffset + proto.LongSizeInBytes
)
View Source 
const (
	// hex: 0x011D00
	MapGetEntryViewCodecRequestMessageType = int32(72960)
	// hex: 0x011D01
	MapGetEntryViewCodecResponseMessageType = int32(72961)

	MapGetEntryViewCodecRequestThreadIdOffset   = proto.PartitionIDOffset + proto.IntSizeInBytes
	MapGetEntryViewCodecRequestInitialFrameSize = MapGetEntryViewCodecRequestThreadIdOffset + proto.LongSizeInBytes

	MapGetEntryViewResponseMaxIdleOffset = proto.ResponseBackupAcksOffset + proto.ByteSizeInBytes
)
View Source 
const (
	// hex: 0x012B00
	MapIsEmptyCodecRequestMessageType = int32(76544)
	// hex: 0x012B01
	MapIsEmptyCodecResponseMessageType = int32(76545)

	MapIsEmptyCodecRequestInitialFrameSize = proto.PartitionIDOffset + proto.IntSizeInBytes

	MapIsEmptyResponseResponseOffset = proto.ResponseBackupAcksOffset + proto.ByteSizeInBytes
)
View Source 
const (
	// hex: 0x011200
	MapIsLockedCodecRequestMessageType = int32(70144)
	// hex: 0x011201
	MapIsLockedCodecResponseMessageType = int32(70145)

	MapIsLockedCodecRequestInitialFrameSize = proto.PartitionIDOffset + proto.IntSizeInBytes

	MapIsLockedResponseResponseOffset = proto.ResponseBackupAcksOffset + proto.ByteSizeInBytes
)
View Source 
const (
	// hex: 0x012200
	MapKeySetCodecRequestMessageType = int32(74240)
	// hex: 0x012201
	MapKeySetCodecResponseMessageType = int32(74241)

	MapKeySetCodecRequestInitialFrameSize = proto.PartitionIDOffset + proto.IntSizeInBytes
)
View Source 
const (
	// hex: 0x012600
	MapKeySetWithPredicateCodecRequestMessageType = int32(75264)
	// hex: 0x012601
	MapKeySetWithPredicateCodecResponseMessageType = int32(75265)

	MapKeySetWithPredicateCodecRequestInitialFrameSize = proto.PartitionIDOffset + proto.IntSizeInBytes
)
View Source 
const (
	// hex: 0x012000
	MapLoadAllCodecRequestMessageType = int32(73728)
	// hex: 0x012001
	MapLoadAllCodecResponseMessageType = int32(73729)

	MapLoadAllCodecRequestReplaceExistingValuesOffset = proto.PartitionIDOffset + proto.IntSizeInBytes
	MapLoadAllCodecRequestInitialFrameSize            = MapLoadAllCodecRequestReplaceExistingValuesOffset + proto.BooleanSizeInBytes
)
View Source 
const (
	// hex: 0x012100
	MapLoadGivenKeysCodecRequestMessageType = int32(73984)
	// hex: 0x012101
	MapLoadGivenKeysCodecResponseMessageType = int32(73985)

	MapLoadGivenKeysCodecRequestReplaceExistingValuesOffset = proto.PartitionIDOffset + proto.IntSizeInBytes
	MapLoadGivenKeysCodecRequestInitialFrameSize            = MapLoadGivenKeysCodecRequestReplaceExistingValuesOffset + proto.BooleanSizeInBytes
)
View Source 
const (
	// hex: 0x011000
	MapLockCodecRequestMessageType = int32(69632)
	// hex: 0x011001
	MapLockCodecResponseMessageType = int32(69633)

	MapLockCodecRequestThreadIdOffset    = proto.PartitionIDOffset + proto.IntSizeInBytes
	MapLockCodecRequestTtlOffset         = MapLockCodecRequestThreadIdOffset + proto.LongSizeInBytes
	MapLockCodecRequestReferenceIdOffset = MapLockCodecRequestTtlOffset + proto.LongSizeInBytes
	MapLockCodecRequestInitialFrameSize  = MapLockCodecRequestReferenceIdOffset + proto.LongSizeInBytes
)
View Source 
const (
	// hex: 0x012C00
	MapPutAllCodecRequestMessageType = int32(76800)
	// hex: 0x012C01
	MapPutAllCodecResponseMessageType = int32(76801)

	MapPutAllCodecRequestTriggerMapLoaderOffset = proto.PartitionIDOffset + proto.IntSizeInBytes
	MapPutAllCodecRequestInitialFrameSize       = MapPutAllCodecRequestTriggerMapLoaderOffset + proto.BooleanSizeInBytes
)
View Source 
const (
	// hex: 0x010100
	MapPutCodecRequestMessageType = int32(65792)
	// hex: 0x010101
	MapPutCodecResponseMessageType = int32(65793)

	MapPutCodecRequestThreadIdOffset   = proto.PartitionIDOffset + proto.IntSizeInBytes
	MapPutCodecRequestTtlOffset        = MapPutCodecRequestThreadIdOffset + proto.LongSizeInBytes
	MapPutCodecRequestInitialFrameSize = MapPutCodecRequestTtlOffset + proto.LongSizeInBytes
)
View Source 
const (
	// hex: 0x010E00
	MapPutIfAbsentCodecRequestMessageType = int32(69120)
	// hex: 0x010E01
	MapPutIfAbsentCodecResponseMessageType = int32(69121)

	MapPutIfAbsentCodecRequestThreadIdOffset   = proto.PartitionIDOffset + proto.IntSizeInBytes
	MapPutIfAbsentCodecRequestTtlOffset        = MapPutIfAbsentCodecRequestThreadIdOffset + proto.LongSizeInBytes
	MapPutIfAbsentCodecRequestInitialFrameSize = MapPutIfAbsentCodecRequestTtlOffset + proto.LongSizeInBytes
)
View Source 
const (
	// hex: 0x014600
	MapPutIfAbsentWithMaxIdleCodecRequestMessageType = int32(83456)
	// hex: 0x014601
	MapPutIfAbsentWithMaxIdleCodecResponseMessageType = int32(83457)

	MapPutIfAbsentWithMaxIdleCodecRequestThreadIdOffset   = proto.PartitionIDOffset + proto.IntSizeInBytes
	MapPutIfAbsentWithMaxIdleCodecRequestTtlOffset        = MapPutIfAbsentWithMaxIdleCodecRequestThreadIdOffset + proto.LongSizeInBytes
	MapPutIfAbsentWithMaxIdleCodecRequestMaxIdleOffset    = MapPutIfAbsentWithMaxIdleCodecRequestTtlOffset + proto.LongSizeInBytes
	MapPutIfAbsentWithMaxIdleCodecRequestInitialFrameSize = MapPutIfAbsentWithMaxIdleCodecRequestMaxIdleOffset + proto.LongSizeInBytes
)
View Source 
const (
	// hex: 0x010D00
	MapPutTransientCodecRequestMessageType = int32(68864)
	// hex: 0x010D01
	MapPutTransientCodecResponseMessageType = int32(68865)

	MapPutTransientCodecRequestThreadIdOffset   = proto.PartitionIDOffset + proto.IntSizeInBytes
	MapPutTransientCodecRequestTtlOffset        = MapPutTransientCodecRequestThreadIdOffset + proto.LongSizeInBytes
	MapPutTransientCodecRequestInitialFrameSize = MapPutTransientCodecRequestTtlOffset + proto.LongSizeInBytes
)
View Source 
const (
	// hex: 0x014500
	MapPutTransientWithMaxIdleCodecRequestMessageType = int32(83200)
	// hex: 0x014501
	MapPutTransientWithMaxIdleCodecResponseMessageType = int32(83201)

	MapPutTransientWithMaxIdleCodecRequestThreadIdOffset   = proto.PartitionIDOffset + proto.IntSizeInBytes
	MapPutTransientWithMaxIdleCodecRequestTtlOffset        = MapPutTransientWithMaxIdleCodecRequestThreadIdOffset + proto.LongSizeInBytes
	MapPutTransientWithMaxIdleCodecRequestMaxIdleOffset    = MapPutTransientWithMaxIdleCodecRequestTtlOffset + proto.LongSizeInBytes
	MapPutTransientWithMaxIdleCodecRequestInitialFrameSize = MapPutTransientWithMaxIdleCodecRequestMaxIdleOffset + proto.LongSizeInBytes
)
View Source 
const (
	// hex: 0x014400
	MapPutWithMaxIdleCodecRequestMessageType = int32(82944)
	// hex: 0x014401
	MapPutWithMaxIdleCodecResponseMessageType = int32(82945)

	MapPutWithMaxIdleCodecRequestThreadIdOffset   = proto.PartitionIDOffset + proto.IntSizeInBytes
	MapPutWithMaxIdleCodecRequestTtlOffset        = MapPutWithMaxIdleCodecRequestThreadIdOffset + proto.LongSizeInBytes
	MapPutWithMaxIdleCodecRequestMaxIdleOffset    = MapPutWithMaxIdleCodecRequestTtlOffset + proto.LongSizeInBytes
	MapPutWithMaxIdleCodecRequestInitialFrameSize = MapPutWithMaxIdleCodecRequestMaxIdleOffset + proto.LongSizeInBytes
)
View Source 
const (
	// hex: 0x013E00
	MapRemoveAllCodecRequestMessageType = int32(81408)
	// hex: 0x013E01
	MapRemoveAllCodecResponseMessageType = int32(81409)

	MapRemoveAllCodecRequestInitialFrameSize = proto.PartitionIDOffset + proto.IntSizeInBytes
)
View Source 
const (
	// hex: 0x010300
	MapRemoveCodecRequestMessageType = int32(66304)
	// hex: 0x010301
	MapRemoveCodecResponseMessageType = int32(66305)

	MapRemoveCodecRequestThreadIdOffset   = proto.PartitionIDOffset + proto.IntSizeInBytes
	MapRemoveCodecRequestInitialFrameSize = MapRemoveCodecRequestThreadIdOffset + proto.LongSizeInBytes
)
View Source 
const (
	// hex: 0x011A00
	MapRemoveEntryListenerCodecRequestMessageType = int32(72192)
	// hex: 0x011A01
	MapRemoveEntryListenerCodecResponseMessageType = int32(72193)

	MapRemoveEntryListenerCodecRequestRegistrationIdOffset = proto.PartitionIDOffset + proto.IntSizeInBytes
	MapRemoveEntryListenerCodecRequestInitialFrameSize     = MapRemoveEntryListenerCodecRequestRegistrationIdOffset + proto.UuidSizeInBytes

	MapRemoveEntryListenerResponseResponseOffset = proto.ResponseBackupAcksOffset + proto.ByteSizeInBytes
)
View Source 
const (
	// hex: 0x010800
	MapRemoveIfSameCodecRequestMessageType = int32(67584)
	// hex: 0x010801
	MapRemoveIfSameCodecResponseMessageType = int32(67585)

	MapRemoveIfSameCodecRequestThreadIdOffset   = proto.PartitionIDOffset + proto.IntSizeInBytes
	MapRemoveIfSameCodecRequestInitialFrameSize = MapRemoveIfSameCodecRequestThreadIdOffset + proto.LongSizeInBytes

	MapRemoveIfSameResponseResponseOffset = proto.ResponseBackupAcksOffset + proto.ByteSizeInBytes
)
View Source 
const (
	// hex: 0x011500
	MapRemoveInterceptorCodecRequestMessageType = int32(70912)
	// hex: 0x011501
	MapRemoveInterceptorCodecResponseMessageType = int32(70913)

	MapRemoveInterceptorCodecRequestInitialFrameSize = proto.PartitionIDOffset + proto.IntSizeInBytes

	MapRemoveInterceptorResponseResponseOffset = proto.ResponseBackupAcksOffset + proto.ByteSizeInBytes
)
View Source 
const (
	// hex: 0x010400
	MapReplaceCodecRequestMessageType = int32(66560)
	// hex: 0x010401
	MapReplaceCodecResponseMessageType = int32(66561)

	MapReplaceCodecRequestThreadIdOffset   = proto.PartitionIDOffset + proto.IntSizeInBytes
	MapReplaceCodecRequestInitialFrameSize = MapReplaceCodecRequestThreadIdOffset + proto.LongSizeInBytes
)
View Source 
const (
	// hex: 0x010500
	MapReplaceIfSameCodecRequestMessageType = int32(66816)
	// hex: 0x010501
	MapReplaceIfSameCodecResponseMessageType = int32(66817)

	MapReplaceIfSameCodecRequestThreadIdOffset   = proto.PartitionIDOffset + proto.IntSizeInBytes
	MapReplaceIfSameCodecRequestInitialFrameSize = MapReplaceIfSameCodecRequestThreadIdOffset + proto.LongSizeInBytes

	MapReplaceIfSameResponseResponseOffset = proto.ResponseBackupAcksOffset + proto.ByteSizeInBytes
)
View Source 
const (
	// hex: 0x010F00
	MapSetCodecRequestMessageType = int32(69376)
	// hex: 0x010F01
	MapSetCodecResponseMessageType = int32(69377)

	MapSetCodecRequestThreadIdOffset   = proto.PartitionIDOffset + proto.IntSizeInBytes
	MapSetCodecRequestTtlOffset        = MapSetCodecRequestThreadIdOffset + proto.LongSizeInBytes
	MapSetCodecRequestInitialFrameSize = MapSetCodecRequestTtlOffset + proto.LongSizeInBytes
)
View Source 
const (
	// hex: 0x014300
	MapSetTtlCodecRequestMessageType = int32(82688)
	// hex: 0x014301
	MapSetTtlCodecResponseMessageType = int32(82689)

	MapSetTtlCodecRequestTtlOffset        = proto.PartitionIDOffset + proto.IntSizeInBytes
	MapSetTtlCodecRequestInitialFrameSize = MapSetTtlCodecRequestTtlOffset + proto.LongSizeInBytes

	MapSetTtlResponseResponseOffset = proto.ResponseBackupAcksOffset + proto.ByteSizeInBytes
)
View Source 
const (
	// hex: 0x014700
	MapSetWithMaxIdleCodecRequestMessageType = int32(83712)
	// hex: 0x014701
	MapSetWithMaxIdleCodecResponseMessageType = int32(83713)

	MapSetWithMaxIdleCodecRequestThreadIdOffset   = proto.PartitionIDOffset + proto.IntSizeInBytes
	MapSetWithMaxIdleCodecRequestTtlOffset        = MapSetWithMaxIdleCodecRequestThreadIdOffset + proto.LongSizeInBytes
	MapSetWithMaxIdleCodecRequestMaxIdleOffset    = MapSetWithMaxIdleCodecRequestTtlOffset + proto.LongSizeInBytes
	MapSetWithMaxIdleCodecRequestInitialFrameSize = MapSetWithMaxIdleCodecRequestMaxIdleOffset + proto.LongSizeInBytes
)
View Source 
const (
	// hex: 0x012A00
	MapSizeCodecRequestMessageType = int32(76288)
	// hex: 0x012A01
	MapSizeCodecResponseMessageType = int32(76289)

	MapSizeCodecRequestInitialFrameSize = proto.PartitionIDOffset + proto.IntSizeInBytes

	MapSizeResponseResponseOffset = proto.ResponseBackupAcksOffset + proto.ByteSizeInBytes
)
View Source 
const (
	// hex: 0x012F00
	MapSubmitToKeyCodecRequestMessageType = int32(77568)
	// hex: 0x012F01
	MapSubmitToKeyCodecResponseMessageType = int32(77569)

	MapSubmitToKeyCodecRequestThreadIdOffset   = proto.PartitionIDOffset + proto.IntSizeInBytes
	MapSubmitToKeyCodecRequestInitialFrameSize = MapSubmitToKeyCodecRequestThreadIdOffset + proto.LongSizeInBytes
)
View Source 
const (
	// hex: 0x011100
	MapTryLockCodecRequestMessageType = int32(69888)
	// hex: 0x011101
	MapTryLockCodecResponseMessageType = int32(69889)

	MapTryLockCodecRequestThreadIdOffset    = proto.PartitionIDOffset + proto.IntSizeInBytes
	MapTryLockCodecRequestLeaseOffset       = MapTryLockCodecRequestThreadIdOffset + proto.LongSizeInBytes
	MapTryLockCodecRequestTimeoutOffset     = MapTryLockCodecRequestLeaseOffset + proto.LongSizeInBytes
	MapTryLockCodecRequestReferenceIdOffset = MapTryLockCodecRequestTimeoutOffset + proto.LongSizeInBytes
	MapTryLockCodecRequestInitialFrameSize  = MapTryLockCodecRequestReferenceIdOffset + proto.LongSizeInBytes

	MapTryLockResponseResponseOffset = proto.ResponseBackupAcksOffset + proto.ByteSizeInBytes
)
View Source 
const (
	// hex: 0x010C00
	MapTryPutCodecRequestMessageType = int32(68608)
	// hex: 0x010C01
	MapTryPutCodecResponseMessageType = int32(68609)

	MapTryPutCodecRequestThreadIdOffset   = proto.PartitionIDOffset + proto.IntSizeInBytes
	MapTryPutCodecRequestTimeoutOffset    = MapTryPutCodecRequestThreadIdOffset + proto.LongSizeInBytes
	MapTryPutCodecRequestInitialFrameSize = MapTryPutCodecRequestTimeoutOffset + proto.LongSizeInBytes

	MapTryPutResponseResponseOffset = proto.ResponseBackupAcksOffset + proto.ByteSizeInBytes
)
View Source 
const (
	// hex: 0x010B00
	MapTryRemoveCodecRequestMessageType = int32(68352)
	// hex: 0x010B01
	MapTryRemoveCodecResponseMessageType = int32(68353)

	MapTryRemoveCodecRequestThreadIdOffset   = proto.PartitionIDOffset + proto.IntSizeInBytes
	MapTryRemoveCodecRequestTimeoutOffset    = MapTryRemoveCodecRequestThreadIdOffset + proto.LongSizeInBytes
	MapTryRemoveCodecRequestInitialFrameSize = MapTryRemoveCodecRequestTimeoutOffset + proto.LongSizeInBytes

	MapTryRemoveResponseResponseOffset = proto.ResponseBackupAcksOffset + proto.ByteSizeInBytes
)
View Source 
const (
	// hex: 0x011300
	MapUnlockCodecRequestMessageType = int32(70400)
	// hex: 0x011301
	MapUnlockCodecResponseMessageType = int32(70401)

	MapUnlockCodecRequestThreadIdOffset    = proto.PartitionIDOffset + proto.IntSizeInBytes
	MapUnlockCodecRequestReferenceIdOffset = MapUnlockCodecRequestThreadIdOffset + proto.LongSizeInBytes
	MapUnlockCodecRequestInitialFrameSize  = MapUnlockCodecRequestReferenceIdOffset + proto.LongSizeInBytes
)
View Source 
const (
	// hex: 0x012400
	MapValuesCodecRequestMessageType = int32(74752)
	// hex: 0x012401
	MapValuesCodecResponseMessageType = int32(74753)

	MapValuesCodecRequestInitialFrameSize = proto.PartitionIDOffset + proto.IntSizeInBytes
)
View Source 
const (
	// hex: 0x012700
	MapValuesWithPredicateCodecRequestMessageType = int32(75520)
	// hex: 0x012701
	MapValuesWithPredicateCodecResponseMessageType = int32(75521)

	MapValuesWithPredicateCodecRequestInitialFrameSize = proto.PartitionIDOffset + proto.IntSizeInBytes
)
View Source 
const (
	MemberInfoCodecUuidFieldOffset            = 0
	MemberInfoCodecLiteMemberFieldOffset      = MemberInfoCodecUuidFieldOffset + proto.UUIDSizeInBytes
	MemberInfoCodecLiteMemberInitialFrameSize = MemberInfoCodecLiteMemberFieldOffset + proto.BooleanSizeInBytes
)
View Source 
const (
	MemberVersionCodecMajorFieldOffset      = 0
	MemberVersionCodecMinorFieldOffset      = MemberVersionCodecMajorFieldOffset + proto.ByteSizeInBytes
	MemberVersionCodecPatchFieldOffset      = MemberVersionCodecMinorFieldOffset + proto.ByteSizeInBytes
	MemberVersionCodecPatchInitialFrameSize = MemberVersionCodecPatchFieldOffset + proto.ByteSizeInBytes
)
View Source 
const (
	// hex: 0x031000
	QueueAddAllCodecRequestMessageType = int32(200704)
	// hex: 0x031001
	QueueAddAllCodecResponseMessageType = int32(200705)

	QueueAddAllCodecRequestInitialFrameSize = proto.PartitionIDOffset + proto.IntSizeInBytes

	QueueAddAllResponseResponseOffset = proto.ResponseBackupAcksOffset + proto.ByteSizeInBytes
)
View Source 
const (
	// hex: 0x031100
	QueueAddListenerCodecRequestMessageType = int32(200960)
	// hex: 0x031101
	QueueAddListenerCodecResponseMessageType = int32(200961)

	// hex: 0x031102
	QueueAddListenerCodecEventItemMessageType = int32(200962)

	QueueAddListenerCodecRequestIncludeValueOffset = proto.PartitionIDOffset + proto.IntSizeInBytes
	QueueAddListenerCodecRequestLocalOnlyOffset    = QueueAddListenerCodecRequestIncludeValueOffset + proto.BooleanSizeInBytes
	QueueAddListenerCodecRequestInitialFrameSize   = QueueAddListenerCodecRequestLocalOnlyOffset + proto.BooleanSizeInBytes

	QueueAddListenerResponseResponseOffset   = proto.ResponseBackupAcksOffset + proto.ByteSizeInBytes
	QueueAddListenerEventItemUuidOffset      = proto.PartitionIDOffset + proto.IntSizeInBytes
	QueueAddListenerEventItemEventTypeOffset = QueueAddListenerEventItemUuidOffset + proto.UuidSizeInBytes
)
View Source 
const (
	// hex: 0x030F00
	QueueClearCodecRequestMessageType = int32(200448)
	// hex: 0x030F01
	QueueClearCodecResponseMessageType = int32(200449)

	QueueClearCodecRequestInitialFrameSize = proto.PartitionIDOffset + proto.IntSizeInBytes
)
View Source 
const (
	// hex: 0x030D00
	QueueCompareAndRemoveAllCodecRequestMessageType = int32(199936)
	// hex: 0x030D01
	QueueCompareAndRemoveAllCodecResponseMessageType = int32(199937)

	QueueCompareAndRemoveAllCodecRequestInitialFrameSize = proto.PartitionIDOffset + proto.IntSizeInBytes

	QueueCompareAndRemoveAllResponseResponseOffset = proto.ResponseBackupAcksOffset + proto.ByteSizeInBytes
)
View Source 
const (
	// hex: 0x030E00
	QueueCompareAndRetainAllCodecRequestMessageType = int32(200192)
	// hex: 0x030E01
	QueueCompareAndRetainAllCodecResponseMessageType = int32(200193)

	QueueCompareAndRetainAllCodecRequestInitialFrameSize = proto.PartitionIDOffset + proto.IntSizeInBytes

	QueueCompareAndRetainAllResponseResponseOffset = proto.ResponseBackupAcksOffset + proto.ByteSizeInBytes
)
View Source 
const (
	// hex: 0x030C00
	QueueContainsAllCodecRequestMessageType = int32(199680)
	// hex: 0x030C01
	QueueContainsAllCodecResponseMessageType = int32(199681)

	QueueContainsAllCodecRequestInitialFrameSize = proto.PartitionIDOffset + proto.IntSizeInBytes

	QueueContainsAllResponseResponseOffset = proto.ResponseBackupAcksOffset + proto.ByteSizeInBytes
)
View Source 
const (
	// hex: 0x030B00
	QueueContainsCodecRequestMessageType = int32(199424)
	// hex: 0x030B01
	QueueContainsCodecResponseMessageType = int32(199425)

	QueueContainsCodecRequestInitialFrameSize = proto.PartitionIDOffset + proto.IntSizeInBytes

	QueueContainsResponseResponseOffset = proto.ResponseBackupAcksOffset + proto.ByteSizeInBytes
)
View Source 
const (
	// hex: 0x030900
	QueueDrainToCodecRequestMessageType = int32(198912)
	// hex: 0x030901
	QueueDrainToCodecResponseMessageType = int32(198913)

	QueueDrainToCodecRequestInitialFrameSize = proto.PartitionIDOffset + proto.IntSizeInBytes
)
View Source 
const (
	// hex: 0x030A00
	QueueDrainToMaxSizeCodecRequestMessageType = int32(199168)
	// hex: 0x030A01
	QueueDrainToMaxSizeCodecResponseMessageType = int32(199169)

	QueueDrainToMaxSizeCodecRequestMaxSizeOffset    = proto.PartitionIDOffset + proto.IntSizeInBytes
	QueueDrainToMaxSizeCodecRequestInitialFrameSize = QueueDrainToMaxSizeCodecRequestMaxSizeOffset + proto.IntSizeInBytes
)
View Source 
const (
	// hex: 0x031400
	QueueIsEmptyCodecRequestMessageType = int32(201728)
	// hex: 0x031401
	QueueIsEmptyCodecResponseMessageType = int32(201729)

	QueueIsEmptyCodecRequestInitialFrameSize = proto.PartitionIDOffset + proto.IntSizeInBytes

	QueueIsEmptyResponseResponseOffset = proto.ResponseBackupAcksOffset + proto.ByteSizeInBytes
)
View Source 
const (
	// hex: 0x030800
	QueueIteratorCodecRequestMessageType = int32(198656)
	// hex: 0x030801
	QueueIteratorCodecResponseMessageType = int32(198657)

	QueueIteratorCodecRequestInitialFrameSize = proto.PartitionIDOffset + proto.IntSizeInBytes
)
View Source 
const (
	// hex: 0x030100
	QueueOfferCodecRequestMessageType = int32(196864)
	// hex: 0x030101
	QueueOfferCodecResponseMessageType = int32(196865)

	QueueOfferCodecRequestTimeoutMillisOffset = proto.PartitionIDOffset + proto.IntSizeInBytes
	QueueOfferCodecRequestInitialFrameSize    = QueueOfferCodecRequestTimeoutMillisOffset + proto.LongSizeInBytes

	QueueOfferResponseResponseOffset = proto.ResponseBackupAcksOffset + proto.ByteSizeInBytes
)
View Source 
const (
	// hex: 0x030700
	QueuePeekCodecRequestMessageType = int32(198400)
	// hex: 0x030701
	QueuePeekCodecResponseMessageType = int32(198401)

	QueuePeekCodecRequestInitialFrameSize = proto.PartitionIDOffset + proto.IntSizeInBytes
)
View Source 
const (
	// hex: 0x030500
	QueuePollCodecRequestMessageType = int32(197888)
	// hex: 0x030501
	QueuePollCodecResponseMessageType = int32(197889)

	QueuePollCodecRequestTimeoutMillisOffset = proto.PartitionIDOffset + proto.IntSizeInBytes
	QueuePollCodecRequestInitialFrameSize    = QueuePollCodecRequestTimeoutMillisOffset + proto.LongSizeInBytes
)
View Source 
const (
	// hex: 0x030200
	QueuePutCodecRequestMessageType = int32(197120)
	// hex: 0x030201
	QueuePutCodecResponseMessageType = int32(197121)

	QueuePutCodecRequestInitialFrameSize = proto.PartitionIDOffset + proto.IntSizeInBytes
)
View Source 
const (
	// hex: 0x031300
	QueueRemainingCapacityCodecRequestMessageType = int32(201472)
	// hex: 0x031301
	QueueRemainingCapacityCodecResponseMessageType = int32(201473)

	QueueRemainingCapacityCodecRequestInitialFrameSize = proto.PartitionIDOffset + proto.IntSizeInBytes

	QueueRemainingCapacityResponseResponseOffset = proto.ResponseBackupAcksOffset + proto.ByteSizeInBytes
)
View Source 
const (
	// hex: 0x030400
	QueueRemoveCodecRequestMessageType = int32(197632)
	// hex: 0x030401
	QueueRemoveCodecResponseMessageType = int32(197633)

	QueueRemoveCodecRequestInitialFrameSize = proto.PartitionIDOffset + proto.IntSizeInBytes

	QueueRemoveResponseResponseOffset = proto.ResponseBackupAcksOffset + proto.ByteSizeInBytes
)
View Source 
const (
	// hex: 0x031200
	QueueRemoveListenerCodecRequestMessageType = int32(201216)
	// hex: 0x031201
	QueueRemoveListenerCodecResponseMessageType = int32(201217)

	QueueRemoveListenerCodecRequestRegistrationIdOffset = proto.PartitionIDOffset + proto.IntSizeInBytes
	QueueRemoveListenerCodecRequestInitialFrameSize     = QueueRemoveListenerCodecRequestRegistrationIdOffset + proto.UuidSizeInBytes

	QueueRemoveListenerResponseResponseOffset = proto.ResponseBackupAcksOffset + proto.ByteSizeInBytes
)
View Source 
const (
	// hex: 0x030300
	QueueSizeCodecRequestMessageType = int32(197376)
	// hex: 0x030301
	QueueSizeCodecResponseMessageType = int32(197377)

	QueueSizeCodecRequestInitialFrameSize = proto.PartitionIDOffset + proto.IntSizeInBytes

	QueueSizeResponseResponseOffset = proto.ResponseBackupAcksOffset + proto.ByteSizeInBytes
)
View Source 
const (
	// hex: 0x030600
	QueueTakeCodecRequestMessageType = int32(198144)
	// hex: 0x030601
	QueueTakeCodecResponseMessageType = int32(198145)

	QueueTakeCodecRequestInitialFrameSize = proto.PartitionIDOffset + proto.IntSizeInBytes
)
View Source 
const (
	// hex: 0x0D0D00
	ReplicatedMapAddEntryListenerCodecRequestMessageType = int32(855296)
	// hex: 0x0D0D01
	ReplicatedMapAddEntryListenerCodecResponseMessageType = int32(855297)

	// hex: 0x0D0D02
	ReplicatedMapAddEntryListenerCodecEventEntryMessageType = int32(855298)

	ReplicatedMapAddEntryListenerCodecRequestLocalOnlyOffset  = proto.PartitionIDOffset + proto.IntSizeInBytes
	ReplicatedMapAddEntryListenerCodecRequestInitialFrameSize = ReplicatedMapAddEntryListenerCodecRequestLocalOnlyOffset + proto.BooleanSizeInBytes

	ReplicatedMapAddEntryListenerResponseResponseOffset                  = proto.ResponseBackupAcksOffset + proto.ByteSizeInBytes
	ReplicatedMapAddEntryListenerEventEntryEventTypeOffset               = proto.PartitionIDOffset + proto.IntSizeInBytes
	ReplicatedMapAddEntryListenerEventEntryUuidOffset                    = ReplicatedMapAddEntryListenerEventEntryEventTypeOffset + proto.IntSizeInBytes
	ReplicatedMapAddEntryListenerEventEntryNumberOfAffectedEntriesOffset = ReplicatedMapAddEntryListenerEventEntryUuidOffset + proto.UuidSizeInBytes
)
View Source 
const (
	// hex: 0x0D0C00
	ReplicatedMapAddEntryListenerToKeyCodecRequestMessageType = int32(855040)
	// hex: 0x0D0C01
	ReplicatedMapAddEntryListenerToKeyCodecResponseMessageType = int32(855041)

	// hex: 0x0D0C02
	ReplicatedMapAddEntryListenerToKeyCodecEventEntryMessageType = int32(855042)

	ReplicatedMapAddEntryListenerToKeyCodecRequestLocalOnlyOffset  = proto.PartitionIDOffset + proto.IntSizeInBytes
	ReplicatedMapAddEntryListenerToKeyCodecRequestInitialFrameSize = ReplicatedMapAddEntryListenerToKeyCodecRequestLocalOnlyOffset + proto.BooleanSizeInBytes

	ReplicatedMapAddEntryListenerToKeyResponseResponseOffset                  = proto.ResponseBackupAcksOffset + proto.ByteSizeInBytes
	ReplicatedMapAddEntryListenerToKeyEventEntryEventTypeOffset               = proto.PartitionIDOffset + proto.IntSizeInBytes
	ReplicatedMapAddEntryListenerToKeyEventEntryUuidOffset                    = ReplicatedMapAddEntryListenerToKeyEventEntryEventTypeOffset + proto.IntSizeInBytes
	ReplicatedMapAddEntryListenerToKeyEventEntryNumberOfAffectedEntriesOffset = ReplicatedMapAddEntryListenerToKeyEventEntryUuidOffset + proto.UuidSizeInBytes
)
View Source 
const (
	// hex: 0x0D0A00
	ReplicatedMapAddEntryListenerToKeyWithPredicateCodecRequestMessageType = int32(854528)
	// hex: 0x0D0A01
	ReplicatedMapAddEntryListenerToKeyWithPredicateCodecResponseMessageType = int32(854529)

	// hex: 0x0D0A02
	ReplicatedMapAddEntryListenerToKeyWithPredicateCodecEventEntryMessageType = int32(854530)

	ReplicatedMapAddEntryListenerToKeyWithPredicateCodecRequestLocalOnlyOffset  = proto.PartitionIDOffset + proto.IntSizeInBytes
	ReplicatedMapAddEntryListenerToKeyWithPredicateCodecRequestInitialFrameSize = ReplicatedMapAddEntryListenerToKeyWithPredicateCodecRequestLocalOnlyOffset + proto.BooleanSizeInBytes

	ReplicatedMapAddEntryListenerToKeyWithPredicateResponseResponseOffset                  = proto.ResponseBackupAcksOffset + proto.ByteSizeInBytes
	ReplicatedMapAddEntryListenerToKeyWithPredicateEventEntryEventTypeOffset               = proto.PartitionIDOffset + proto.IntSizeInBytes
	ReplicatedMapAddEntryListenerToKeyWithPredicateEventEntryUuidOffset                    = ReplicatedMapAddEntryListenerToKeyWithPredicateEventEntryEventTypeOffset + proto.IntSizeInBytes
	ReplicatedMapAddEntryListenerToKeyWithPredicateEventEntryNumberOfAffectedEntriesOffset = ReplicatedMapAddEntryListenerToKeyWithPredicateEventEntryUuidOffset + proto.UuidSizeInBytes
)
View Source 
const (
	// hex: 0x0D0B00
	ReplicatedMapAddEntryListenerWithPredicateCodecRequestMessageType = int32(854784)
	// hex: 0x0D0B01
	ReplicatedMapAddEntryListenerWithPredicateCodecResponseMessageType = int32(854785)

	// hex: 0x0D0B02
	ReplicatedMapAddEntryListenerWithPredicateCodecEventEntryMessageType = int32(854786)

	ReplicatedMapAddEntryListenerWithPredicateCodecRequestLocalOnlyOffset  = proto.PartitionIDOffset + proto.IntSizeInBytes
	ReplicatedMapAddEntryListenerWithPredicateCodecRequestInitialFrameSize = ReplicatedMapAddEntryListenerWithPredicateCodecRequestLocalOnlyOffset + proto.BooleanSizeInBytes

	ReplicatedMapAddEntryListenerWithPredicateResponseResponseOffset                  = proto.ResponseBackupAcksOffset + proto.ByteSizeInBytes
	ReplicatedMapAddEntryListenerWithPredicateEventEntryEventTypeOffset               = proto.PartitionIDOffset + proto.IntSizeInBytes
	ReplicatedMapAddEntryListenerWithPredicateEventEntryUuidOffset                    = ReplicatedMapAddEntryListenerWithPredicateEventEntryEventTypeOffset + proto.IntSizeInBytes
	ReplicatedMapAddEntryListenerWithPredicateEventEntryNumberOfAffectedEntriesOffset = ReplicatedMapAddEntryListenerWithPredicateEventEntryUuidOffset + proto.UuidSizeInBytes
)
View Source 
const (
	// hex: 0x0D1200
	ReplicatedMapAddNearCacheEntryListenerCodecRequestMessageType = int32(856576)
	// hex: 0x0D1201
	ReplicatedMapAddNearCacheEntryListenerCodecResponseMessageType = int32(856577)

	// hex: 0x0D1202
	ReplicatedMapAddNearCacheEntryListenerCodecEventEntryMessageType = int32(856578)

	ReplicatedMapAddNearCacheEntryListenerCodecRequestIncludeValueOffset = proto.PartitionIDOffset + proto.IntSizeInBytes
	ReplicatedMapAddNearCacheEntryListenerCodecRequestLocalOnlyOffset    = ReplicatedMapAddNearCacheEntryListenerCodecRequestIncludeValueOffset + proto.BooleanSizeInBytes
	ReplicatedMapAddNearCacheEntryListenerCodecRequestInitialFrameSize   = ReplicatedMapAddNearCacheEntryListenerCodecRequestLocalOnlyOffset + proto.BooleanSizeInBytes

	ReplicatedMapAddNearCacheEntryListenerResponseResponseOffset                  = proto.ResponseBackupAcksOffset + proto.ByteSizeInBytes
	ReplicatedMapAddNearCacheEntryListenerEventEntryEventTypeOffset               = proto.PartitionIDOffset + proto.IntSizeInBytes
	ReplicatedMapAddNearCacheEntryListenerEventEntryUuidOffset                    = ReplicatedMapAddNearCacheEntryListenerEventEntryEventTypeOffset + proto.IntSizeInBytes
	ReplicatedMapAddNearCacheEntryListenerEventEntryNumberOfAffectedEntriesOffset = ReplicatedMapAddNearCacheEntryListenerEventEntryUuidOffset + proto.UuidSizeInBytes
)
View Source 
const (
	// hex: 0x0D0900
	ReplicatedMapClearCodecRequestMessageType = int32(854272)
	// hex: 0x0D0901
	ReplicatedMapClearCodecResponseMessageType = int32(854273)

	ReplicatedMapClearCodecRequestInitialFrameSize = proto.PartitionIDOffset + proto.IntSizeInBytes
)
View Source 
const (
	// hex: 0x0D0400
	ReplicatedMapContainsKeyCodecRequestMessageType = int32(852992)
	// hex: 0x0D0401
	ReplicatedMapContainsKeyCodecResponseMessageType = int32(852993)

	ReplicatedMapContainsKeyCodecRequestInitialFrameSize = proto.PartitionIDOffset + proto.IntSizeInBytes

	ReplicatedMapContainsKeyResponseResponseOffset = proto.ResponseBackupAcksOffset + proto.ByteSizeInBytes
)
View Source 
const (
	// hex: 0x0D0500
	ReplicatedMapContainsValueCodecRequestMessageType = int32(853248)
	// hex: 0x0D0501
	ReplicatedMapContainsValueCodecResponseMessageType = int32(853249)

	ReplicatedMapContainsValueCodecRequestInitialFrameSize = proto.PartitionIDOffset + proto.IntSizeInBytes

	ReplicatedMapContainsValueResponseResponseOffset = proto.ResponseBackupAcksOffset + proto.ByteSizeInBytes
)
View Source 
const (
	// hex: 0x0D1100
	ReplicatedMapEntrySetCodecRequestMessageType = int32(856320)
	// hex: 0x0D1101
	ReplicatedMapEntrySetCodecResponseMessageType = int32(856321)

	ReplicatedMapEntrySetCodecRequestInitialFrameSize = proto.PartitionIDOffset + proto.IntSizeInBytes
)
View Source 
const (
	// hex: 0x0D0600
	ReplicatedMapGetCodecRequestMessageType = int32(853504)
	// hex: 0x0D0601
	ReplicatedMapGetCodecResponseMessageType = int32(853505)

	ReplicatedMapGetCodecRequestInitialFrameSize = proto.PartitionIDOffset + proto.IntSizeInBytes
)
View Source 
const (
	// hex: 0x0D0300
	ReplicatedMapIsEmptyCodecRequestMessageType = int32(852736)
	// hex: 0x0D0301
	ReplicatedMapIsEmptyCodecResponseMessageType = int32(852737)

	ReplicatedMapIsEmptyCodecRequestInitialFrameSize = proto.PartitionIDOffset + proto.IntSizeInBytes

	ReplicatedMapIsEmptyResponseResponseOffset = proto.ResponseBackupAcksOffset + proto.ByteSizeInBytes
)
View Source 
const (
	// hex: 0x0D0F00
	ReplicatedMapKeySetCodecRequestMessageType = int32(855808)
	// hex: 0x0D0F01
	ReplicatedMapKeySetCodecResponseMessageType = int32(855809)

	ReplicatedMapKeySetCodecRequestInitialFrameSize = proto.PartitionIDOffset + proto.IntSizeInBytes
)
View Source 
const (
	// hex: 0x0D0800
	ReplicatedMapPutAllCodecRequestMessageType = int32(854016)
	// hex: 0x0D0801
	ReplicatedMapPutAllCodecResponseMessageType = int32(854017)

	ReplicatedMapPutAllCodecRequestInitialFrameSize = proto.PartitionIDOffset + proto.IntSizeInBytes
)
View Source 
const (
	// hex: 0x0D0100
	ReplicatedMapPutCodecRequestMessageType = int32(852224)
	// hex: 0x0D0101
	ReplicatedMapPutCodecResponseMessageType = int32(852225)

	ReplicatedMapPutCodecRequestTtlOffset        = proto.PartitionIDOffset + proto.IntSizeInBytes
	ReplicatedMapPutCodecRequestInitialFrameSize = ReplicatedMapPutCodecRequestTtlOffset + proto.LongSizeInBytes
)
View Source 
const (
	// hex: 0x0D0700
	ReplicatedMapRemoveCodecRequestMessageType = int32(853760)
	// hex: 0x0D0701
	ReplicatedMapRemoveCodecResponseMessageType = int32(853761)

	ReplicatedMapRemoveCodecRequestInitialFrameSize = proto.PartitionIDOffset + proto.IntSizeInBytes
)
View Source 
const (
	// hex: 0x0D0E00
	ReplicatedMapRemoveEntryListenerCodecRequestMessageType = int32(855552)
	// hex: 0x0D0E01
	ReplicatedMapRemoveEntryListenerCodecResponseMessageType = int32(855553)

	ReplicatedMapRemoveEntryListenerCodecRequestRegistrationIdOffset = proto.PartitionIDOffset + proto.IntSizeInBytes
	ReplicatedMapRemoveEntryListenerCodecRequestInitialFrameSize     = ReplicatedMapRemoveEntryListenerCodecRequestRegistrationIdOffset + proto.UuidSizeInBytes

	ReplicatedMapRemoveEntryListenerResponseResponseOffset = proto.ResponseBackupAcksOffset + proto.ByteSizeInBytes
)
View Source 
const (
	// hex: 0x0D0200
	ReplicatedMapSizeCodecRequestMessageType = int32(852480)
	// hex: 0x0D0201
	ReplicatedMapSizeCodecResponseMessageType = int32(852481)

	ReplicatedMapSizeCodecRequestInitialFrameSize = proto.PartitionIDOffset + proto.IntSizeInBytes

	ReplicatedMapSizeResponseResponseOffset = proto.ResponseBackupAcksOffset + proto.ByteSizeInBytes
)
View Source 
const (
	// hex: 0x0D1000
	ReplicatedMapValuesCodecRequestMessageType = int32(856064)
	// hex: 0x0D1001
	ReplicatedMapValuesCodecResponseMessageType = int32(856065)

	ReplicatedMapValuesCodecRequestInitialFrameSize = proto.PartitionIDOffset + proto.IntSizeInBytes
)
View Source 
const (
	// hex: 0x060600
	SetAddAllCodecRequestMessageType = int32(394752)
	// hex: 0x060601
	SetAddAllCodecResponseMessageType = int32(394753)

	SetAddAllCodecRequestInitialFrameSize = proto.PartitionIDOffset + proto.IntSizeInBytes

	SetAddAllResponseResponseOffset = proto.ResponseBackupAcksOffset + proto.ByteSizeInBytes
)
View Source 
const (
	// hex: 0x060400
	SetAddCodecRequestMessageType = int32(394240)
	// hex: 0x060401
	SetAddCodecResponseMessageType = int32(394241)

	SetAddCodecRequestInitialFrameSize = proto.PartitionIDOffset + proto.IntSizeInBytes

	SetAddResponseResponseOffset = proto.ResponseBackupAcksOffset + proto.ByteSizeInBytes
)
View Source 
const (
	// hex: 0x060B00
	SetAddListenerCodecRequestMessageType = int32(396032)
	// hex: 0x060B01
	SetAddListenerCodecResponseMessageType = int32(396033)

	// hex: 0x060B02
	SetAddListenerCodecEventItemMessageType = int32(396034)

	SetAddListenerCodecRequestIncludeValueOffset = proto.PartitionIDOffset + proto.IntSizeInBytes
	SetAddListenerCodecRequestLocalOnlyOffset    = SetAddListenerCodecRequestIncludeValueOffset + proto.BooleanSizeInBytes
	SetAddListenerCodecRequestInitialFrameSize   = SetAddListenerCodecRequestLocalOnlyOffset + proto.BooleanSizeInBytes

	SetAddListenerResponseResponseOffset   = proto.ResponseBackupAcksOffset + proto.ByteSizeInBytes
	SetAddListenerEventItemUuidOffset      = proto.PartitionIDOffset + proto.IntSizeInBytes
	SetAddListenerEventItemEventTypeOffset = SetAddListenerEventItemUuidOffset + proto.UuidSizeInBytes
)
View Source 
const (
	// hex: 0x060900
	SetClearCodecRequestMessageType = int32(395520)
	// hex: 0x060901
	SetClearCodecResponseMessageType = int32(395521)

	SetClearCodecRequestInitialFrameSize = proto.PartitionIDOffset + proto.IntSizeInBytes
)
View Source 
const (
	// hex: 0x060700
	SetCompareAndRemoveAllCodecRequestMessageType = int32(395008)
	// hex: 0x060701
	SetCompareAndRemoveAllCodecResponseMessageType = int32(395009)

	SetCompareAndRemoveAllCodecRequestInitialFrameSize = proto.PartitionIDOffset + proto.IntSizeInBytes

	SetCompareAndRemoveAllResponseResponseOffset = proto.ResponseBackupAcksOffset + proto.ByteSizeInBytes
)
View Source 
const (
	// hex: 0x060800
	SetCompareAndRetainAllCodecRequestMessageType = int32(395264)
	// hex: 0x060801
	SetCompareAndRetainAllCodecResponseMessageType = int32(395265)

	SetCompareAndRetainAllCodecRequestInitialFrameSize = proto.PartitionIDOffset + proto.IntSizeInBytes

	SetCompareAndRetainAllResponseResponseOffset = proto.ResponseBackupAcksOffset + proto.ByteSizeInBytes
)
View Source 
const (
	// hex: 0x060300
	SetContainsAllCodecRequestMessageType = int32(393984)
	// hex: 0x060301
	SetContainsAllCodecResponseMessageType = int32(393985)

	SetContainsAllCodecRequestInitialFrameSize = proto.PartitionIDOffset + proto.IntSizeInBytes

	SetContainsAllResponseResponseOffset = proto.ResponseBackupAcksOffset + proto.ByteSizeInBytes
)
View Source 
const (
	// hex: 0x060200
	SetContainsCodecRequestMessageType = int32(393728)
	// hex: 0x060201
	SetContainsCodecResponseMessageType = int32(393729)

	SetContainsCodecRequestInitialFrameSize = proto.PartitionIDOffset + proto.IntSizeInBytes

	SetContainsResponseResponseOffset = proto.ResponseBackupAcksOffset + proto.ByteSizeInBytes
)
View Source 
const (
	// hex: 0x060A00
	SetGetAllCodecRequestMessageType = int32(395776)
	// hex: 0x060A01
	SetGetAllCodecResponseMessageType = int32(395777)

	SetGetAllCodecRequestInitialFrameSize = proto.PartitionIDOffset + proto.IntSizeInBytes
)
View Source 
const (
	// hex: 0x060D00
	SetIsEmptyCodecRequestMessageType = int32(396544)
	// hex: 0x060D01
	SetIsEmptyCodecResponseMessageType = int32(396545)

	SetIsEmptyCodecRequestInitialFrameSize = proto.PartitionIDOffset + proto.IntSizeInBytes

	SetIsEmptyResponseResponseOffset = proto.ResponseBackupAcksOffset + proto.ByteSizeInBytes
)
View Source 
const (
	// hex: 0x060500
	SetRemoveCodecRequestMessageType = int32(394496)
	// hex: 0x060501
	SetRemoveCodecResponseMessageType = int32(394497)

	SetRemoveCodecRequestInitialFrameSize = proto.PartitionIDOffset + proto.IntSizeInBytes

	SetRemoveResponseResponseOffset = proto.ResponseBackupAcksOffset + proto.ByteSizeInBytes
)
View Source 
const (
	// hex: 0x060C00
	SetRemoveListenerCodecRequestMessageType = int32(396288)
	// hex: 0x060C01
	SetRemoveListenerCodecResponseMessageType = int32(396289)

	SetRemoveListenerCodecRequestRegistrationIdOffset = proto.PartitionIDOffset + proto.IntSizeInBytes
	SetRemoveListenerCodecRequestInitialFrameSize     = SetRemoveListenerCodecRequestRegistrationIdOffset + proto.UuidSizeInBytes

	SetRemoveListenerResponseResponseOffset = proto.ResponseBackupAcksOffset + proto.ByteSizeInBytes
)
View Source 
const (
	// hex: 0x060100
	SetSizeCodecRequestMessageType = int32(393472)
	// hex: 0x060101
	SetSizeCodecResponseMessageType = int32(393473)

	SetSizeCodecRequestInitialFrameSize = proto.PartitionIDOffset + proto.IntSizeInBytes

	SetSizeResponseResponseOffset = proto.ResponseBackupAcksOffset + proto.ByteSizeInBytes
)
View Source 
const (
	SimpleEntryViewCodecCostFieldOffset           = 0
	SimpleEntryViewCodecCreationTimeFieldOffset   = SimpleEntryViewCodecCostFieldOffset + proto.LongSizeInBytes
	SimpleEntryViewCodecExpirationTimeFieldOffset = SimpleEntryViewCodecCreationTimeFieldOffset + proto.LongSizeInBytes
	SimpleEntryViewCodecHitsFieldOffset           = SimpleEntryViewCodecExpirationTimeFieldOffset + proto.LongSizeInBytes
	SimpleEntryViewCodecLastAccessTimeFieldOffset = SimpleEntryViewCodecHitsFieldOffset + proto.LongSizeInBytes
	SimpleEntryViewCodecLastStoredTimeFieldOffset = SimpleEntryViewCodecLastAccessTimeFieldOffset + proto.LongSizeInBytes
	SimpleEntryViewCodecLastUpdateTimeFieldOffset = SimpleEntryViewCodecLastStoredTimeFieldOffset + proto.LongSizeInBytes
	SimpleEntryViewCodecVersionFieldOffset        = SimpleEntryViewCodecLastUpdateTimeFieldOffset + proto.LongSizeInBytes
	SimpleEntryViewCodecTtlFieldOffset            = SimpleEntryViewCodecVersionFieldOffset + proto.LongSizeInBytes
	SimpleEntryViewCodecMaxIdleFieldOffset        = SimpleEntryViewCodecTtlFieldOffset + proto.LongSizeInBytes
	SimpleEntryViewCodecMaxIdleInitialFrameSize   = SimpleEntryViewCodecMaxIdleFieldOffset + proto.LongSizeInBytes
)
View Source 
const (
	StackTraceElementCodecLineNumberFieldOffset      = 0
	StackTraceElementCodecLineNumberInitialFrameSize = StackTraceElementCodecLineNumberFieldOffset + proto.IntSizeInBytes
)
View Source 
const (
	// hex: 0x040200
	TopicAddMessageListenerCodecRequestMessageType = int32(262656)
	// hex: 0x040201
	TopicAddMessageListenerCodecResponseMessageType = int32(262657)

	// hex: 0x040202
	TopicAddMessageListenerCodecEventTopicMessageType = int32(262658)

	TopicAddMessageListenerCodecRequestLocalOnlyOffset  = proto.PartitionIDOffset + proto.IntSizeInBytes
	TopicAddMessageListenerCodecRequestInitialFrameSize = TopicAddMessageListenerCodecRequestLocalOnlyOffset + proto.BooleanSizeInBytes

	TopicAddMessageListenerResponseResponseOffset      = proto.ResponseBackupAcksOffset + proto.ByteSizeInBytes
	TopicAddMessageListenerEventTopicPublishTimeOffset = proto.PartitionIDOffset + proto.IntSizeInBytes
	TopicAddMessageListenerEventTopicUuidOffset        = TopicAddMessageListenerEventTopicPublishTimeOffset + proto.LongSizeInBytes
)
View Source 
const (
	// hex: 0x040400
	TopicPublishAllCodecRequestMessageType = int32(263168)
	// hex: 0x040401
	TopicPublishAllCodecResponseMessageType = int32(263169)

	TopicPublishAllCodecRequestInitialFrameSize = proto.PartitionIDOffset + proto.IntSizeInBytes
)
View Source 
const (
	// hex: 0x040100
	TopicPublishCodecRequestMessageType = int32(262400)
	// hex: 0x040101
	TopicPublishCodecResponseMessageType = int32(262401)

	TopicPublishCodecRequestInitialFrameSize = proto.PartitionIDOffset + proto.IntSizeInBytes
)
View Source 
const (
	// hex: 0x040300
	TopicRemoveMessageListenerCodecRequestMessageType = int32(262912)
	// hex: 0x040301
	TopicRemoveMessageListenerCodecResponseMessageType = int32(262913)

	TopicRemoveMessageListenerCodecRequestRegistrationIdOffset = proto.PartitionIDOffset + proto.IntSizeInBytes
	TopicRemoveMessageListenerCodecRequestInitialFrameSize     = TopicRemoveMessageListenerCodecRequestRegistrationIdOffset + proto.UuidSizeInBytes

	TopicRemoveMessageListenerResponseResponseOffset = proto.ResponseBackupAcksOffset + proto.ByteSizeInBytes
)

Variables

View Source 
var CodecUtil codecUtil
View Source 
var FixSizedTypesCodec fixSizedTypesCodec

Functions

func DecodeAddress 

func DecodeAddress(frameIterator *proto.ForwardFrameIterator) cluster.Address

func DecodeBitmapIndexOptions 

func DecodeBitmapIndexOptions(frameIterator *proto.ForwardFrameIterator) types.BitmapIndexOptions

func DecodeByteArray 

func DecodeByteArray(frameIterator *proto.ForwardFrameIterator) []byte

func DecodeClientAuthenticationResponse 

func DecodeClientAuthenticationResponse(clientMessage *proto.ClientMessage) (status byte, address cluster.Address, memberUuid types.UUID, serializationVersion byte, serverHazelcastVersion string, partitionCount int32, clusterId types.UUID, failoverSupported bool)

func DecodeData 

func DecodeData(frameIterator *proto.ForwardFrameIterator) *iserialization.Data

func DecodeEndpointQualifier 

func DecodeEndpointQualifier(frameIterator *proto.ForwardFrameIterator) pubcluster.EndpointQualifier

func DecodeEntryList 

func DecodeEntryList(frameIterator *proto.ForwardFrameIterator, keyDecoder, valueDecoder Decoder) []proto.Pair

func DecodeEntryListForDataAndData 

func DecodeEntryListForDataAndData(frameIterator *proto.ForwardFrameIterator) []proto.Pair

func DecodeEntryListForStringAndEntryListIntegerLong 

func DecodeEntryListForStringAndEntryListIntegerLong(frameIterator *proto.ForwardFrameIterator) []proto.Pair

func DecodeEntryListIntegerInteger 

func DecodeEntryListIntegerInteger(frameIterator *proto.ForwardFrameIterator) []proto.Pair

func DecodeEntryListIntegerLong 

func DecodeEntryListIntegerLong(iterator *proto.ForwardFrameIterator) []proto.Pair

func DecodeEntryListIntegerUUID 

func DecodeEntryListIntegerUUID(frameIterator *proto.ForwardFrameIterator) []proto.Pair

func DecodeEntryListUUIDListInteger 

func DecodeEntryListUUIDListInteger(frameIterator *proto.ForwardFrameIterator) []proto.Pair

func DecodeEntryListUUIDLong 

func DecodeEntryListUUIDLong(frameIterator *proto.ForwardFrameIterator) []proto.Pair

func DecodeError 

func DecodeError(msg *proto.ClientMessage) *hzerrors.ServerError

func DecodeErrorHolder 

func DecodeErrorHolder(frameIterator *proto.ForwardFrameIterator) proto.ErrorHolder

func DecodeIndexConfig 

func DecodeIndexConfig(frameIterator *proto.ForwardFrameIterator) types.IndexConfig

func DecodeListAddAllResponse 

func DecodeListAddAllResponse(clientMessage *proto.ClientMessage) bool

func DecodeListAddAllWithIndexResponse 

func DecodeListAddAllWithIndexResponse(clientMessage *proto.ClientMessage) bool

func DecodeListAddListenerResponse 

func DecodeListAddListenerResponse(clientMessage *proto.ClientMessage) types.UUID

func DecodeListAddResponse 

func DecodeListAddResponse(clientMessage *proto.ClientMessage) bool

func DecodeListCompareAndRemoveAllResponse 

func DecodeListCompareAndRemoveAllResponse(clientMessage *proto.ClientMessage) bool

func DecodeListCompareAndRetainAllResponse 

func DecodeListCompareAndRetainAllResponse(clientMessage *proto.ClientMessage) bool

func DecodeListContainsAllResponse 

func DecodeListContainsAllResponse(clientMessage *proto.ClientMessage) bool

func DecodeListContainsResponse 

func DecodeListContainsResponse(clientMessage *proto.ClientMessage) bool

func DecodeListData 

func DecodeListData(frameIterator *proto.ForwardFrameIterator) []*iserialization.Data

func DecodeListGetAllResponse 

func DecodeListGetAllResponse(clientMessage *proto.ClientMessage) []*iserialization.Data

func DecodeListGetResponse 

func DecodeListGetResponse(clientMessage *proto.ClientMessage) *iserialization.Data

func DecodeListIndexOfResponse 

func DecodeListIndexOfResponse(clientMessage *proto.ClientMessage) int32

func DecodeListInteger 

func DecodeListInteger(frameIterator *proto.ForwardFrameIterator) []int32

func DecodeListIntegerIntegerInteger 

func DecodeListIntegerIntegerInteger(frameIterator *proto.ForwardFrameIterator) []proto.Pair

func DecodeListIsEmptyResponse 

func DecodeListIsEmptyResponse(clientMessage *proto.ClientMessage) bool

func DecodeListIteratorResponse 

func DecodeListIteratorResponse(clientMessage *proto.ClientMessage) []*iserialization.Data

func DecodeListLastIndexOfResponse 

func DecodeListLastIndexOfResponse(clientMessage *proto.ClientMessage) int32

func DecodeListListIteratorResponse 

func DecodeListListIteratorResponse(clientMessage *proto.ClientMessage) []*iserialization.Data

func DecodeListLong 

func DecodeListLong(frameIterator *proto.ForwardFrameIterator) []int64

func DecodeListMultiFrame 

func DecodeListMultiFrame(frameIterator *proto.ForwardFrameIterator, decoder func(frameIterator *proto.ForwardFrameIterator))

func DecodeListMultiFrameForData 

func DecodeListMultiFrameForData(frameIterator *proto.ForwardFrameIterator) []*iserialization.Data

func DecodeListMultiFrameForDataContainsNullable 

func DecodeListMultiFrameForDataContainsNullable(frameIterator *proto.ForwardFrameIterator) []*iserialization.Data

func DecodeListMultiFrameForMemberInfo 

func DecodeListMultiFrameForMemberInfo(frameIterator *proto.ForwardFrameIterator) []pubcluster.MemberInfo

func DecodeListMultiFrameForStackTraceElement 

func DecodeListMultiFrameForStackTraceElement(frameIterator *proto.ForwardFrameIterator) []hzerrors.StackTraceElement

func DecodeListMultiFrameForString 

func DecodeListMultiFrameForString(frameIterator *proto.ForwardFrameIterator) []string

func DecodeListMultiFrameWithListInteger 

func DecodeListMultiFrameWithListInteger(frameIterator *proto.ForwardFrameIterator) []int32

func DecodeListRemoveListenerResponse 

func DecodeListRemoveListenerResponse(clientMessage *proto.ClientMessage) bool

func DecodeListRemoveResponse 

func DecodeListRemoveResponse(clientMessage *proto.ClientMessage) bool

func DecodeListRemoveWithIndexResponse 

func DecodeListRemoveWithIndexResponse(clientMessage *proto.ClientMessage) *iserialization.Data

func DecodeListSetResponse 

func DecodeListSetResponse(clientMessage *proto.ClientMessage) *iserialization.Data

func DecodeListSizeResponse 

func DecodeListSizeResponse(clientMessage *proto.ClientMessage) int32

func DecodeListSubResponse 

func DecodeListSubResponse(clientMessage *proto.ClientMessage) []*iserialization.Data

func DecodeListUUID 

func DecodeListUUID(frameIterator *proto.ForwardFrameIterator) []types.UUID

func DecodeLongArray 

func DecodeLongArray(frameIterator *proto.ForwardFrameIterator) []int64

func DecodeMapAddEntryListenerResponse 

func DecodeMapAddEntryListenerResponse(clientMessage *proto.ClientMessage) types.UUID

func DecodeMapAddEntryListenerToKeyResponse 

func DecodeMapAddEntryListenerToKeyResponse(clientMessage *proto.ClientMessage) types.UUID

func DecodeMapAddEntryListenerToKeyWithPredicateResponse 

func DecodeMapAddEntryListenerToKeyWithPredicateResponse(clientMessage *proto.ClientMessage) types.UUID

func DecodeMapAddEntryListenerWithPredicateResponse 

func DecodeMapAddEntryListenerWithPredicateResponse(clientMessage *proto.ClientMessage) types.UUID

func DecodeMapAddInterceptorResponse 

func DecodeMapAddInterceptorResponse(clientMessage *proto.ClientMessage) string

func DecodeMapContainsKeyResponse 

func DecodeMapContainsKeyResponse(clientMessage *proto.ClientMessage) bool

func DecodeMapContainsValueResponse 

func DecodeMapContainsValueResponse(clientMessage *proto.ClientMessage) bool

func DecodeMapEntriesWithPredicateResponse 

func DecodeMapEntriesWithPredicateResponse(clientMessage *proto.ClientMessage) []proto.Pair

func DecodeMapEntrySetResponse 

func DecodeMapEntrySetResponse(clientMessage *proto.ClientMessage) []proto.Pair

func DecodeMapEvictResponse 

func DecodeMapEvictResponse(clientMessage *proto.ClientMessage) bool

func DecodeMapExecuteOnAllKeysResponse 

func DecodeMapExecuteOnAllKeysResponse(clientMessage *proto.ClientMessage) []proto.Pair

func DecodeMapExecuteOnKeyResponse 

func DecodeMapExecuteOnKeyResponse(clientMessage *proto.ClientMessage) *iserialization.Data

func DecodeMapExecuteOnKeysResponse 

func DecodeMapExecuteOnKeysResponse(clientMessage *proto.ClientMessage) []proto.Pair

func DecodeMapExecuteWithPredicateResponse 

func DecodeMapExecuteWithPredicateResponse(clientMessage *proto.ClientMessage) []proto.Pair

func DecodeMapFetchEntriesResponse 

func DecodeMapFetchEntriesResponse(clientMessage *proto.ClientMessage) (iterationPointers []proto.Pair, entries []proto.Pair)

func DecodeMapFetchKeysResponse 

func DecodeMapFetchKeysResponse(clientMessage *proto.ClientMessage) (iterationPointers []proto.Pair, keys []*iserialization.Data)

func DecodeMapFetchNearCacheInvalidationMetadataResponse 

func DecodeMapFetchNearCacheInvalidationMetadataResponse(clientMessage *proto.ClientMessage) (namePartitionSequenceList []proto.Pair, partitionUuidList []proto.Pair)

func DecodeMapForEndpointQualifierAndAddress 

func DecodeMapForEndpointQualifierAndAddress(iterator *proto.ForwardFrameIterator) interface{}

func DecodeMapForStringAndString 

func DecodeMapForStringAndString(iterator *proto.ForwardFrameIterator) map[string]string

func DecodeMapGetAllResponse 

func DecodeMapGetAllResponse(clientMessage *proto.ClientMessage) []proto.Pair

func DecodeMapGetEntryViewResponse 

func DecodeMapGetEntryViewResponse(clientMessage *proto.ClientMessage) (response *types.SimpleEntryView, maxIdle int64)

func DecodeMapGetResponse 

func DecodeMapGetResponse(clientMessage *proto.ClientMessage) *iserialization.Data

func DecodeMapIsEmptyResponse 

func DecodeMapIsEmptyResponse(clientMessage *proto.ClientMessage) bool

func DecodeMapIsLockedResponse 

func DecodeMapIsLockedResponse(clientMessage *proto.ClientMessage) bool

func DecodeMapKeySetResponse 

func DecodeMapKeySetResponse(clientMessage *proto.ClientMessage) []*iserialization.Data

func DecodeMapKeySetWithPredicateResponse 

func DecodeMapKeySetWithPredicateResponse(clientMessage *proto.ClientMessage) []*iserialization.Data

func DecodeMapPutIfAbsentResponse 

func DecodeMapPutIfAbsentResponse(clientMessage *proto.ClientMessage) *iserialization.Data

func DecodeMapPutIfAbsentWithMaxIdleResponse 

func DecodeMapPutIfAbsentWithMaxIdleResponse(clientMessage *proto.ClientMessage) *iserialization.Data

func DecodeMapPutResponse 

func DecodeMapPutResponse(clientMessage *proto.ClientMessage) *iserialization.Data

func DecodeMapPutTransientWithMaxIdleResponse 

func DecodeMapPutTransientWithMaxIdleResponse(clientMessage *proto.ClientMessage) *iserialization.Data

func DecodeMapPutWithMaxIdleResponse 

func DecodeMapPutWithMaxIdleResponse(clientMessage *proto.ClientMessage) *iserialization.Data

func DecodeMapRemoveEntryListenerResponse 

func DecodeMapRemoveEntryListenerResponse(clientMessage *proto.ClientMessage) bool

func DecodeMapRemoveIfSameResponse 

func DecodeMapRemoveIfSameResponse(clientMessage *proto.ClientMessage) bool

func DecodeMapRemoveInterceptorResponse 

func DecodeMapRemoveInterceptorResponse(clientMessage *proto.ClientMessage) bool

func DecodeMapRemoveResponse 

func DecodeMapRemoveResponse(clientMessage *proto.ClientMessage) *iserialization.Data

func DecodeMapReplaceIfSameResponse 

func DecodeMapReplaceIfSameResponse(clientMessage *proto.ClientMessage) bool

func DecodeMapReplaceResponse 

func DecodeMapReplaceResponse(clientMessage *proto.ClientMessage) *iserialization.Data

func DecodeMapSetTtlResponse 

func DecodeMapSetTtlResponse(clientMessage *proto.ClientMessage) bool

func DecodeMapSetWithMaxIdleResponse 

func DecodeMapSetWithMaxIdleResponse(clientMessage *proto.ClientMessage) *iserialization.Data

func DecodeMapSizeResponse 

func DecodeMapSizeResponse(clientMessage *proto.ClientMessage) int32

func DecodeMapSubmitToKeyResponse 

func DecodeMapSubmitToKeyResponse(clientMessage *proto.ClientMessage) *iserialization.Data

func DecodeMapTryLockResponse 

func DecodeMapTryLockResponse(clientMessage *proto.ClientMessage) bool

func DecodeMapTryPutResponse 

func DecodeMapTryPutResponse(clientMessage *proto.ClientMessage) bool

func DecodeMapTryRemoveResponse 

func DecodeMapTryRemoveResponse(clientMessage *proto.ClientMessage) bool

func DecodeMapValuesResponse 

func DecodeMapValuesResponse(clientMessage *proto.ClientMessage) []*iserialization.Data

func DecodeMapValuesWithPredicateResponse 

func DecodeMapValuesWithPredicateResponse(clientMessage *proto.ClientMessage) []*iserialization.Data

func DecodeMemberInfo 

func DecodeMemberInfo(frameIterator *proto.ForwardFrameIterator) cluster.MemberInfo

func DecodeMemberVersion 

func DecodeMemberVersion(frameIterator *proto.ForwardFrameIterator) cluster.MemberVersion

func DecodeNullableData 

func DecodeNullableData(frameIterator *proto.ForwardFrameIterator) *iserialization.Data

func DecodeNullableEntryList 

func DecodeNullableEntryList(frameIterator *proto.ForwardFrameIterator, keyDecoder, valueDecoder Decoder) []proto.Pair

func DecodeQueueAddAllResponse 

func DecodeQueueAddAllResponse(clientMessage *proto.ClientMessage) bool

func DecodeQueueAddListenerResponse 

func DecodeQueueAddListenerResponse(clientMessage *proto.ClientMessage) types.UUID

func DecodeQueueCompareAndRemoveAllResponse 

func DecodeQueueCompareAndRemoveAllResponse(clientMessage *proto.ClientMessage) bool

func DecodeQueueCompareAndRetainAllResponse 

func DecodeQueueCompareAndRetainAllResponse(clientMessage *proto.ClientMessage) bool

func DecodeQueueContainsAllResponse 

func DecodeQueueContainsAllResponse(clientMessage *proto.ClientMessage) bool

func DecodeQueueContainsResponse 

func DecodeQueueContainsResponse(clientMessage *proto.ClientMessage) bool

func DecodeQueueDrainToMaxSizeResponse 

func DecodeQueueDrainToMaxSizeResponse(clientMessage *proto.ClientMessage) []*iserialization.Data

func DecodeQueueDrainToResponse 

func DecodeQueueDrainToResponse(clientMessage *proto.ClientMessage) []*iserialization.Data

func DecodeQueueIsEmptyResponse 

func DecodeQueueIsEmptyResponse(clientMessage *proto.ClientMessage) bool

func DecodeQueueIteratorResponse 

func DecodeQueueIteratorResponse(clientMessage *proto.ClientMessage) []*iserialization.Data

func DecodeQueueOfferResponse 

func DecodeQueueOfferResponse(clientMessage *proto.ClientMessage) bool

func DecodeQueuePeekResponse 

func DecodeQueuePeekResponse(clientMessage *proto.ClientMessage) *iserialization.Data

func DecodeQueuePollResponse 

func DecodeQueuePollResponse(clientMessage *proto.ClientMessage) *iserialization.Data

func DecodeQueueRemainingCapacityResponse 

func DecodeQueueRemainingCapacityResponse(clientMessage *proto.ClientMessage) int32

func DecodeQueueRemoveListenerResponse 

func DecodeQueueRemoveListenerResponse(clientMessage *proto.ClientMessage) bool

func DecodeQueueRemoveResponse 

func DecodeQueueRemoveResponse(clientMessage *proto.ClientMessage) bool

func DecodeQueueSizeResponse 

func DecodeQueueSizeResponse(clientMessage *proto.ClientMessage) int32

func DecodeQueueTakeResponse 

func DecodeQueueTakeResponse(clientMessage *proto.ClientMessage) *iserialization.Data

func DecodeReplicatedMapAddEntryListenerResponse 

func DecodeReplicatedMapAddEntryListenerResponse(clientMessage *proto.ClientMessage) types.UUID

func DecodeReplicatedMapAddEntryListenerToKeyResponse 

func DecodeReplicatedMapAddEntryListenerToKeyResponse(clientMessage *proto.ClientMessage) types.UUID

func DecodeReplicatedMapAddEntryListenerToKeyWithPredicateResponse 

func DecodeReplicatedMapAddEntryListenerToKeyWithPredicateResponse(clientMessage *proto.ClientMessage) types.UUID

func DecodeReplicatedMapAddEntryListenerWithPredicateResponse 

func DecodeReplicatedMapAddEntryListenerWithPredicateResponse(clientMessage *proto.ClientMessage) types.UUID

func DecodeReplicatedMapAddNearCacheEntryListenerResponse 

func DecodeReplicatedMapAddNearCacheEntryListenerResponse(clientMessage *proto.ClientMessage) types.UUID

func DecodeReplicatedMapContainsKeyResponse 

func DecodeReplicatedMapContainsKeyResponse(clientMessage *proto.ClientMessage) bool

func DecodeReplicatedMapContainsValueResponse 

func DecodeReplicatedMapContainsValueResponse(clientMessage *proto.ClientMessage) bool

func DecodeReplicatedMapEntrySetResponse 

func DecodeReplicatedMapEntrySetResponse(clientMessage *proto.ClientMessage) []proto.Pair

func DecodeReplicatedMapGetResponse 

func DecodeReplicatedMapGetResponse(clientMessage *proto.ClientMessage) *iserialization.Data

func DecodeReplicatedMapIsEmptyResponse 

func DecodeReplicatedMapIsEmptyResponse(clientMessage *proto.ClientMessage) bool

func DecodeReplicatedMapKeySetResponse 

func DecodeReplicatedMapKeySetResponse(clientMessage *proto.ClientMessage) []*iserialization.Data

func DecodeReplicatedMapPutResponse 

func DecodeReplicatedMapPutResponse(clientMessage *proto.ClientMessage) *iserialization.Data

func DecodeReplicatedMapRemoveEntryListenerResponse 

func DecodeReplicatedMapRemoveEntryListenerResponse(clientMessage *proto.ClientMessage) bool

func DecodeReplicatedMapRemoveResponse 

func DecodeReplicatedMapRemoveResponse(clientMessage *proto.ClientMessage) *iserialization.Data

func DecodeReplicatedMapSizeResponse 

func DecodeReplicatedMapSizeResponse(clientMessage *proto.ClientMessage) int32

func DecodeReplicatedMapValuesResponse 

func DecodeReplicatedMapValuesResponse(clientMessage *proto.ClientMessage) []*iserialization.Data

func DecodeSetAddAllResponse 

func DecodeSetAddAllResponse(clientMessage *proto.ClientMessage) bool

func DecodeSetAddListenerResponse 

func DecodeSetAddListenerResponse(clientMessage *proto.ClientMessage) types.UUID

func DecodeSetAddResponse 

func DecodeSetAddResponse(clientMessage *proto.ClientMessage) bool

func DecodeSetCompareAndRemoveAllResponse 

func DecodeSetCompareAndRemoveAllResponse(clientMessage *proto.ClientMessage) bool

func DecodeSetCompareAndRetainAllResponse 

func DecodeSetCompareAndRetainAllResponse(clientMessage *proto.ClientMessage) bool

func DecodeSetContainsAllResponse 

func DecodeSetContainsAllResponse(clientMessage *proto.ClientMessage) bool

func DecodeSetContainsResponse 

func DecodeSetContainsResponse(clientMessage *proto.ClientMessage) bool

func DecodeSetGetAllResponse 

func DecodeSetGetAllResponse(clientMessage *proto.ClientMessage) []*serialization.Data

func DecodeSetIsEmptyResponse 

func DecodeSetIsEmptyResponse(clientMessage *proto.ClientMessage) bool

func DecodeSetRemoveListenerResponse 

func DecodeSetRemoveListenerResponse(clientMessage *proto.ClientMessage) bool

func DecodeSetRemoveResponse 

func DecodeSetRemoveResponse(clientMessage *proto.ClientMessage) bool

func DecodeSetSizeResponse 

func DecodeSetSizeResponse(clientMessage *proto.ClientMessage) int32

func DecodeSimpleEntryView 

func DecodeSimpleEntryView(frameIterator *proto.ForwardFrameIterator) *types.SimpleEntryView

func DecodeStackTraceElement 

func DecodeStackTraceElement(frameIterator *proto.ForwardFrameIterator) hzerrors.StackTraceElement

func DecodeString 

func DecodeString(frameIterator *proto.ForwardFrameIterator) string

func DecodeTopicAddMessageListenerResponse 

func DecodeTopicAddMessageListenerResponse(clientMessage *proto.ClientMessage) types.UUID

func DecodeTopicRemoveMessageListenerResponse 

func DecodeTopicRemoveMessageListenerResponse(clientMessage *proto.ClientMessage) bool

func EncodeAddress 

func EncodeAddress(clientMessage *proto.ClientMessage, address cluster.Address)

func EncodeBitmapIndexOptions 

func EncodeBitmapIndexOptions(clientMessage *proto.ClientMessage, bitmapIndexOptions types.BitmapIndexOptions)

func EncodeByteArray 

func EncodeByteArray(message *proto.ClientMessage, value []byte)

func EncodeClientAddClusterViewListenerRequest 

func EncodeClientAddClusterViewListenerRequest() *proto.ClientMessage

func EncodeClientAuthenticationRequest 

func EncodeClientAuthenticationRequest(clusterName string, username string, password string, uuid types.UUID, clientType string, serializationVersion byte, clientHazelcastVersion string, clientName string, labels []string) *proto.ClientMessage

func EncodeClientCreateProxyRequest 

func EncodeClientCreateProxyRequest(name string, serviceName string) *proto.ClientMessage

func EncodeClientDestroyProxyRequest 

func EncodeClientDestroyProxyRequest(name string, serviceName string) *proto.ClientMessage

func EncodeClientPingRequest 

func EncodeClientPingRequest() *proto.ClientMessage

func EncodeData 

func EncodeData(message *proto.ClientMessage, value interface{})

func EncodeEndpointQualifier 

func EncodeEndpointQualifier(clientMessage *proto.ClientMessage, endpointQualifier pubcluster.EndpointQualifier)

func EncodeEntryList 

func EncodeEntryList(message *proto.ClientMessage, entries []proto.Pair, keyEncoder, valueEncoder Encoder)

func EncodeEntryListForDataAndData 

func EncodeEntryListForDataAndData(message *proto.ClientMessage, entries []proto.Pair)

func EncodeEntryListForDataAndListData 

func EncodeEntryListForDataAndListData(message *proto.ClientMessage, entries []proto.Pair)

func EncodeEntryListForStringAndByteArray 

func EncodeEntryListForStringAndByteArray(message *proto.ClientMessage, entries []proto.Pair)

func EncodeEntryListForStringAndString 

func EncodeEntryListForStringAndString(message *proto.ClientMessage, entries []proto.Pair)

func EncodeEntryListIntegerInteger 

func EncodeEntryListIntegerInteger(message *proto.ClientMessage, entries []proto.Pair)

func EncodeEntryListUUIDListInteger 

func EncodeEntryListUUIDListInteger(message *proto.ClientMessage, entries []proto.Pair)

func EncodeEntryListUUIDLong 

func EncodeEntryListUUIDLong(message *proto.ClientMessage, entries []proto.Pair)

func EncodeErrorHolder 

func EncodeErrorHolder(clientMessage *proto.ClientMessage, errorHolder proto.ErrorHolder)

func EncodeIndexConfig 

func EncodeIndexConfig(clientMessage *proto.ClientMessage, indexConfig types.IndexConfig)

func EncodeListAddAllRequest 

func EncodeListAddAllRequest(name string, valueList []*iserialization.Data) *proto.ClientMessage

func EncodeListAddAllWithIndexRequest 

func EncodeListAddAllWithIndexRequest(name string, index int32, valueList []*iserialization.Data) *proto.ClientMessage

func EncodeListAddListenerRequest 

func EncodeListAddListenerRequest(name string, includeValue bool, localOnly bool) *proto.ClientMessage

func EncodeListAddRequest 

func EncodeListAddRequest(name string, value *iserialization.Data) *proto.ClientMessage

func EncodeListAddWithIndexRequest 

func EncodeListAddWithIndexRequest(name string, index int32, value *iserialization.Data) *proto.ClientMessage

func EncodeListClearRequest 

func EncodeListClearRequest(name string) *proto.ClientMessage

func EncodeListCompareAndRemoveAllRequest 

func EncodeListCompareAndRemoveAllRequest(name string, values []*iserialization.Data) *proto.ClientMessage

func EncodeListCompareAndRetainAllRequest 

func EncodeListCompareAndRetainAllRequest(name string, values []*iserialization.Data) *proto.ClientMessage

func EncodeListContainsAllRequest 

func EncodeListContainsAllRequest(name string, values []*iserialization.Data) *proto.ClientMessage

func EncodeListContainsRequest 

func EncodeListContainsRequest(name string, value *iserialization.Data) *proto.ClientMessage

func EncodeListData 

func EncodeListData(message *proto.ClientMessage, entries []*iserialization.Data)

func EncodeListGetAllRequest 

func EncodeListGetAllRequest(name string) *proto.ClientMessage

func EncodeListGetRequest 

func EncodeListGetRequest(name string, index int32) *proto.ClientMessage

func EncodeListIndexOfRequest 

func EncodeListIndexOfRequest(name string, value *iserialization.Data) *proto.ClientMessage

func EncodeListInteger 

func EncodeListInteger(message *proto.ClientMessage, entries []int32)

func EncodeListIntegerIntegerInteger 

func EncodeListIntegerIntegerInteger(message *proto.ClientMessage, entries []proto.Pair)

func EncodeListIsEmptyRequest 

func EncodeListIsEmptyRequest(name string) *proto.ClientMessage

func EncodeListIteratorRequest 

func EncodeListIteratorRequest(name string) *proto.ClientMessage

func EncodeListLastIndexOfRequest 

func EncodeListLastIndexOfRequest(name string, value *iserialization.Data) *proto.ClientMessage

func EncodeListListIteratorRequest 

func EncodeListListIteratorRequest(name string, index int32) *proto.ClientMessage

func EncodeListLong 

func EncodeListLong(message *proto.ClientMessage, entries []int64)

func EncodeListMultiFrame 

func EncodeListMultiFrame(message *proto.ClientMessage, values []*iserialization.Data, encoder Encoder)

func EncodeListMultiFrameContainsNullable 

func EncodeListMultiFrameContainsNullable(message *proto.ClientMessage, values []*iserialization.Data, encoder Encoder)

func EncodeListMultiFrameForData 

func EncodeListMultiFrameForData(message *proto.ClientMessage, values []*iserialization.Data)

func EncodeListMultiFrameForStackTraceElement 

func EncodeListMultiFrameForStackTraceElement(message *proto.ClientMessage, values []hzerrors.StackTraceElement)

func EncodeListMultiFrameForString 

func EncodeListMultiFrameForString(message *proto.ClientMessage, values []string)

func EncodeListMultiFrameNullable 

func EncodeListMultiFrameNullable(message *proto.ClientMessage, values []*iserialization.Data, encoder Encoder)

func EncodeListRemoveListenerRequest 

func EncodeListRemoveListenerRequest(name string, registrationId types.UUID) *proto.ClientMessage

func EncodeListRemoveRequest 

func EncodeListRemoveRequest(name string, value *iserialization.Data) *proto.ClientMessage

func EncodeListRemoveWithIndexRequest 

func EncodeListRemoveWithIndexRequest(name string, index int32) *proto.ClientMessage

func EncodeListSetRequest 

func EncodeListSetRequest(name string, index int32, value *iserialization.Data) *proto.ClientMessage

func EncodeListSizeRequest 

func EncodeListSizeRequest(name string) *proto.ClientMessage

func EncodeListSubRequest 

func EncodeListSubRequest(name string, from int32, to int32) *proto.ClientMessage

func EncodeListUUID 

func EncodeListUUID(message *proto.ClientMessage, entries []types.UUID)

func EncodeLongArray 

func EncodeLongArray(message *proto.ClientMessage, entries []int64)

func EncodeMapAddEntryListenerRequest 

func EncodeMapAddEntryListenerRequest(name string, includeValue bool, listenerFlags int32, localOnly bool) *proto.ClientMessage

func EncodeMapAddEntryListenerToKeyRequest 

func EncodeMapAddEntryListenerToKeyRequest(name string, key *iserialization.Data, includeValue bool, listenerFlags int32, localOnly bool) *proto.ClientMessage

func EncodeMapAddEntryListenerToKeyWithPredicateRequest 

func EncodeMapAddEntryListenerToKeyWithPredicateRequest(name string, key *iserialization.Data, predicate *iserialization.Data, includeValue bool, listenerFlags int32, localOnly bool) *proto.ClientMessage

func EncodeMapAddEntryListenerWithPredicateRequest 

func EncodeMapAddEntryListenerWithPredicateRequest(name string, predicate *iserialization.Data, includeValue bool, listenerFlags int32, localOnly bool) *proto.ClientMessage

func EncodeMapAddIndexRequest 

func EncodeMapAddIndexRequest(name string, indexConfig types.IndexConfig) *proto.ClientMessage

func EncodeMapAddInterceptorRequest 

func EncodeMapAddInterceptorRequest(name string, interceptor *iserialization.Data) *proto.ClientMessage

func EncodeMapClearRequest 

func EncodeMapClearRequest(name string) *proto.ClientMessage

func EncodeMapContainsKeyRequest 

func EncodeMapContainsKeyRequest(name string, key *iserialization.Data, threadId int64) *proto.ClientMessage

func EncodeMapContainsValueRequest 

func EncodeMapContainsValueRequest(name string, value *iserialization.Data) *proto.ClientMessage

func EncodeMapDeleteRequest 

func EncodeMapDeleteRequest(name string, key *iserialization.Data, threadId int64) *proto.ClientMessage

func EncodeMapEntriesWithPredicateRequest 

func EncodeMapEntriesWithPredicateRequest(name string, predicate *iserialization.Data) *proto.ClientMessage

func EncodeMapEntrySetRequest 

func EncodeMapEntrySetRequest(name string) *proto.ClientMessage

func EncodeMapEvictAllRequest 

func EncodeMapEvictAllRequest(name string) *proto.ClientMessage

func EncodeMapEvictRequest 

func EncodeMapEvictRequest(name string, key *iserialization.Data, threadId int64) *proto.ClientMessage

func EncodeMapExecuteOnAllKeysRequest 

func EncodeMapExecuteOnAllKeysRequest(name string, entryProcessor *iserialization.Data) *proto.ClientMessage

func EncodeMapExecuteOnKeyRequest 

func EncodeMapExecuteOnKeyRequest(name string, entryProcessor *iserialization.Data, key *iserialization.Data, threadId int64) *proto.ClientMessage

func EncodeMapExecuteOnKeysRequest 

func EncodeMapExecuteOnKeysRequest(name string, entryProcessor *iserialization.Data, keys []*iserialization.Data) *proto.ClientMessage

func EncodeMapExecuteWithPredicateRequest 

func EncodeMapExecuteWithPredicateRequest(name string, entryProcessor *iserialization.Data, predicate *iserialization.Data) *proto.ClientMessage

func EncodeMapFetchEntriesRequest 

func EncodeMapFetchEntriesRequest(name string, iterationPointers []proto.Pair, batch int32) *proto.ClientMessage

func EncodeMapFetchKeysRequest 

func EncodeMapFetchKeysRequest(name string, iterationPointers []proto.Pair, batch int32) *proto.ClientMessage

func EncodeMapFetchNearCacheInvalidationMetadataRequest 

func EncodeMapFetchNearCacheInvalidationMetadataRequest(names []string, uuid types.UUID) *proto.ClientMessage

func EncodeMapFlushRequest 

func EncodeMapFlushRequest(name string) *proto.ClientMessage

func EncodeMapForEndpointQualifierAndAddress 

func EncodeMapForEndpointQualifierAndAddress(message *proto.ClientMessage, values map[pubcluster.EndpointQualifier]pubcluster.Address)

func EncodeMapForStringAndString 

func EncodeMapForStringAndString(message *proto.ClientMessage, values map[string]string)

func EncodeMapForceUnlockRequest 

func EncodeMapForceUnlockRequest(name string, key *iserialization.Data, referenceId int64) *proto.ClientMessage

func EncodeMapGetAllRequest 

func EncodeMapGetAllRequest(name string, keys []*iserialization.Data) *proto.ClientMessage

func EncodeMapGetEntryViewRequest 

func EncodeMapGetEntryViewRequest(name string, key *iserialization.Data, threadId int64) *proto.ClientMessage

func EncodeMapGetRequest 

func EncodeMapGetRequest(name string, key *iserialization.Data, threadId int64) *proto.ClientMessage

func EncodeMapIsEmptyRequest 

func EncodeMapIsEmptyRequest(name string) *proto.ClientMessage

func EncodeMapIsLockedRequest 

func EncodeMapIsLockedRequest(name string, key *iserialization.Data) *proto.ClientMessage

func EncodeMapKeySetRequest 

func EncodeMapKeySetRequest(name string) *proto.ClientMessage

func EncodeMapKeySetWithPredicateRequest 

func EncodeMapKeySetWithPredicateRequest(name string, predicate *iserialization.Data) *proto.ClientMessage

func EncodeMapLoadAllRequest 

func EncodeMapLoadAllRequest(name string, replaceExistingValues bool) *proto.ClientMessage

func EncodeMapLoadGivenKeysRequest 

func EncodeMapLoadGivenKeysRequest(name string, keys []*iserialization.Data, replaceExistingValues bool) *proto.ClientMessage

func EncodeMapLockRequest 

func EncodeMapLockRequest(name string, key *iserialization.Data, threadId int64, ttl int64, referenceId int64) *proto.ClientMessage

func EncodeMapPutAllRequest 

func EncodeMapPutAllRequest(name string, entries []proto.Pair, triggerMapLoader bool) *proto.ClientMessage

func EncodeMapPutIfAbsentRequest 

func EncodeMapPutIfAbsentRequest(name string, key *iserialization.Data, value *iserialization.Data, threadId int64, ttl int64) *proto.ClientMessage

func EncodeMapPutIfAbsentWithMaxIdleRequest 

func EncodeMapPutIfAbsentWithMaxIdleRequest(name string, key *iserialization.Data, value *iserialization.Data, threadId int64, ttl int64, maxIdle int64) *proto.ClientMessage

func EncodeMapPutRequest 

func EncodeMapPutRequest(name string, key *iserialization.Data, value *iserialization.Data, threadId int64, ttl int64) *proto.ClientMessage

func EncodeMapPutTransientRequest 

func EncodeMapPutTransientRequest(name string, key *iserialization.Data, value *iserialization.Data, threadId int64, ttl int64) *proto.ClientMessage

func EncodeMapPutTransientWithMaxIdleRequest 

func EncodeMapPutTransientWithMaxIdleRequest(name string, key *iserialization.Data, value *iserialization.Data, threadId int64, ttl int64, maxIdle int64) *proto.ClientMessage

func EncodeMapPutWithMaxIdleRequest 

func EncodeMapPutWithMaxIdleRequest(name string, key *iserialization.Data, value *iserialization.Data, threadId int64, ttl int64, maxIdle int64) *proto.ClientMessage

func EncodeMapRemoveAllRequest 

func EncodeMapRemoveAllRequest(name string, predicate *iserialization.Data) *proto.ClientMessage

func EncodeMapRemoveEntryListenerRequest 

func EncodeMapRemoveEntryListenerRequest(name string, registrationId types.UUID) *proto.ClientMessage

func EncodeMapRemoveIfSameRequest 

func EncodeMapRemoveIfSameRequest(name string, key *iserialization.Data, value *iserialization.Data, threadId int64) *proto.ClientMessage

func EncodeMapRemoveInterceptorRequest 

func EncodeMapRemoveInterceptorRequest(name string, id string) *proto.ClientMessage

func EncodeMapRemoveRequest 

func EncodeMapRemoveRequest(name string, key *iserialization.Data, threadId int64) *proto.ClientMessage

func EncodeMapReplaceIfSameRequest 

func EncodeMapReplaceIfSameRequest(name string, key *iserialization.Data, testValue *iserialization.Data, value *iserialization.Data, threadId int64) *proto.ClientMessage

func EncodeMapReplaceRequest 

func EncodeMapReplaceRequest(name string, key *iserialization.Data, value *iserialization.Data, threadId int64) *proto.ClientMessage

func EncodeMapSetRequest 

func EncodeMapSetRequest(name string, key *iserialization.Data, value *iserialization.Data, threadId int64, ttl int64) *proto.ClientMessage

func EncodeMapSetTtlRequest 

func EncodeMapSetTtlRequest(name string, key *iserialization.Data, ttl int64) *proto.ClientMessage

func EncodeMapSetWithMaxIdleRequest 

func EncodeMapSetWithMaxIdleRequest(name string, key *iserialization.Data, value *iserialization.Data, threadId int64, ttl int64, maxIdle int64) *proto.ClientMessage

func EncodeMapSizeRequest 

func EncodeMapSizeRequest(name string) *proto.ClientMessage

func EncodeMapSubmitToKeyRequest 

func EncodeMapSubmitToKeyRequest(name string, entryProcessor *iserialization.Data, key *iserialization.Data, threadId int64) *proto.ClientMessage

func EncodeMapTryLockRequest 

func EncodeMapTryLockRequest(name string, key *iserialization.Data, threadId int64, lease int64, timeout int64, referenceId int64) *proto.ClientMessage

func EncodeMapTryPutRequest 

func EncodeMapTryPutRequest(name string, key *iserialization.Data, value *iserialization.Data, threadId int64, timeout int64) *proto.ClientMessage

func EncodeMapTryRemoveRequest 

func EncodeMapTryRemoveRequest(name string, key *iserialization.Data, threadId int64, timeout int64) *proto.ClientMessage

func EncodeMapUnlockRequest 

func EncodeMapUnlockRequest(name string, key *iserialization.Data, threadId int64, referenceId int64) *proto.ClientMessage

func EncodeMapValuesRequest 

func EncodeMapValuesRequest(name string) *proto.ClientMessage

func EncodeMapValuesWithPredicateRequest 

func EncodeMapValuesWithPredicateRequest(name string, predicate *iserialization.Data) *proto.ClientMessage

func EncodeMemberInfo 

func EncodeMemberInfo(clientMessage *proto.ClientMessage, memberInfo cluster.MemberInfo)

func EncodeMemberVersion 

func EncodeMemberVersion(clientMessage *proto.ClientMessage, memberVersion cluster.MemberVersion)

func EncodeNullableData 

func EncodeNullableData(message *proto.ClientMessage, data *iserialization.Data)

func EncodeNullableEntryList 

func EncodeNullableEntryList(message *proto.ClientMessage, entries []proto.Pair, keyEncoder, valueEncoder Encoder)

func EncodeQueueAddAllRequest 

func EncodeQueueAddAllRequest(name string, dataList []*iserialization.Data) *proto.ClientMessage

func EncodeQueueAddListenerRequest 

func EncodeQueueAddListenerRequest(name string, includeValue bool, localOnly bool) *proto.ClientMessage

func EncodeQueueClearRequest 

func EncodeQueueClearRequest(name string) *proto.ClientMessage

func EncodeQueueCompareAndRemoveAllRequest 

func EncodeQueueCompareAndRemoveAllRequest(name string, dataList []*iserialization.Data) *proto.ClientMessage

func EncodeQueueCompareAndRetainAllRequest 

func EncodeQueueCompareAndRetainAllRequest(name string, dataList []*iserialization.Data) *proto.ClientMessage

func EncodeQueueContainsAllRequest 

func EncodeQueueContainsAllRequest(name string, dataList []*iserialization.Data) *proto.ClientMessage

func EncodeQueueContainsRequest 

func EncodeQueueContainsRequest(name string, value *iserialization.Data) *proto.ClientMessage

func EncodeQueueDrainToMaxSizeRequest 

func EncodeQueueDrainToMaxSizeRequest(name string, maxSize int32) *proto.ClientMessage

func EncodeQueueDrainToRequest 

func EncodeQueueDrainToRequest(name string) *proto.ClientMessage

func EncodeQueueIsEmptyRequest 

func EncodeQueueIsEmptyRequest(name string) *proto.ClientMessage

func EncodeQueueIteratorRequest 

func EncodeQueueIteratorRequest(name string) *proto.ClientMessage

func EncodeQueueOfferRequest 

func EncodeQueueOfferRequest(name string, value *iserialization.Data, timeoutMillis int64) *proto.ClientMessage

func EncodeQueuePeekRequest 

func EncodeQueuePeekRequest(name string) *proto.ClientMessage

func EncodeQueuePollRequest 

func EncodeQueuePollRequest(name string, timeoutMillis int64) *proto.ClientMessage

func EncodeQueuePutRequest 

func EncodeQueuePutRequest(name string, value *iserialization.Data) *proto.ClientMessage

func EncodeQueueRemainingCapacityRequest 

func EncodeQueueRemainingCapacityRequest(name string) *proto.ClientMessage

func EncodeQueueRemoveListenerRequest 

func EncodeQueueRemoveListenerRequest(name string, registrationId types.UUID) *proto.ClientMessage

func EncodeQueueRemoveRequest 

func EncodeQueueRemoveRequest(name string, value *iserialization.Data) *proto.ClientMessage

func EncodeQueueSizeRequest 

func EncodeQueueSizeRequest(name string) *proto.ClientMessage

func EncodeQueueTakeRequest 

func EncodeQueueTakeRequest(name string) *proto.ClientMessage

func EncodeReplicatedMapAddEntryListenerRequest 

func EncodeReplicatedMapAddEntryListenerRequest(name string, localOnly bool) *proto.ClientMessage

func EncodeReplicatedMapAddEntryListenerToKeyRequest 

func EncodeReplicatedMapAddEntryListenerToKeyRequest(name string, key *iserialization.Data, localOnly bool) *proto.ClientMessage

func EncodeReplicatedMapAddEntryListenerToKeyWithPredicateRequest 

func EncodeReplicatedMapAddEntryListenerToKeyWithPredicateRequest(name string, key *iserialization.Data, predicate *iserialization.Data, localOnly bool) *proto.ClientMessage

func EncodeReplicatedMapAddEntryListenerWithPredicateRequest 

func EncodeReplicatedMapAddEntryListenerWithPredicateRequest(name string, predicate *iserialization.Data, localOnly bool) *proto.ClientMessage

func EncodeReplicatedMapAddNearCacheEntryListenerRequest 

func EncodeReplicatedMapAddNearCacheEntryListenerRequest(name string, includeValue bool, localOnly bool) *proto.ClientMessage

func EncodeReplicatedMapClearRequest 

func EncodeReplicatedMapClearRequest(name string) *proto.ClientMessage

func EncodeReplicatedMapContainsKeyRequest 

func EncodeReplicatedMapContainsKeyRequest(name string, key *iserialization.Data) *proto.ClientMessage

func EncodeReplicatedMapContainsValueRequest 

func EncodeReplicatedMapContainsValueRequest(name string, value *iserialization.Data) *proto.ClientMessage

func EncodeReplicatedMapEntrySetRequest 

func EncodeReplicatedMapEntrySetRequest(name string) *proto.ClientMessage

func EncodeReplicatedMapGetRequest 

func EncodeReplicatedMapGetRequest(name string, key *iserialization.Data) *proto.ClientMessage

func EncodeReplicatedMapIsEmptyRequest 

func EncodeReplicatedMapIsEmptyRequest(name string) *proto.ClientMessage

func EncodeReplicatedMapKeySetRequest 

func EncodeReplicatedMapKeySetRequest(name string) *proto.ClientMessage

func EncodeReplicatedMapPutAllRequest 

func EncodeReplicatedMapPutAllRequest(name string, entries []proto.Pair) *proto.ClientMessage

func EncodeReplicatedMapPutRequest 

func EncodeReplicatedMapPutRequest(name string, key *iserialization.Data, value *iserialization.Data, ttl int64) *proto.ClientMessage

func EncodeReplicatedMapRemoveEntryListenerRequest 

func EncodeReplicatedMapRemoveEntryListenerRequest(name string, registrationId types.UUID) *proto.ClientMessage

func EncodeReplicatedMapRemoveRequest 

func EncodeReplicatedMapRemoveRequest(name string, key *iserialization.Data) *proto.ClientMessage

func EncodeReplicatedMapSizeRequest 

func EncodeReplicatedMapSizeRequest(name string) *proto.ClientMessage

func EncodeReplicatedMapValuesRequest 

func EncodeReplicatedMapValuesRequest(name string) *proto.ClientMessage

func EncodeSetAddAllRequest 

func EncodeSetAddAllRequest(name string, valueList []*serialization.Data) *proto.ClientMessage

func EncodeSetAddListenerRequest 

func EncodeSetAddListenerRequest(name string, includeValue bool, localOnly bool) *proto.ClientMessage

func EncodeSetAddRequest 

func EncodeSetAddRequest(name string, value *serialization.Data) *proto.ClientMessage

func EncodeSetClearRequest 

func EncodeSetClearRequest(name string) *proto.ClientMessage

func EncodeSetCompareAndRemoveAllRequest 

func EncodeSetCompareAndRemoveAllRequest(name string, values []*serialization.Data) *proto.ClientMessage

func EncodeSetCompareAndRetainAllRequest 

func EncodeSetCompareAndRetainAllRequest(name string, values []*serialization.Data) *proto.ClientMessage

func EncodeSetContainsAllRequest 

func EncodeSetContainsAllRequest(name string, items []*serialization.Data) *proto.ClientMessage

func EncodeSetContainsRequest 

func EncodeSetContainsRequest(name string, value *serialization.Data) *proto.ClientMessage

func EncodeSetGetAllRequest 

func EncodeSetGetAllRequest(name string) *proto.ClientMessage

func EncodeSetIsEmptyRequest 

func EncodeSetIsEmptyRequest(name string) *proto.ClientMessage

func EncodeSetRemoveListenerRequest 

func EncodeSetRemoveListenerRequest(name string, registrationId types.UUID) *proto.ClientMessage

func EncodeSetRemoveRequest 

func EncodeSetRemoveRequest(name string, value *serialization.Data) *proto.ClientMessage

func EncodeSetSizeRequest 

func EncodeSetSizeRequest(name string) *proto.ClientMessage

func EncodeSimpleEntryView 

func EncodeSimpleEntryView(clientMessage *proto.ClientMessage, simpleEntryView *types.SimpleEntryView)

func EncodeStackTraceElement 

func EncodeStackTraceElement(clientMessage *proto.ClientMessage, stackTraceElement hzerrors.StackTraceElement)

func EncodeString 

func EncodeString(message *proto.ClientMessage, value interface{})

func EncodeTopicAddMessageListenerRequest 

func EncodeTopicAddMessageListenerRequest(name string, localOnly bool) *proto.ClientMessage

func EncodeTopicPublishAllRequest 

func EncodeTopicPublishAllRequest(name string, messages []*iserialization.Data) *proto.ClientMessage

func EncodeTopicPublishRequest 

func EncodeTopicPublishRequest(name string, message *iserialization.Data) *proto.ClientMessage

func EncodeTopicRemoveMessageListenerRequest 

func EncodeTopicRemoveMessageListenerRequest(name string, registrationId types.UUID) *proto.ClientMessage

func HandleClientAddClusterViewListener 

func HandleClientAddClusterViewListener(clientMessage *proto.ClientMessage, handleMembersViewEvent func(version int32, memberInfos []cluster.MemberInfo), handlePartitionsViewEvent func(version int32, partitions []proto.Pair))

func HandleListAddListener 

func HandleListAddListener(clientMessage *proto.ClientMessage, handleItemEvent func(item *iserialization.Data, uuid types.UUID, eventType int32))

func HandleMapAddEntryListener 

func HandleMapAddEntryListener(clientMessage *proto.ClientMessage, handleEntryEvent func(key *iserialization.Data, value *iserialization.Data, oldValue *iserialization.Data, mergingValue *iserialization.Data, eventType int32, uuid types.UUID, numberOfAffectedEntries int32))

func HandleMapAddEntryListenerToKey 

func HandleMapAddEntryListenerToKey(clientMessage *proto.ClientMessage, handleEntryEvent func(key *iserialization.Data, value *iserialization.Data, oldValue *iserialization.Data, mergingValue *iserialization.Data, eventType int32, uuid types.UUID, numberOfAffectedEntries int32))

func HandleMapAddEntryListenerToKeyWithPredicate 

func HandleMapAddEntryListenerToKeyWithPredicate(clientMessage *proto.ClientMessage, handleEntryEvent func(key *iserialization.Data, value *iserialization.Data, oldValue *iserialization.Data, mergingValue *iserialization.Data, eventType int32, uuid types.UUID, numberOfAffectedEntries int32))

func HandleMapAddEntryListenerWithPredicate 

func HandleMapAddEntryListenerWithPredicate(clientMessage *proto.ClientMessage, handleEntryEvent func(key *iserialization.Data, value *iserialization.Data, oldValue *iserialization.Data, mergingValue *iserialization.Data, eventType int32, uuid types.UUID, numberOfAffectedEntries int32))

func HandleQueueAddListener 

func HandleQueueAddListener(clientMessage *proto.ClientMessage, handleItemEvent func(item *iserialization.Data, uuid types.UUID, eventType int32))

func HandleReplicatedMapAddEntryListener 

func HandleReplicatedMapAddEntryListener(clientMessage *proto.ClientMessage, handleEntryEvent func(key *iserialization.Data, value *iserialization.Data, oldValue *iserialization.Data, mergingValue *iserialization.Data, eventType int32, uuid types.UUID, numberOfAffectedEntries int32))

func HandleReplicatedMapAddEntryListenerToKey 

func HandleReplicatedMapAddEntryListenerToKey(clientMessage *proto.ClientMessage, handleEntryEvent func(key *iserialization.Data, value *iserialization.Data, oldValue *iserialization.Data, mergingValue *iserialization.Data, eventType int32, uuid types.UUID, numberOfAffectedEntries int32))

func HandleReplicatedMapAddEntryListenerToKeyWithPredicate 

func HandleReplicatedMapAddEntryListenerToKeyWithPredicate(clientMessage *proto.ClientMessage, handleEntryEvent func(key *iserialization.Data, value *iserialization.Data, oldValue *iserialization.Data, mergingValue *iserialization.Data, eventType int32, uuid types.UUID, numberOfAffectedEntries int32))

func HandleReplicatedMapAddEntryListenerWithPredicate 

func HandleReplicatedMapAddEntryListenerWithPredicate(clientMessage *proto.ClientMessage, handleEntryEvent func(key *iserialization.Data, value *iserialization.Data, oldValue *iserialization.Data, mergingValue *iserialization.Data, eventType int32, uuid types.UUID, numberOfAffectedEntries int32))

func HandleReplicatedMapAddNearCacheEntryListener 

func HandleReplicatedMapAddNearCacheEntryListener(clientMessage *proto.ClientMessage, handleEntryEvent func(key *iserialization.Data, value *iserialization.Data, oldValue *iserialization.Data, mergingValue *iserialization.Data, eventType int32, uuid types.UUID, numberOfAffectedEntries int32))

func HandleSetAddListener 

func HandleSetAddListener(clientMessage *proto.ClientMessage, handleItemEvent func(item *serialization.Data, uuid types.UUID, eventType int32))

func HandleTopicAddMessageListener 

func HandleTopicAddMessageListener(clientMessage *proto.ClientMessage, handleTopicEvent func(item *iserialization.Data, publishTime int64, uuid types.UUID))

func NewEndpointQualifier 

func NewEndpointQualifier(qualifierType int32, identifier string) pubcluster.EndpointQualifier

Types

type Decoder 

type Decoder func(frameIterator *proto.ForwardFrameIterator) *iserialization.Data

Decoder create *iserialization.Data

type DistributedObject 

type DistributedObject interface {
	// Destroy destroys this object cluster-wide.
	// Destroy clears and releases all resources for this object.
	Destroy() (bool, error)

	// Name returns the unique name for this DistributedObject.
	Name() string

	// PartitionKey returns the key of partition this DistributedObject is assigned to. The returned value only has meaning
	// for a non partitioned data structure like an IAtomicLong. For a partitioned data structure like an Map
	// the returned value will not be nil, but otherwise undefined.
	PartitionKey() string

	// ServiceName returns the service name for this object.
	ServiceName() string
}

DistributedObject is the base interface for all distributed objects.

type DistributedObjectInfo 

type DistributedObjectInfo struct {
	// contains filtered or unexported fields
}

func NewDistributedObjectInfo 

func NewDistributedObjectInfo(name string, serviceName string) DistributedObjectInfo

func (*DistributedObjectInfo) GetName 

func (i *DistributedObjectInfo) GetName() string

func (*DistributedObjectInfo) GetServiceName 

func (i *DistributedObjectInfo) GetServiceName() string

func (*DistributedObjectInfo) Name 

func (i *DistributedObjectInfo) Name() string

func (*DistributedObjectInfo) ServiceName 

func (i *DistributedObjectInfo) ServiceName() string

type Encoder 

type Encoder func(message *proto.ClientMessage, value interface{})

Encoder for ClientMessage and value

Source Files

View all Source files

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.