@celerispay/hazelcast-client 3.12.5

package/lib/serialization/portable/ClassDefinitionBuilder.js

@@ -0,0 +1,126 @@
+"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 });
+var ClassDefinition_1 = require("./ClassDefinition");
+var HazelcastError_1 = require("../../HazelcastError");
+var ClassDefinitionBuilder = /** @class */ (function () {
+    function ClassDefinitionBuilder(factoryId, classId, version) {
+        if (version === void 0) { version = 0; }
+        this.fieldDefinitions = [];
+        this.index = 0;
+        this.factoryId = factoryId;
+        this.classId = classId;
+        this.version = version;
+    }
+    ClassDefinitionBuilder.prototype.getFactoryId = function () {
+        return this.factoryId;
+    };
+    ClassDefinitionBuilder.prototype.getClassId = function () {
+        return this.classId;
+    };
+    ClassDefinitionBuilder.prototype.getVersion = function () {
+        return this.version;
+    };
+    ClassDefinitionBuilder.prototype.addByteField = function (fieldName) {
+        return this.addField(new ClassDefinition_1.FieldDefinition(this.index, fieldName, ClassDefinition_1.FieldType.BYTE, this.version));
+    };
+    ClassDefinitionBuilder.prototype.addBooleanField = function (fieldName) {
+        return this.addField(new ClassDefinition_1.FieldDefinition(this.index, fieldName, ClassDefinition_1.FieldType.BOOLEAN, this.version));
+    };
+    ClassDefinitionBuilder.prototype.addCharField = function (fieldName) {
+        return this.addField(new ClassDefinition_1.FieldDefinition(this.index, fieldName, ClassDefinition_1.FieldType.CHAR, this.version));
+    };
+    ClassDefinitionBuilder.prototype.addShortField = function (fieldName) {
+        return this.addField(new ClassDefinition_1.FieldDefinition(this.index, fieldName, ClassDefinition_1.FieldType.SHORT, this.version));
+    };
+    ClassDefinitionBuilder.prototype.addIntField = function (fieldName) {
+        return this.addField(new ClassDefinition_1.FieldDefinition(this.index, fieldName, ClassDefinition_1.FieldType.INT, this.version));
+    };
+    ClassDefinitionBuilder.prototype.addLongField = function (fieldName) {
+        return this.addField(new ClassDefinition_1.FieldDefinition(this.index, fieldName, ClassDefinition_1.FieldType.LONG, this.version));
+    };
+    ClassDefinitionBuilder.prototype.addFloatField = function (fieldName) {
+        return this.addField(new ClassDefinition_1.FieldDefinition(this.index, fieldName, ClassDefinition_1.FieldType.FLOAT, this.version));
+    };
+    ClassDefinitionBuilder.prototype.addDoubleField = function (fieldName) {
+        return this.addField(new ClassDefinition_1.FieldDefinition(this.index, fieldName, ClassDefinition_1.FieldType.DOUBLE, this.version));
+    };
+    ClassDefinitionBuilder.prototype.addUTFField = function (fieldName) {
+        return this.addField(new ClassDefinition_1.FieldDefinition(this.index, fieldName, ClassDefinition_1.FieldType.UTF, this.version));
+    };
+    ClassDefinitionBuilder.prototype.addPortableField = function (fieldName, def) {
+        if (def.getClassId() === 0) {
+            throw new RangeError('Portable class ID cannot be zero!');
+        }
+        return this.addField(new ClassDefinition_1.FieldDefinition(this.index, fieldName, ClassDefinition_1.FieldType.PORTABLE, def.getVersion(), def.getFactoryId(), def.getClassId()));
+    };
+    ClassDefinitionBuilder.prototype.addByteArrayField = function (fieldName) {
+        return this.addField(new ClassDefinition_1.FieldDefinition(this.index, fieldName, ClassDefinition_1.FieldType.BYTE_ARRAY, this.version));
+    };
+    ClassDefinitionBuilder.prototype.addBooleanArrayField = function (fieldName) {
+        return this.addField(new ClassDefinition_1.FieldDefinition(this.index, fieldName, ClassDefinition_1.FieldType.BOOLEAN_ARRAY, this.version));
+    };
+    ClassDefinitionBuilder.prototype.addCharArrayField = function (fieldName) {
+        return this.addField(new ClassDefinition_1.FieldDefinition(this.index, fieldName, ClassDefinition_1.FieldType.CHAR_ARRAY, this.version));
+    };
+    ClassDefinitionBuilder.prototype.addShortArrayField = function (fieldName) {
+        return this.addField(new ClassDefinition_1.FieldDefinition(this.index, fieldName, ClassDefinition_1.FieldType.SHORT_ARRAY, this.version));
+    };
+    ClassDefinitionBuilder.prototype.addIntArrayField = function (fieldName) {
+        return this.addField(new ClassDefinition_1.FieldDefinition(this.index, fieldName, ClassDefinition_1.FieldType.INT_ARRAY, this.version));
+    };
+    ClassDefinitionBuilder.prototype.addLongArrayField = function (fieldName) {
+        return this.addField(new ClassDefinition_1.FieldDefinition(this.index, fieldName, ClassDefinition_1.FieldType.LONG_ARRAY, this.version));
+    };
+    ClassDefinitionBuilder.prototype.addFloatArrayField = function (fieldName) {
+        return this.addField(new ClassDefinition_1.FieldDefinition(this.index, fieldName, ClassDefinition_1.FieldType.FLOAT_ARRAY, this.version));
+    };
+    ClassDefinitionBuilder.prototype.addDoubleArrayField = function (fieldName) {
+        return this.addField(new ClassDefinition_1.FieldDefinition(this.index, fieldName, ClassDefinition_1.FieldType.DOUBLE_ARRAY, this.version));
+    };
+    ClassDefinitionBuilder.prototype.addUTFArrayField = function (fieldName) {
+        return this.addField(new ClassDefinition_1.FieldDefinition(this.index, fieldName, ClassDefinition_1.FieldType.UTF_ARRAY, this.version));
+    };
+    ClassDefinitionBuilder.prototype.addPortableArrayField = function (fieldName, def) {
+        if (def.getClassId() === 0) {
+            throw new RangeError('Portable class ID cannot be zero!');
+        }
+        return this.addField(new ClassDefinition_1.FieldDefinition(this.index, fieldName, ClassDefinition_1.FieldType.PORTABLE_ARRAY, def.getVersion(), def.getFactoryId(), def.getClassId()));
+    };
+    ClassDefinitionBuilder.prototype.addField = function (fieldDefinition) {
+        if (this.done) {
+            throw new HazelcastError_1.HazelcastSerializationError("ClassDefinition is already built for " + this.classId);
+        }
+        if (this.index !== fieldDefinition.getIndex()) {
+            throw new RangeError('Invalid field index');
+        }
+        this.fieldDefinitions.push(fieldDefinition);
+        this.index++;
+        return this;
+    };
+    ClassDefinitionBuilder.prototype.build = function () {
+        this.done = true;
+        var cd = new ClassDefinition_1.ClassDefinition(this.factoryId, this.classId, this.version);
+        for (var _i = 0, _a = this.fieldDefinitions; _i < _a.length; _i++) {
+            var fd = _a[_i];
+            cd.addFieldDefinition(fd);
+        }
+        return cd;
+    };
+    return ClassDefinitionBuilder;
+}());
+exports.ClassDefinitionBuilder = ClassDefinitionBuilder;

