@celerispay/hazelcast-client 3.12.5

package/lib/codec/PNCounterGetConfiguredReplicaCountCodec.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 PNCounterMessageType_1 = require("./PNCounterMessageType");
+var REQUEST_TYPE = PNCounterMessageType_1.PNCounterMessageType.PNCOUNTER_GETCONFIGUREDREPLICACOUNT;
+var RESPONSE_TYPE = 102;
+var RETRYABLE = true;
+var PNCounterGetConfiguredReplicaCountCodec = /** @class */ (function () {
+    function PNCounterGetConfiguredReplicaCountCodec() {
+    }
+    PNCounterGetConfiguredReplicaCountCodec.calculateSize = function (name) {
+        var dataSize = 0;
+        dataSize += BitsUtil_1.BitsUtil.calculateSizeString(name);
+        return dataSize;
+    };
+    PNCounterGetConfiguredReplicaCountCodec.encodeRequest = function (name) {
+        var clientMessage = ClientMessage.newClientMessage(this.calculateSize(name));
+        clientMessage.setMessageType(REQUEST_TYPE);
+        clientMessage.setRetryable(RETRYABLE);
+        clientMessage.appendString(name);
+        clientMessage.updateFrameLength();
+        return clientMessage;
+    };
+    PNCounterGetConfiguredReplicaCountCodec.decodeResponse = function (clientMessage, toObjectFunction) {
+        if (toObjectFunction === void 0) { toObjectFunction = null; }
+        var parameters = {
+            'response': null
+        };
+        if (clientMessage.isComplete()) {
+            return parameters;
+        }
+        parameters['response'] = clientMessage.readInt32();
+        return parameters;
+    };
+    return PNCounterGetConfiguredReplicaCountCodec;
+}());
+exports.PNCounterGetConfiguredReplicaCountCodec = PNCounterGetConfiguredReplicaCountCodec;

package/lib/codec/PNCounterMessageType.d.ts

@@ -0,0 +1,5 @@
+export declare class PNCounterMessageType {
+    static PNCOUNTER_GET: number;
+    static PNCOUNTER_ADD: number;
+    static PNCOUNTER_GETCONFIGUREDREPLICACOUNT: number;
+}

package/lib/codec/PNCounterMessageType.js

@@ -0,0 +1,27 @@
+"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 PNCounterMessageType = /** @class */ (function () {
+    function PNCounterMessageType() {
+    }
+    PNCounterMessageType.PNCOUNTER_GET = 0x2001;
+    PNCounterMessageType.PNCOUNTER_ADD = 0x2002;
+    PNCounterMessageType.PNCOUNTER_GETCONFIGUREDREPLICACOUNT = 0x2003;
+    return PNCounterMessageType;
+}());
+exports.PNCounterMessageType = PNCounterMessageType;

package/lib/codec/QueueAddAllCodec.d.ts

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

package/lib/codec/QueueAddAllCodec.js

@@ -0,0 +1,62 @@
+"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 QueueMessageType_1 = require("./QueueMessageType");
+var REQUEST_TYPE = QueueMessageType_1.QueueMessageType.QUEUE_ADDALL;
+var RESPONSE_TYPE = 101;
+var RETRYABLE = false;
+var QueueAddAllCodec = /** @class */ (function () {
+    function QueueAddAllCodec() {
+    }
+    QueueAddAllCodec.calculateSize = function (name, dataList) {
+        // Calculates the request payload size
+        var dataSize = 0;
+        dataSize += BitsUtil_1.BitsUtil.calculateSizeString(name);
+        dataSize += BitsUtil_1.BitsUtil.INT_SIZE_IN_BYTES;
+        dataList.forEach(function (dataListItem) {
+            dataSize += BitsUtil_1.BitsUtil.calculateSizeData(dataListItem);
+        });
+        return dataSize;
+    };
+    QueueAddAllCodec.encodeRequest = function (name, dataList) {
+        // Encode request into clientMessage
+        var clientMessage = ClientMessage.newClientMessage(this.calculateSize(name, dataList));
+        clientMessage.setMessageType(REQUEST_TYPE);
+        clientMessage.setRetryable(RETRYABLE);
+        clientMessage.appendString(name);
+        clientMessage.appendInt32(dataList.length);
+        dataList.forEach(function (dataListItem) {
+            clientMessage.appendData(dataListItem);
+        });
+        clientMessage.updateFrameLength();
+        return clientMessage;
+    };
+    QueueAddAllCodec.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 QueueAddAllCodec;
+}());
+exports.QueueAddAllCodec = QueueAddAllCodec;

