@celerispay/hazelcast-client 3.12.5

package/lib/codec/MapGetEntryViewCodec.js

@@ -0,0 +1,61 @@
+"use strict";
+/*
+ * 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.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+/* tslint:disable */
+var ClientMessage = require("../ClientMessage");
+var BitsUtil_1 = require("../BitsUtil");
+var EntryViewCodec_1 = require("./EntryViewCodec");
+var MapMessageType_1 = require("./MapMessageType");
+var REQUEST_TYPE = MapMessageType_1.MapMessageType.MAP_GETENTRYVIEW;
+var RESPONSE_TYPE = 111;
+var RETRYABLE = true;
+var MapGetEntryViewCodec = /** @class */ (function () {
+    function MapGetEntryViewCodec() {
+    }
+    MapGetEntryViewCodec.calculateSize = function (name, key, threadId) {
+        // Calculates the request payload size
+        var dataSize = 0;
+        dataSize += BitsUtil_1.BitsUtil.calculateSizeString(name);
+        dataSize += BitsUtil_1.BitsUtil.calculateSizeData(key);
+        dataSize += BitsUtil_1.BitsUtil.LONG_SIZE_IN_BYTES;
+        return dataSize;
+    };
+    MapGetEntryViewCodec.encodeRequest = function (name, key, threadId) {
+        // Encode request into clientMessage
+        var clientMessage = ClientMessage.newClientMessage(this.calculateSize(name, key, threadId));
+        clientMessage.setMessageType(REQUEST_TYPE);
+        clientMessage.setRetryable(RETRYABLE);
+        clientMessage.appendString(name);
+        clientMessage.appendData(key);
+        clientMessage.appendLong(threadId);
+        clientMessage.updateFrameLength();
+        return clientMessage;
+    };
+    MapGetEntryViewCodec.decodeResponse = function (clientMessage, toObjectFunction) {
+        if (toObjectFunction === void 0) { toObjectFunction = null; }
+        // Decode response from client message
+        var parameters = {
+            'response': null
+        };
+        if (clientMessage.readBoolean() !== true) {
+            parameters['response'] = EntryViewCodec_1.EntryViewCodec.decode(clientMessage, toObjectFunction);
+        }
+        return parameters;
+    };
+    return MapGetEntryViewCodec;
+}());
+exports.MapGetEntryViewCodec = MapGetEntryViewCodec;

package/lib/codec/MapIsEmptyCodec.d.ts

@@ -0,0 +1,7 @@
+import ClientMessage = require('../ClientMessage');
+import { Data } from '../serialization/Data';
+export declare class MapIsEmptyCodec {
+    static calculateSize(name: string): number;
+    static encodeRequest(name: string): ClientMessage;
+    static decodeResponse(clientMessage: ClientMessage, toObjectFunction?: (data: Data) => any): any;
+}

package/lib/codec/MapIsEmptyCodec.js

@@ -0,0 +1,54 @@
+"use strict";
+/*
+ * 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.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+/* tslint:disable */
+var ClientMessage = require("../ClientMessage");
+var BitsUtil_1 = require("../BitsUtil");
+var MapMessageType_1 = require("./MapMessageType");
+var REQUEST_TYPE = MapMessageType_1.MapMessageType.MAP_ISEMPTY;
+var RESPONSE_TYPE = 101;
+var RETRYABLE = true;
+var MapIsEmptyCodec = /** @class */ (function () {
+    function MapIsEmptyCodec() {
+    }
+    MapIsEmptyCodec.calculateSize = function (name) {
+        // Calculates the request payload size
+        var dataSize = 0;
+        dataSize += BitsUtil_1.BitsUtil.calculateSizeString(name);
+        return dataSize;
+    };
+    MapIsEmptyCodec.encodeRequest = function (name) {
+        // Encode request into clientMessage
+        var clientMessage = ClientMessage.newClientMessage(this.calculateSize(name));
+        clientMessage.setMessageType(REQUEST_TYPE);
+        clientMessage.setRetryable(RETRYABLE);
+        clientMessage.appendString(name);
+        clientMessage.updateFrameLength();
+        return clientMessage;
+    };
+    MapIsEmptyCodec.decodeResponse = function (clientMessage, toObjectFunction) {
+        if (toObjectFunction === void 0) { toObjectFunction = null; }
+        // Decode response from client message
+        var parameters = {
+            'response': null
+        };
+        parameters['response'] = clientMessage.readBoolean();
+        return parameters;
+    };
+    return MapIsEmptyCodec;
+}());
+exports.MapIsEmptyCodec = MapIsEmptyCodec;