package/lib/serialization/portable/ClassDefinitionContext.d.ts

@@ -0,0 +1,9 @@
+import { ClassDefinition } from './ClassDefinition';
+export declare class ClassDefinitionContext {
+    private factoryId;
+    private classDefs;
+    constructor(factoryId: number);
+    private static encodeVersionedClassId(classId, version);
+    lookup(classId: number, version: number): ClassDefinition;
+    register(classDefinition: ClassDefinition): ClassDefinition;
+}

package/lib/serialization/portable/ClassDefinitionContext.js

@@ -0,0 +1,51 @@
+"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 });
+var HazelcastError_1 = require("../../HazelcastError");
+var ClassDefinitionContext = /** @class */ (function () {
+    function ClassDefinitionContext(factoryId) {
+        this.factoryId = factoryId;
+        this.classDefs = {};
+    }
+    ClassDefinitionContext.encodeVersionedClassId = function (classId, version) {
+        return classId + 'v' + version;
+    };
+    ClassDefinitionContext.prototype.lookup = function (classId, version) {
+        var encoded = ClassDefinitionContext.encodeVersionedClassId(classId, version);
+        return this.classDefs[encoded];
+    };
+    ClassDefinitionContext.prototype.register = function (classDefinition) {
+        if (classDefinition === null) {
+            return null;
+        }
+        if (classDefinition.getFactoryId() !== this.factoryId) {
+            throw new HazelcastError_1.HazelcastSerializationError("This factory's number is " + this.factoryId + ".\n            Intended factory id is " + classDefinition.getFactoryId());
+        }
+        var cdKey = ClassDefinitionContext.encodeVersionedClassId(classDefinition.getClassId(), classDefinition.getVersion());
+        var current = this.classDefs[cdKey];
+        if (current == null) {
+            this.classDefs[cdKey] = classDefinition;
+            return classDefinition;
+        }
+        if (!current.equals(classDefinition)) {
+            throw new HazelcastError_1.HazelcastSerializationError("Incompatible class definition with same class id:\n             " + classDefinition.getClassId());
+        }
+        return classDefinition;
+    };
+    return ClassDefinitionContext;
+}());
+exports.ClassDefinitionContext = ClassDefinitionContext;