package/lib/codec/QueueAddListenerCodec.d.ts

@@ -0,0 +1,8 @@
+import ClientMessage = require('../ClientMessage');
+import { Data } from '../serialization/Data';
+export declare class QueueAddListenerCodec {
+    static calculateSize(name: string, includeValue: boolean, localOnly: boolean): number;
+    static encodeRequest(name: string, includeValue: boolean, localOnly: boolean): ClientMessage;
+    static decodeResponse(clientMessage: ClientMessage, toObjectFunction?: (data: Data) => any): any;
+    static handle(clientMessage: ClientMessage, handleEventItem: any, toObjectFunction?: (data: Data) => any): void;
+}

package/lib/codec/QueueAddListenerCodec.js

@@ -0,0 +1,80 @@
+"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 QueueMessageType_1 = require("./QueueMessageType");
+var REQUEST_TYPE = QueueMessageType_1.QueueMessageType.QUEUE_ADDLISTENER;
+var RESPONSE_TYPE = 104;
+var RETRYABLE = false;
+var QueueAddListenerCodec = /** @class */ (function () {
+    function QueueAddListenerCodec() {
+    }
+    QueueAddListenerCodec.calculateSize = function (name, includeValue, localOnly) {
+        // Calculates the request payload size
+        var dataSize = 0;
+        dataSize += BitsUtil_1.BitsUtil.calculateSizeString(name);
+        dataSize += BitsUtil_1.BitsUtil.BOOLEAN_SIZE_IN_BYTES;
+        dataSize += BitsUtil_1.BitsUtil.BOOLEAN_SIZE_IN_BYTES;
+        return dataSize;
+    };
+    QueueAddListenerCodec.encodeRequest = function (name, includeValue, localOnly) {
+        // Encode request into clientMessage
+        var clientMessage = ClientMessage.newClientMessage(this.calculateSize(name, includeValue, localOnly));
+        clientMessage.setMessageType(REQUEST_TYPE);
+        clientMessage.setRetryable(RETRYABLE);
+        clientMessage.appendString(name);
+        clientMessage.appendBoolean(includeValue);
+        clientMessage.appendBoolean(localOnly);
+        clientMessage.updateFrameLength();
+        return clientMessage;
+    };
+    QueueAddListenerCodec.decodeResponse = function (clientMessage, toObjectFunction) {
+        if (toObjectFunction === void 0) { toObjectFunction = null; }
+        // Decode response from client message
+        var parameters = {
+            'response': null
+        };
+        parameters['response'] = clientMessage.readString();
+        return parameters;
+    };
+    QueueAddListenerCodec.handle = function (clientMessage, handleEventItem, toObjectFunction) {
+        if (toObjectFunction === void 0) { toObjectFunction = null; }
+        var messageType = clientMessage.getMessageType();
+        if (messageType === BitsUtil_1.BitsUtil.EVENT_ITEM && handleEventItem !== null) {
+            var messageFinished = false;
+            var item = undefined;
+            if (!messageFinished) {
+                if (clientMessage.readBoolean() !== true) {
+                    item = clientMessage.readData();
+                }
+            }
+            var uuid = undefined;
+            if (!messageFinished) {
+                uuid = clientMessage.readString();
+            }
+            var eventType = undefined;
+            if (!messageFinished) {
+                eventType = clientMessage.readInt32();
+            }
+            handleEventItem(item, uuid, eventType);
+        }
+    };
+    return QueueAddListenerCodec;
+}());
+exports.QueueAddListenerCodec = QueueAddListenerCodec;

package/lib/codec/QueueClearCodec.d.ts

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

package/lib/codec/QueueClearCodec.js