package/lib/codec/MapIsLockedCodec.d.ts

@@ -0,0 +1,7 @@
+import ClientMessage = require('../ClientMessage');
+import { Data } from '../serialization/Data';
+export declare class MapIsLockedCodec {
+    static calculateSize(name: string, key: Data): number;
+    static encodeRequest(name: string, key: Data): ClientMessage;
+    static decodeResponse(clientMessage: ClientMessage, toObjectFunction?: (data: Data) => any): any;
+}

package/lib/codec/MapIsLockedCodec.js

@@ -0,0 +1,56 @@
+"use strict";
+/*
+ * 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.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+/* tslint:disable */
+var ClientMessage = require("../ClientMessage");
+var BitsUtil_1 = require("../BitsUtil");
+var MapMessageType_1 = require("./MapMessageType");
+var REQUEST_TYPE = MapMessageType_1.MapMessageType.MAP_ISLOCKED;
+var RESPONSE_TYPE = 101;
+var RETRYABLE = true;
+var MapIsLockedCodec = /** @class */ (function () {
+    function MapIsLockedCodec() {
+    }
+    MapIsLockedCodec.calculateSize = function (name, key) {
+        // Calculates the request payload size
+        var dataSize = 0;
+        dataSize += BitsUtil_1.BitsUtil.calculateSizeString(name);
+        dataSize += BitsUtil_1.BitsUtil.calculateSizeData(key);
+        return dataSize;
+    };
+    MapIsLockedCodec.encodeRequest = function (name, key) {
+        // Encode request into clientMessage
+        var clientMessage = ClientMessage.newClientMessage(this.calculateSize(name, key));
+        clientMessage.setMessageType(REQUEST_TYPE);
+        clientMessage.setRetryable(RETRYABLE);
+        clientMessage.appendString(name);
+        clientMessage.appendData(key);
+        clientMessage.updateFrameLength();
+        return clientMessage;
+    };
+    MapIsLockedCodec.decodeResponse = function (clientMessage, toObjectFunction) {
+        if (toObjectFunction === void 0) { toObjectFunction = null; }
+        // Decode response from client message
+        var parameters = {
+            'response': null
+        };
+        parameters['response'] = clientMessage.readBoolean();
+        return parameters;
+    };
+    return MapIsLockedCodec;
+}());
+exports.MapIsLockedCodec = MapIsLockedCodec;

package/lib/codec/MapKeySetCodec.d.ts

@@ -0,0 +1,7 @@
+import ClientMessage = require('../ClientMessage');
+import { Data } from '../serialization/Data';
+export declare class MapKeySetCodec {
+    static calculateSize(name: string): number;
+    static encodeRequest(name: string): ClientMessage;
+    static decodeResponse(clientMessage: ClientMessage, toObjectFunction?: (data: Data) => any): any;
+}

package/lib/codec/MapKeySetCodec.js

@@ -0,0 +1,61 @@
+"use strict";
+/*
+ * 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.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+/* tslint:disable */
+var ClientMessage = require("../ClientMessage");
+var BitsUtil_1 = require("../BitsUtil");
+var MapMessageType_1 = require("./MapMessageType");
+var REQUEST_TYPE = MapMessageType_1.MapMessageType.MAP_KEYSET;
+var RESPONSE_TYPE = 106;
+var RETRYABLE = true;
+var MapKeySetCodec = /** @class */ (function () {
+    function MapKeySetCodec() {
+    }
+    MapKeySetCodec.calculateSize = function (name) {
+        // Calculates the request payload size
+        var dataSize = 0;
+        dataSize += BitsUtil_1.BitsUtil.calculateSizeString(name);
+        return dataSize;
+    };
+    MapKeySetCodec.encodeRequest = function (name) {
+        // Encode request into clientMessage
+        var clientMessage = ClientMessage.newClientMessage(this.calculateSize(name));
+        clientMessage.setMessageType(REQUEST_TYPE);
+        clientMessage.setRetryable(RETRYABLE);
+        clientMessage.appendString(name);
+        clientMessage.updateFrameLength();
+        return clientMessage;
+    };
+    MapKeySetCodec.decodeResponse = function (clientMessage, toObjectFunction) {
+        if (toObjectFunction === void 0) { toObjectFunction = null; }
+        // Decode response from client message
+        var parameters = {
+            'response': null
+        };
+        var responseSize = clientMessage.readInt32();
+        var response = [];
+        for (var responseIndex = 0; responseIndex < responseSize; responseIndex++) {
+            var responseItem;
+            responseItem = clientMessage.readData();
+            response.push(responseItem);
+        }
+        parameters['response'] = response;
+        return parameters;
+    };
+    return MapKeySetCodec;
+}());
+exports.MapKeySetCodec = MapKeySetCodec;