package/lib/serialization/portable/ClassDefinitionWriter.d.ts

@@ -0,0 +1,35 @@
+/// <reference types="long" />
+import { PortableWriter } from './PortableSerializer';
+import { ClassDefinition } from './ClassDefinition';
+import { PortableContext } from './PortableContext';
+import { Portable } from '../Serializable';
+import * as Long from 'long';
+import { ClassDefinitionBuilder } from './ClassDefinitionBuilder';
+export declare class ClassDefinitionWriter implements PortableWriter {
+    private context;
+    private builder;
+    constructor(context: PortableContext, builder: ClassDefinitionBuilder);
+    writeInt(fieldName: string, value: number): void;
+    writeLong(fieldName: string, long: Long): void;
+    writeUTF(fieldName: string, str: string): void;
+    writeBoolean(fieldName: string, value: boolean): void;
+    writeByte(fieldName: string, value: number): void;
+    writeChar(fieldName: string, char: string): void;
+    writeDouble(fieldName: string, double: number): void;
+    writeFloat(fieldName: string, float: number): void;
+    writeShort(fieldName: string, value: number): void;
+    writePortable(fieldName: string, portable: Portable): void;
+    writeNullPortable(fieldName: string, factoryId: number, classId: number): void;
+    writeByteArray(fieldName: string, bytes: number[]): void;
+    writeBooleanArray(fieldName: string, booleans: boolean[]): void;
+    writeCharArray(fieldName: string, chars: string[]): void;
+    writeIntArray(fieldName: string, ints: number[]): void;
+    writeLongArray(fieldName: string, longs: Long[]): void;
+    writeDoubleArray(fieldName: string, doubles: number[]): void;
+    writeFloatArray(fieldName: string, floats: number[]): void;
+    writeShortArray(fieldName: string, shorts: number[]): void;
+    writeUTFArray(fieldName: string, val: string[]): void;
+    writePortableArray(fieldName: string, portables: Portable[]): void;
+    registerAndGet(): ClassDefinition;
+    private createNestedClassDef(portable, nestedBuilder);
+}

package/lib/serialization/portable/ClassDefinitionWriter.js