@@ -0,0 +1,45 @@
+"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 QueueMessageType_1 = require("./QueueMessageType");
+var REQUEST_TYPE = QueueMessageType_1.QueueMessageType.QUEUE_CLEAR;
+var RESPONSE_TYPE = 100;
+var RETRYABLE = false;
+var QueueClearCodec = /** @class */ (function () {
+    function QueueClearCodec() {
+    }
+    QueueClearCodec.calculateSize = function (name) {
+        // Calculates the request payload size
+        var dataSize = 0;
+        dataSize += BitsUtil_1.BitsUtil.calculateSizeString(name);
+        return dataSize;
+    };
+    QueueClearCodec.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;
+    };
+    return QueueClearCodec;
+}());
+exports.QueueClearCodec = QueueClearCodec;

package/lib/codec/QueueCompareAndRemoveAllCodec.d.ts

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

package/lib/codec/QueueCompareAndRemoveAllCodec.js

@@ -0,0 +1,62 @@
+"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 QueueMessageType_1 = require("./QueueMessageType");
+var REQUEST_TYPE = QueueMessageType_1.QueueMessageType.QUEUE_COMPAREANDREMOVEALL;
+var RESPONSE_TYPE = 101;
+var RETRYABLE = false;
+var QueueCompareAndRemoveAllCodec = /** @class */ (function () {
+    function QueueCompareAndRemoveAllCodec() {
+    }
+    QueueCompareAndRemoveAllCodec.calculateSize = function (name, dataList) {
+        // Calculates the request payload size
+        var dataSize = 0;
+        dataSize += BitsUtil_1.BitsUtil.calculateSizeString(name);
+        dataSize += BitsUtil_1.BitsUtil.INT_SIZE_IN_BYTES;
+        dataList.forEach(function (dataListItem) {
+            dataSize += BitsUtil_1.BitsUtil.calculateSizeData(dataListItem);
+        });
+        return dataSize;
+    };
+    QueueCompareAndRemoveAllCodec.encodeRequest = function (name, dataList) {
+        // Encode request into clientMessage
+        var clientMessage = ClientMessage.newClientMessage(this.calculateSize(name, dataList));
+        clientMessage.setMessageType(REQUEST_TYPE);
+        clientMessage.setRetryable(RETRYABLE);
+        clientMessage.appendString(name);
+        clientMessage.appendInt32(dataList.length);
+        dataList.forEach(function (dataListItem) {
+            clientMessage.appendData(dataListItem);
+        });
+        clientMessage.updateFrameLength();
+        return clientMessage;
+    };
+    QueueCompareAndRemoveAllCodec.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 QueueCompareAndRemoveAllCodec;
+}());
+exports.QueueCompareAndRemoveAllCodec = QueueCompareAndRemoveAllCodec;

package/lib/codec/QueueCompareAndRetainAllCodec.d.ts

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

package/lib/codec/QueueCompareAndRetainAllCodec.js

@@ -0,0 +1,62 @@
+"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 QueueMessageType_1 = require("./QueueMessageType");
+var REQUEST_TYPE = QueueMessageType_1.QueueMessageType.QUEUE_COMPAREANDRETAINALL;
+var RESPONSE_TYPE = 101;
+var RETRYABLE = false;
+var QueueCompareAndRetainAllCodec = /** @class */ (function () {
+    function QueueCompareAndRetainAllCodec() {
+    }
+    QueueCompareAndRetainAllCodec.calculateSize = function (name, dataList) {
+        // Calculates the request payload size
+        var dataSize = 0;
+        dataSize += BitsUtil_1.BitsUtil.calculateSizeString(name);
+        dataSize += BitsUtil_1.BitsUtil.INT_SIZE_IN_BYTES;
+        dataList.forEach(function (dataListItem) {
+            dataSize += BitsUtil_1.BitsUtil.calculateSizeData(dataListItem);
+        });
+        return dataSize;
+    };
+    QueueCompareAndRetainAllCodec.encodeRequest = function (name, dataList) {
+        // Encode request into clientMessage
+        var clientMessage = ClientMessage.newClientMessage(this.calculateSize(name, dataList));
+        clientMessage.setMessageType(REQUEST_TYPE);
+        clientMessage.setRetryable(RETRYABLE);
+        clientMessage.appendString(name);
+        clientMessage.appendInt32(dataList.length);
+        dataList.forEach(function (dataListItem) {
+            clientMessage.appendData(dataListItem);
+        });
+        clientMessage.updateFrameLength();
+        return clientMessage;
+    };
+    QueueCompareAndRetainAllCodec.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 QueueCompareAndRetainAllCodec;
+}());
+exports.QueueCompareAndRetainAllCodec = QueueCompareAndRetainAllCodec;