package/lib/codec/MapKeySetWithPagingPredicateCodec.d.ts

@@ -0,0 +1,7 @@
+import ClientMessage = require('../ClientMessage');
+import { Data } from '../serialization/Data';
+export declare class MapKeySetWithPagingPredicateCodec {
+    static calculateSize(name: string, predicate: Data): number;
+    static encodeRequest(name: string, predicate: Data): ClientMessage;
+    static decodeResponse(clientMessage: ClientMessage, toObjectFunction?: (data: Data) => any): any;
+}

package/lib/codec/MapKeySetWithPagingPredicateCodec.js

@@ -0,0 +1,63 @@
+"use strict";
+/*
+ * 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.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+/* tslint:disable */
+var ClientMessage = require("../ClientMessage");
+var BitsUtil_1 = require("../BitsUtil");
+var MapMessageType_1 = require("./MapMessageType");
+var REQUEST_TYPE = MapMessageType_1.MapMessageType.MAP_KEYSETWITHPAGINGPREDICATE;
+var RESPONSE_TYPE = 106;
+var RETRYABLE = true;
+var MapKeySetWithPagingPredicateCodec = /** @class */ (function () {
+    function MapKeySetWithPagingPredicateCodec() {
+    }
+    MapKeySetWithPagingPredicateCodec.calculateSize = function (name, predicate) {
+        // Calculates the request payload size
+        var dataSize = 0;
+        dataSize += BitsUtil_1.BitsUtil.calculateSizeString(name);
+        dataSize += BitsUtil_1.BitsUtil.calculateSizeData(predicate);
+        return dataSize;
+    };
+    MapKeySetWithPagingPredicateCodec.encodeRequest = function (name, predicate) {
+        // Encode request into clientMessage
+        var clientMessage = ClientMessage.newClientMessage(this.calculateSize(name, predicate));
+        clientMessage.setMessageType(REQUEST_TYPE);
+        clientMessage.setRetryable(RETRYABLE);
+        clientMessage.appendString(name);
+        clientMessage.appendData(predicate);
+        clientMessage.updateFrameLength();
+        return clientMessage;
+    };
+    MapKeySetWithPagingPredicateCodec.decodeResponse = function (clientMessage, toObjectFunction) {
+        if (toObjectFunction === void 0) { toObjectFunction = null; }
+        // Decode response from client message
+        var parameters = {
+            'response': null
+        };
+        var responseSize = clientMessage.readInt32();
+        var response = [];
+        for (var responseIndex = 0; responseIndex < responseSize; responseIndex++) {
+            var responseItem;
+            responseItem = clientMessage.readData();
+            response.push(responseItem);
+        }
+        parameters['response'] = response;
+        return parameters;
+    };
+    return MapKeySetWithPagingPredicateCodec;
+}());
+exports.MapKeySetWithPagingPredicateCodec = MapKeySetWithPagingPredicateCodec;

package/lib/codec/MapKeySetWithPredicateCodec.d.ts

@@ -0,0 +1,7 @@
+import ClientMessage = require('../ClientMessage');
+import { Data } from '../serialization/Data';
+export declare class MapKeySetWithPredicateCodec {
+    static calculateSize(name: string, predicate: Data): number;
+    static encodeRequest(name: string, predicate: Data): ClientMessage;
+    static decodeResponse(clientMessage: ClientMessage, toObjectFunction?: (data: Data) => any): any;
+}

package/lib/codec/MapKeySetWithPredicateCodec.js