@@ -0,0 +1,123 @@
+"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 });
+var ClassDefinitionBuilder_1 = require("./ClassDefinitionBuilder");
+var HazelcastError_1 = require("../../HazelcastError");
+var ClassDefinitionWriter = /** @class */ (function () {
+    function ClassDefinitionWriter(context, builder) {
+        this.context = context;
+        this.builder = builder;
+    }
+    ClassDefinitionWriter.prototype.writeInt = function (fieldName, value) {
+        this.builder.addIntField(fieldName);
+    };
+    ClassDefinitionWriter.prototype.writeLong = function (fieldName, long) {
+        this.builder.addLongField(fieldName);
+    };
+    ClassDefinitionWriter.prototype.writeUTF = function (fieldName, str) {
+        this.builder.addUTFField(fieldName);
+    };
+    ClassDefinitionWriter.prototype.writeBoolean = function (fieldName, value) {
+        this.builder.addBooleanField(fieldName);
+    };
+    ClassDefinitionWriter.prototype.writeByte = function (fieldName, value) {
+        this.builder.addByteField(fieldName);
+    };
+    ClassDefinitionWriter.prototype.writeChar = function (fieldName, char) {
+        this.builder.addCharField(fieldName);
+    };
+    ClassDefinitionWriter.prototype.writeDouble = function (fieldName, double) {
+        this.builder.addDoubleField(fieldName);
+    };
+    ClassDefinitionWriter.prototype.writeFloat = function (fieldName, float) {
+        this.builder.addFloatField(fieldName);
+    };
+    ClassDefinitionWriter.prototype.writeShort = function (fieldName, value) {
+        this.builder.addShortField(fieldName);
+    };
+    ClassDefinitionWriter.prototype.writePortable = function (fieldName, portable) {
+        if (portable == null) {
+            throw new HazelcastError_1.HazelcastSerializationError('Cannot write null portable without explicitly '
+                + 'registering class definition!');
+        }
+        var version = this.context.getClassVersion(portable);
+        var nestedClassDef = this.createNestedClassDef(portable, new ClassDefinitionBuilder_1.ClassDefinitionBuilder(portable.getFactoryId(), portable.getClassId(), version));
+        this.builder.addPortableField(fieldName, nestedClassDef);
+    };
+    ClassDefinitionWriter.prototype.writeNullPortable = function (fieldName, factoryId, classId) {
+        var nestedClassDef = this.context.lookupClassDefinition(factoryId, classId, this.context.getVersion());
+        if (nestedClassDef == null) {
+            throw new HazelcastError_1.HazelcastSerializationError('Cannot write null portable without explicitly '
+                + 'registering class definition!');
+        }
+        this.builder.addPortableField(fieldName, nestedClassDef);
+    };
+    ClassDefinitionWriter.prototype.writeByteArray = function (fieldName, bytes) {
+        this.builder.addByteArrayField(fieldName);
+    };
+    ClassDefinitionWriter.prototype.writeBooleanArray = function (fieldName, booleans) {
+        this.builder.addBooleanArrayField(fieldName);
+    };
+    ClassDefinitionWriter.prototype.writeCharArray = function (fieldName, chars) {
+        this.builder.addCharArrayField(fieldName);
+    };
+    ClassDefinitionWriter.prototype.writeIntArray = function (fieldName, ints) {
+        this.builder.addIntArrayField(fieldName);
+    };
+    ClassDefinitionWriter.prototype.writeLongArray = function (fieldName, longs) {
+        this.builder.addLongArrayField(fieldName);
+    };
+    ClassDefinitionWriter.prototype.writeDoubleArray = function (fieldName, doubles) {
+        this.builder.addDoubleArrayField(fieldName);
+    };
+    ClassDefinitionWriter.prototype.writeFloatArray = function (fieldName, floats) {
+        this.builder.addFloatArrayField(fieldName);
+    };
+    ClassDefinitionWriter.prototype.writeShortArray = function (fieldName, shorts) {
+        this.builder.addShortArrayField(fieldName);
+    };
+    ClassDefinitionWriter.prototype.writeUTFArray = function (fieldName, val) {
+        this.builder.addUTFArrayField(fieldName);
+    };
+    ClassDefinitionWriter.prototype.writePortableArray = function (fieldName, portables) {
+        if (portables == null || portables.length === 0) {
+            throw new HazelcastError_1.HazelcastSerializationError('Cannot write null portable array without explicitly '
+                + 'registering class definition!');
+        }
+        var p = portables[0];
+        var classId = p.getClassId();
+        for (var i = 1; i < portables.length; i++) {
+            if (portables[i].getClassId() !== classId) {
+                throw new RangeError('Detected different class-ids in portable array!');
+            }
+        }
+        var version = this.context.getClassVersion(p);
+        var nestedClassDef = this.createNestedClassDef(p, new ClassDefinitionBuilder_1.ClassDefinitionBuilder(p.getFactoryId(), p.getClassId(), version));
+        this.builder.addPortableArrayField(fieldName, nestedClassDef);
+    };
+    ClassDefinitionWriter.prototype.registerAndGet = function () {
+        var cd = this.builder.build();
+        return this.context.registerClassDefinition(cd);
+    };
+    ClassDefinitionWriter.prototype.createNestedClassDef = function (portable, nestedBuilder) {
+        var writer = new ClassDefinitionWriter(this.context, nestedBuilder);
+        portable.writePortable(writer);
+        return this.context.registerClassDefinition(nestedBuilder.build());
+    };
+    return ClassDefinitionWriter;
+}());
+exports.ClassDefinitionWriter = ClassDefinitionWriter;