package/lib/codec/QueueContainsAllCodec.d.ts

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

package/lib/codec/QueueContainsAllCodec.js

@@ -0,0 +1,62 @@
+"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 QueueMessageType_1 = require("./QueueMessageType");
+var REQUEST_TYPE = QueueMessageType_1.QueueMessageType.QUEUE_CONTAINSALL;
+var RESPONSE_TYPE = 101;
+var RETRYABLE = false;
+var QueueContainsAllCodec = /** @class */ (function () {
+    function QueueContainsAllCodec() {
+    }
+    QueueContainsAllCodec.calculateSize = function (name, dataList) {
+        // Calculates the request payload size
+        var dataSize = 0;
+        dataSize += BitsUtil_1.BitsUtil.calculateSizeString(name);
+        dataSize += BitsUtil_1.BitsUtil.INT_SIZE_IN_BYTES;
+        dataList.forEach(function (dataListItem) {
+            dataSize += BitsUtil_1.BitsUtil.calculateSizeData(dataListItem);
+        });
+        return dataSize;
+    };
+    QueueContainsAllCodec.encodeRequest = function (name, dataList) {
+        // Encode request into clientMessage
+        var clientMessage = ClientMessage.newClientMessage(this.calculateSize(name, dataList));
+        clientMessage.setMessageType(REQUEST_TYPE);
+        clientMessage.setRetryable(RETRYABLE);
+        clientMessage.appendString(name);
+        clientMessage.appendInt32(dataList.length);
+        dataList.forEach(function (dataListItem) {
+            clientMessage.appendData(dataListItem);
+        });
+        clientMessage.updateFrameLength();
+        return clientMessage;
+    };
+    QueueContainsAllCodec.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 QueueContainsAllCodec;
+}());
+exports.QueueContainsAllCodec = QueueContainsAllCodec;

package/lib/codec/QueueContainsCodec.d.ts

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

package/lib/codec/QueueContainsCodec.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 QueueMessageType_1 = require("./QueueMessageType");
+var REQUEST_TYPE = QueueMessageType_1.QueueMessageType.QUEUE_CONTAINS;
+var RESPONSE_TYPE = 101;
+var RETRYABLE = false;
+var QueueContainsCodec = /** @class */ (function () {
+    function QueueContainsCodec() {
+    }
+    QueueContainsCodec.calculateSize = function (name, value) {
+        // Calculates the request payload size
+        var dataSize = 0;
+        dataSize += BitsUtil_1.BitsUtil.calculateSizeString(name);
+        dataSize += BitsUtil_1.BitsUtil.calculateSizeData(value);
+        return dataSize;
+    };
+    QueueContainsCodec.encodeRequest = function (name, value) {
+        // Encode request into clientMessage
+        var clientMessage = ClientMessage.newClientMessage(this.calculateSize(name, value));
+        clientMessage.setMessageType(REQUEST_TYPE);
+        clientMessage.setRetryable(RETRYABLE);
+        clientMessage.appendString(name);
+        clientMessage.appendData(value);
+        clientMessage.updateFrameLength();
+        return clientMessage;
+    };
+    QueueContainsCodec.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 QueueContainsCodec;
+}());
+exports.QueueContainsCodec = QueueContainsCodec;

package/lib/codec/QueueDrainToCodec.d.ts

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

package/lib/codec/QueueDrainToCodec.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 QueueMessageType_1 = require("./QueueMessageType");
+var REQUEST_TYPE = QueueMessageType_1.QueueMessageType.QUEUE_DRAINTO;
+var RESPONSE_TYPE = 106;
+var RETRYABLE = false;
+var QueueDrainToCodec = /** @class */ (function () {
+    function QueueDrainToCodec() {
+    }
+    QueueDrainToCodec.calculateSize = function (name) {
+        // Calculates the request payload size
+        var dataSize = 0;
+        dataSize += BitsUtil_1.BitsUtil.calculateSizeString(name);
+        return dataSize;
+    };
+    QueueDrainToCodec.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;
+    };
+    QueueDrainToCodec.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 QueueDrainToCodec;
+}());
+exports.QueueDrainToCodec = QueueDrainToCodec;

package/lib/codec/QueueDrainToMaxSizeCodec.d.ts

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