@@ -0,0 +1,63 @@
+"use strict";
+/*
+ * 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.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+/* tslint:disable */
+var ClientMessage = require("../ClientMessage");
+var BitsUtil_1 = require("../BitsUtil");
+var MapMessageType_1 = require("./MapMessageType");
+var REQUEST_TYPE = MapMessageType_1.MapMessageType.MAP_KEYSETWITHPREDICATE;
+var RESPONSE_TYPE = 106;
+var RETRYABLE = true;
+var MapKeySetWithPredicateCodec = /** @class */ (function () {
+    function MapKeySetWithPredicateCodec() {
+    }
+    MapKeySetWithPredicateCodec.calculateSize = function (name, predicate) {
+        // Calculates the request payload size
+        var dataSize = 0;
+        dataSize += BitsUtil_1.BitsUtil.calculateSizeString(name);
+        dataSize += BitsUtil_1.BitsUtil.calculateSizeData(predicate);
+        return dataSize;
+    };
+    MapKeySetWithPredicateCodec.encodeRequest = function (name, predicate) {
+        // Encode request into clientMessage
+        var clientMessage = ClientMessage.newClientMessage(this.calculateSize(name, predicate));
+        clientMessage.setMessageType(REQUEST_TYPE);
+        clientMessage.setRetryable(RETRYABLE);
+        clientMessage.appendString(name);
+        clientMessage.appendData(predicate);
+        clientMessage.updateFrameLength();
+        return clientMessage;
+    };
+    MapKeySetWithPredicateCodec.decodeResponse = function (clientMessage, toObjectFunction) {
+        if (toObjectFunction === void 0) { toObjectFunction = null; }
+        // Decode response from client message
+        var parameters = {
+            'response': null
+        };
+        var responseSize = clientMessage.readInt32();
+        var response = [];
+        for (var responseIndex = 0; responseIndex < responseSize; responseIndex++) {
+            var responseItem;
+            responseItem = clientMessage.readData();
+            response.push(responseItem);
+        }
+        parameters['response'] = response;
+        return parameters;
+    };
+    return MapKeySetWithPredicateCodec;
+}());
+exports.MapKeySetWithPredicateCodec = MapKeySetWithPredicateCodec;

package/lib/codec/MapLoadAllCodec.d.ts

@@ -0,0 +1,5 @@
+import ClientMessage = require('../ClientMessage');
+export declare class MapLoadAllCodec {
+    static calculateSize(name: string, replaceExistingValues: boolean): number;
+    static encodeRequest(name: string, replaceExistingValues: boolean): ClientMessage;
+}

package/lib/codec/MapLoadAllCodec.js

@@ -0,0 +1,47 @@
+"use strict";
+/*
+ * 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.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+/* tslint:disable */
+var ClientMessage = require("../ClientMessage");
+var BitsUtil_1 = require("../BitsUtil");
+var MapMessageType_1 = require("./MapMessageType");
+var REQUEST_TYPE = MapMessageType_1.MapMessageType.MAP_LOADALL;
+var RESPONSE_TYPE = 100;
+var RETRYABLE = false;
+var MapLoadAllCodec = /** @class */ (function () {
+    function MapLoadAllCodec() {
+    }
+    MapLoadAllCodec.calculateSize = function (name, replaceExistingValues) {
+        // Calculates the request payload size
+        var dataSize = 0;
+        dataSize += BitsUtil_1.BitsUtil.calculateSizeString(name);
+        dataSize += BitsUtil_1.BitsUtil.BOOLEAN_SIZE_IN_BYTES;
+        return dataSize;
+    };
+    MapLoadAllCodec.encodeRequest = function (name, replaceExistingValues) {
+        // Encode request into clientMessage
+        var clientMessage = ClientMessage.newClientMessage(this.calculateSize(name, replaceExistingValues));
+        clientMessage.setMessageType(REQUEST_TYPE);
+        clientMessage.setRetryable(RETRYABLE);
+        clientMessage.appendString(name);
+        clientMessage.appendBoolean(replaceExistingValues);
+        clientMessage.updateFrameLength();
+        return clientMessage;
+    };
+    return MapLoadAllCodec;
+}());
+exports.MapLoadAllCodec = MapLoadAllCodec;

package/lib/codec/MapLoadGivenKeysCodec.d.ts

@@ -0,0 +1,5 @@
+import ClientMessage = require('../ClientMessage');
+export declare class MapLoadGivenKeysCodec {
+    static calculateSize(name: string, keys: any, replaceExistingValues: boolean): number;
+    static encodeRequest(name: string, keys: any, replaceExistingValues: boolean): ClientMessage;
+}