package/lib/serialization/portable/DefaultPortableReader.d.ts

@@ -0,0 +1,43 @@
+/// <reference types="long" />
+import * as Long from 'long';
+import { DataInput } from '../Data';
+import { Portable } from '../Serializable';
+import { ClassDefinition, FieldType } from './ClassDefinition';
+import { PortableReader, PortableSerializer } from './PortableSerializer';
+export declare class DefaultPortableReader implements PortableReader {
+    protected serializer: PortableSerializer;
+    protected input: DataInput;
+    protected classDefinition: ClassDefinition;
+    private offset;
+    private finalPos;
+    private raw;
+    constructor(serializer: PortableSerializer, input: DataInput, classDefinition: ClassDefinition);
+    getVersion(): number;
+    hasField(fieldName: string): boolean;
+    getFieldNames(): string[];
+    getFieldType(fieldName: string): FieldType;
+    readInt(fieldName: string): number;
+    readLong(fieldName: string): Long;
+    readUTF(fieldName: string): string;
+    readBoolean(fieldName: string): boolean;
+    readByte(fieldName: string): number;
+    readChar(fieldName: string): string;
+    readDouble(fieldName: string): number;
+    readFloat(fieldName: string): number;
+    readShort(fieldName: string): number;
+    readPortable(fieldName: string): Portable;
+    readByteArray(fieldName: string): number[];
+    readBooleanArray(fieldName: string): boolean[];
+    readCharArray(fieldName: string): string[];
+    readIntArray(fieldName: string): number[];
+    readLongArray(fieldName: string): Long[];
+    readDoubleArray(fieldName: string): number[];
+    readFloatArray(fieldName: string): number[];
+    readShortArray(fieldName: string): number[];
+    readUTFArray(fieldName: string): string[];
+    readPortableArray(fieldName: string): Portable[];
+    getRawDataInput(): DataInput;
+    end(): void;
+    private positionByFieldDefinition(field);
+    private positionByField(fieldName, fieldType);
+}

package/lib/serialization/portable/DefaultPortableReader.js