package/lib/codec/MapLoadGivenKeysCodec.js

@@ -0,0 +1,55 @@
+"use strict";
+/*
+ * 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.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+/* tslint:disable */
+var ClientMessage = require("../ClientMessage");
+var BitsUtil_1 = require("../BitsUtil");
+var MapMessageType_1 = require("./MapMessageType");
+var REQUEST_TYPE = MapMessageType_1.MapMessageType.MAP_LOADGIVENKEYS;
+var RESPONSE_TYPE = 100;
+var RETRYABLE = false;
+var MapLoadGivenKeysCodec = /** @class */ (function () {
+    function MapLoadGivenKeysCodec() {
+    }
+    MapLoadGivenKeysCodec.calculateSize = function (name, keys, replaceExistingValues) {
+        // Calculates the request payload size
+        var dataSize = 0;
+        dataSize += BitsUtil_1.BitsUtil.calculateSizeString(name);
+        dataSize += BitsUtil_1.BitsUtil.INT_SIZE_IN_BYTES;
+        keys.forEach(function (keysItem) {
+            dataSize += BitsUtil_1.BitsUtil.calculateSizeData(keysItem);
+        });
+        dataSize += BitsUtil_1.BitsUtil.BOOLEAN_SIZE_IN_BYTES;
+        return dataSize;
+    };
+    MapLoadGivenKeysCodec.encodeRequest = function (name, keys, replaceExistingValues) {
+        // Encode request into clientMessage
+        var clientMessage = ClientMessage.newClientMessage(this.calculateSize(name, keys, replaceExistingValues));
+        clientMessage.setMessageType(REQUEST_TYPE);
+        clientMessage.setRetryable(RETRYABLE);
+        clientMessage.appendString(name);
+        clientMessage.appendInt32(keys.length);
+        keys.forEach(function (keysItem) {
+            clientMessage.appendData(keysItem);
+        });
+        clientMessage.appendBoolean(replaceExistingValues);
+        clientMessage.updateFrameLength();
+        return clientMessage;
+    };
+    return MapLoadGivenKeysCodec;
+}());
+exports.MapLoadGivenKeysCodec = MapLoadGivenKeysCodec;

package/lib/codec/MapLockCodec.d.ts

@@ -0,0 +1,6 @@
+import ClientMessage = require('../ClientMessage');
+import { Data } from '../serialization/Data';
+export declare class MapLockCodec {
+    static calculateSize(name: string, key: Data, threadId: any, ttl: any, referenceId: any): number;
+    static encodeRequest(name: string, key: Data, threadId: any, ttl: any, referenceId: any): ClientMessage;
+}

package/lib/codec/MapLockCodec.js

@@ -0,0 +1,53 @@
+"use strict";
+/*
+ * 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.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+/* tslint:disable */
+var ClientMessage = require("../ClientMessage");
+var BitsUtil_1 = require("../BitsUtil");
+var MapMessageType_1 = require("./MapMessageType");
+var REQUEST_TYPE = MapMessageType_1.MapMessageType.MAP_LOCK;
+var RESPONSE_TYPE = 100;
+var RETRYABLE = true;
+var MapLockCodec = /** @class */ (function () {
+    function MapLockCodec() {
+    }
+    MapLockCodec.calculateSize = function (name, key, threadId, ttl, referenceId) {
+        // Calculates the request payload size
+        var dataSize = 0;
+        dataSize += BitsUtil_1.BitsUtil.calculateSizeString(name);
+        dataSize += BitsUtil_1.BitsUtil.calculateSizeData(key);
+        dataSize += BitsUtil_1.BitsUtil.LONG_SIZE_IN_BYTES;
+        dataSize += BitsUtil_1.BitsUtil.LONG_SIZE_IN_BYTES;
+        dataSize += BitsUtil_1.BitsUtil.LONG_SIZE_IN_BYTES;
+        return dataSize;
+    };
+    MapLockCodec.encodeRequest = function (name, key, threadId, ttl, referenceId) {
+        // Encode request into clientMessage
+        var clientMessage = ClientMessage.newClientMessage(this.calculateSize(name, key, threadId, ttl, referenceId));
+        clientMessage.setMessageType(REQUEST_TYPE);
+        clientMessage.setRetryable(RETRYABLE);
+        clientMessage.appendString(name);
+        clientMessage.appendData(key);
+        clientMessage.appendLong(threadId);
+        clientMessage.appendLong(ttl);
+        clientMessage.appendLong(referenceId);
+        clientMessage.updateFrameLength();
+        return clientMessage;
+    };
+    return MapLockCodec;
+}());
+exports.MapLockCodec = MapLockCodec;