@@ -0,0 +1,188 @@
+"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 });
+var BitsUtil_1 = require("../../BitsUtil");
+var HazelcastError_1 = require("../../HazelcastError");
+var ClassDefinition_1 = require("./ClassDefinition");
+var DefaultPortableReader = /** @class */ (function () {
+    function DefaultPortableReader(serializer, input, classDefinition) {
+        this.raw = false;
+        this.serializer = serializer;
+        this.input = input;
+        this.classDefinition = classDefinition;
+        this.finalPos = this.input.readInt();
+        var fieldCount = this.input.readInt();
+        this.offset = this.input.position();
+    }
+    DefaultPortableReader.prototype.getVersion = function () {
+        return this.classDefinition.getVersion();
+    };
+    DefaultPortableReader.prototype.hasField = function (fieldName) {
+        return this.classDefinition.hasField(fieldName);
+    };
+    DefaultPortableReader.prototype.getFieldNames = function () {
+        throw new ReferenceError('Not implemented!');
+    };
+    DefaultPortableReader.prototype.getFieldType = function (fieldName) {
+        return this.classDefinition.getFieldType(fieldName);
+    };
+    DefaultPortableReader.prototype.readInt = function (fieldName) {
+        var pos = this.positionByField(fieldName, ClassDefinition_1.FieldType.INT);
+        return this.input.readInt(pos);
+    };
+    DefaultPortableReader.prototype.readLong = function (fieldName) {
+        var pos = this.positionByField(fieldName, ClassDefinition_1.FieldType.LONG);
+        return this.input.readLong(pos);
+    };
+    DefaultPortableReader.prototype.readUTF = function (fieldName) {
+        var pos = this.positionByField(fieldName, ClassDefinition_1.FieldType.UTF);
+        return this.input.readUTF(pos);
+    };
+    DefaultPortableReader.prototype.readBoolean = function (fieldName) {
+        var pos = this.positionByField(fieldName, ClassDefinition_1.FieldType.BOOLEAN);
+        return this.input.readBoolean(pos);
+    };
+    DefaultPortableReader.prototype.readByte = function (fieldName) {
+        var pos = this.positionByField(fieldName, ClassDefinition_1.FieldType.BYTE);
+        return this.input.readByte(pos);
+    };
+    DefaultPortableReader.prototype.readChar = function (fieldName) {
+        var pos = this.positionByField(fieldName, ClassDefinition_1.FieldType.CHAR);
+        return this.input.readChar(pos);
+    };
+    DefaultPortableReader.prototype.readDouble = function (fieldName) {
+        var pos = this.positionByField(fieldName, ClassDefinition_1.FieldType.DOUBLE);
+        return this.input.readDouble(pos);
+    };
+    DefaultPortableReader.prototype.readFloat = function (fieldName) {
+        var pos = this.positionByField(fieldName, ClassDefinition_1.FieldType.FLOAT);
+        return this.input.readFloat(pos);
+    };
+    DefaultPortableReader.prototype.readShort = function (fieldName) {
+        var pos = this.positionByField(fieldName, ClassDefinition_1.FieldType.SHORT);
+        return this.input.readShort(pos);
+    };
+    DefaultPortableReader.prototype.readPortable = function (fieldName) {
+        var backupPos = this.input.position();
+        try {
+            var pos = this.positionByField(fieldName, ClassDefinition_1.FieldType.PORTABLE);
+            this.input.position(pos);
+            var isNull = this.input.readBoolean();
+            var factoryId = this.input.readInt();
+            var classId = this.input.readInt();
+            if (isNull) {
+                return null;
+            }
+            else {
+                return this.serializer.readObject(this.input, factoryId, classId);
+            }
+        }
+        finally {
+            this.input.position(backupPos);
+        }
+    };
+    DefaultPortableReader.prototype.readByteArray = function (fieldName) {
+        var pos = this.positionByField(fieldName, ClassDefinition_1.FieldType.BYTE_ARRAY);
+        return this.input.readByteArray(pos);
+    };
+    DefaultPortableReader.prototype.readBooleanArray = function (fieldName) {
+        var pos = this.positionByField(fieldName, ClassDefinition_1.FieldType.BOOLEAN_ARRAY);
+        return this.input.readBooleanArray(pos);
+    };
+    DefaultPortableReader.prototype.readCharArray = function (fieldName) {
+        var pos = this.positionByField(fieldName, ClassDefinition_1.FieldType.CHAR_ARRAY);
+        return this.input.readCharArray(pos);
+    };
+    DefaultPortableReader.prototype.readIntArray = function (fieldName) {
+        var pos = this.positionByField(fieldName, ClassDefinition_1.FieldType.INT_ARRAY);
+        return this.input.readIntArray(pos);
+    };
+    DefaultPortableReader.prototype.readLongArray = function (fieldName) {
+        var pos = this.positionByField(fieldName, ClassDefinition_1.FieldType.LONG_ARRAY);
+        return this.input.readLongArray(pos);
+    };
+    DefaultPortableReader.prototype.readDoubleArray = function (fieldName) {
+        var pos = this.positionByField(fieldName, ClassDefinition_1.FieldType.DOUBLE_ARRAY);
+        return this.input.readDoubleArray(pos);
+    };
+    DefaultPortableReader.prototype.readFloatArray = function (fieldName) {
+        var pos = this.positionByField(fieldName, ClassDefinition_1.FieldType.FLOAT_ARRAY);
+        return this.input.readFloatArray(pos);
+    };
+    DefaultPortableReader.prototype.readShortArray = function (fieldName) {
+        var pos = this.positionByField(fieldName, ClassDefinition_1.FieldType.SHORT_ARRAY);
+        return this.input.readShortArray(pos);
+    };
+    DefaultPortableReader.prototype.readUTFArray = function (fieldName) {
+        var pos = this.positionByField(fieldName, ClassDefinition_1.FieldType.UTF_ARRAY);
+        return this.input.readUTFArray(pos);
+    };
+    DefaultPortableReader.prototype.readPortableArray = function (fieldName) {
+        var backupPos = this.input.position();
+        try {
+            var pos = this.positionByField(fieldName, ClassDefinition_1.FieldType.PORTABLE_ARRAY);
+            this.input.position(pos);
+            var len = this.input.readInt();
+            var factoryId = this.input.readInt();
+            var classId = this.input.readInt();
+            if (len === BitsUtil_1.BitsUtil.NULL_ARRAY_LENGTH) {
+                return null;
+            }
+            else {
+                var portables = [];
+                if (len > 0) {
+                    var offset = this.input.position();
+                    for (var i = 0; i < len; i++) {
+                        var start = this.input.readInt(offset + i * BitsUtil_1.BitsUtil.INT_SIZE_IN_BYTES);
+                        this.input.position(start);
+                        portables[i] = this.serializer.readObject(this.input, factoryId, classId);
+                    }
+                }
+                return portables;
+            }
+        }
+        finally {
+            this.input.position(backupPos);
+        }
+    };
+    DefaultPortableReader.prototype.getRawDataInput = function () {
+        var pos;
+        if (!this.raw) {
+            pos = this.input.readInt(this.offset + this.classDefinition.getFieldCount() * BitsUtil_1.BitsUtil.INT_SIZE_IN_BYTES);
+            this.input.position(pos);
+            this.raw = true;
+        }
+        return this.input;
+    };
+    DefaultPortableReader.prototype.end = function () {
+        this.input.position(this.finalPos);
+    };
+    DefaultPortableReader.prototype.positionByFieldDefinition = function (field) {
+        if (this.raw) {
+            throw new HazelcastError_1.IllegalStateError('Cannot read portable fields after getRawDataInput called!');
+        }
+        var pos = this.input.readInt(this.offset + field.getIndex() * BitsUtil_1.BitsUtil.INT_SIZE_IN_BYTES);
+        var len = this.input.readShort(pos);
+        return pos + BitsUtil_1.BitsUtil.SHORT_SIZE_IN_BYTES + len + 1;
+    };
+    DefaultPortableReader.prototype.positionByField = function (fieldName, fieldType) {
+        var definition = this.classDefinition.getField(fieldName);
+        return this.positionByFieldDefinition(definition);
+    };
+    return DefaultPortableReader;
+}());
+exports.DefaultPortableReader = DefaultPortableReader;