package/lib/codec/MapMessageType.d.ts

@@ -0,0 +1,71 @@
+export declare class MapMessageType {
+    static MAP_PUT: number;
+    static MAP_GET: number;
+    static MAP_REMOVE: number;
+    static MAP_REPLACE: number;
+    static MAP_REPLACEIFSAME: number;
+    static MAP_CONTAINSKEY: number;
+    static MAP_CONTAINSVALUE: number;
+    static MAP_REMOVEIFSAME: number;
+    static MAP_DELETE: number;
+    static MAP_FLUSH: number;
+    static MAP_TRYREMOVE: number;
+    static MAP_TRYPUT: number;
+    static MAP_PUTTRANSIENT: number;
+    static MAP_PUTIFABSENT: number;
+    static MAP_SET: number;
+    static MAP_LOCK: number;
+    static MAP_TRYLOCK: number;
+    static MAP_ISLOCKED: number;
+    static MAP_UNLOCK: number;
+    static MAP_ADDINTERCEPTOR: number;
+    static MAP_REMOVEINTERCEPTOR: number;
+    static MAP_ADDENTRYLISTENERTOKEYWITHPREDICATE: number;
+    static MAP_ADDENTRYLISTENERWITHPREDICATE: number;
+    static MAP_ADDENTRYLISTENERTOKEY: number;
+    static MAP_ADDENTRYLISTENER: number;
+    static MAP_ADDNEARCACHEENTRYLISTENER: number;
+    static MAP_REMOVEENTRYLISTENER: number;
+    static MAP_ADDPARTITIONLOSTLISTENER: number;
+    static MAP_REMOVEPARTITIONLOSTLISTENER: number;
+    static MAP_GETENTRYVIEW: number;
+    static MAP_EVICT: number;
+    static MAP_EVICTALL: number;
+    static MAP_LOADALL: number;
+    static MAP_LOADGIVENKEYS: number;
+    static MAP_KEYSET: number;
+    static MAP_GETALL: number;
+    static MAP_VALUES: number;
+    static MAP_ENTRYSET: number;
+    static MAP_KEYSETWITHPREDICATE: number;
+    static MAP_VALUESWITHPREDICATE: number;
+    static MAP_ENTRIESWITHPREDICATE: number;
+    static MAP_ADDINDEX: number;
+    static MAP_SIZE: number;
+    static MAP_ISEMPTY: number;
+    static MAP_PUTALL: number;
+    static MAP_CLEAR: number;
+    static MAP_EXECUTEONKEY: number;
+    static MAP_SUBMITTOKEY: number;
+    static MAP_EXECUTEONALLKEYS: number;
+    static MAP_EXECUTEWITHPREDICATE: number;
+    static MAP_EXECUTEONKEYS: number;
+    static MAP_FORCEUNLOCK: number;
+    static MAP_KEYSETWITHPAGINGPREDICATE: number;
+    static MAP_VALUESWITHPAGINGPREDICATE: number;
+    static MAP_ENTRIESWITHPAGINGPREDICATE: number;
+    static MAP_CLEARNEARCACHE: number;
+    static MAP_FETCHKEYS: number;
+    static MAP_FETCHENTRIES: number;
+    static MAP_AGGREGATE: number;
+    static MAP_AGGREGATEWITHPREDICATE: number;
+    static MAP_PROJECT: number;
+    static MAP_PROJECTWITHPREDICATE: number;
+    static MAP_FETCHNEARCACHEINVALIDATIONMETADATA: number;
+    static MAP_ASSIGNANDGETUUIDS: number;
+    static MAP_REMOVEALL: number;
+    static MAP_ADDNEARCACHEINVALIDATIONLISTENER: number;
+    static MAP_FETCHWITHQUERY: number;
+    static MAP_EVENTJOURNALSUBSCRIBE: number;
+    static MAP_EVENTJOURNALREAD: number;
+}