package/lib/serialization/portable/DefaultPortableWriter.d.ts

@@ -0,0 +1,37 @@
+/// <reference types="long" />
+import { PortableSerializer } from './PortableSerializer';
+import { PositionalDataOutput } from '../Data';
+import { ClassDefinition } from './ClassDefinition';
+import { Portable } from '../Serializable';
+import * as Long from 'long';
+export declare class DefaultPortableWriter {
+    private serializer;
+    private output;
+    private classDefinition;
+    private offset;
+    private begin;
+    constructor(serializer: PortableSerializer, output: PositionalDataOutput, classDefinition: ClassDefinition);
+    writeInt(fieldName: string, value: number): void;
+    writeLong(fieldName: string, long: Long): void;
+    writeUTF(fieldName: string, str: string): void;
+    writeBoolean(fieldName: string, value: boolean): void;
+    writeByte(fieldName: string, value: number): void;
+    writeChar(fieldName: string, char: string): void;
+    writeDouble(fieldName: string, double: number): void;
+    writeFloat(fieldName: string, float: number): void;
+    writeShort(fieldName: string, value: number): void;
+    writePortable(fieldName: string, portable: Portable): void;
+    writeNullPortable(fieldName: string, factoryId: number, classId: number): void;
+    writeByteArray(fieldName: string, bytes: number[]): void;
+    writeBooleanArray(fieldName: string, booleans: boolean[]): void;
+    writeCharArray(fieldName: string, chars: string[]): void;
+    writeIntArray(fieldName: string, ints: number[]): void;
+    writeLongArray(fieldName: string, longs: Long[]): void;
+    writeDoubleArray(fieldName: string, doubles: number[]): void;
+    writeFloatArray(fieldName: string, floats: number[]): void;
+    writeShortArray(fieldName: string, shorts: number[]): void;
+    writeUTFArray(fieldName: string, val: string[]): void;
+    writePortableArray(fieldName: string, portables: Portable[]): void;
+    end(): void;
+    private setPosition(fieldName, fieldType);
+}