@celerispay/hazelcast-client 3.12.5

package/lib/serialization/portable/DefaultPortableWriter.js

@@ -0,0 +1,156 @@
+"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 BitsUtil_1 = require("../../BitsUtil");
+var DefaultPortableWriter = /** @class */ (function () {
+    function DefaultPortableWriter(serializer, output, classDefinition) {
+        this.serializer = serializer;
+        this.output = output;
+        this.classDefinition = classDefinition;
+        this.begin = this.output.position();
+        this.output.writeZeroBytes(4);
+        this.output.writeInt(this.classDefinition.getFieldCount());
+        this.offset = this.output.position();
+        var fieldIndexesLength = (this.classDefinition.getFieldCount() + 1) * BitsUtil_1.BitsUtil.INT_SIZE_IN_BYTES;
+        this.output.writeZeroBytes(fieldIndexesLength);
+    }
+    DefaultPortableWriter.prototype.writeInt = function (fieldName, value) {
+        this.setPosition(fieldName, ClassDefinition_1.FieldType.INT);
+        this.output.writeInt(value);
+    };
+    DefaultPortableWriter.prototype.writeLong = function (fieldName, long) {
+        this.setPosition(fieldName, ClassDefinition_1.FieldType.LONG);
+        this.output.writeLong(long);
+    };
+    DefaultPortableWriter.prototype.writeUTF = function (fieldName, str) {
+        this.setPosition(fieldName, ClassDefinition_1.FieldType.UTF);
+        this.output.writeUTF(str);
+    };
+    DefaultPortableWriter.prototype.writeBoolean = function (fieldName, value) {
+        this.setPosition(fieldName, ClassDefinition_1.FieldType.BOOLEAN);
+        this.output.writeBoolean(value);
+    };
+    DefaultPortableWriter.prototype.writeByte = function (fieldName, value) {
+        this.setPosition(fieldName, ClassDefinition_1.FieldType.BYTE);
+        this.output.writeByte(value);
+    };
+    DefaultPortableWriter.prototype.writeChar = function (fieldName, char) {
+        this.setPosition(fieldName, ClassDefinition_1.FieldType.CHAR);
+        this.output.writeChar(char);
+    };
+    DefaultPortableWriter.prototype.writeDouble = function (fieldName, double) {
+        this.setPosition(fieldName, ClassDefinition_1.FieldType.DOUBLE);
+        this.output.writeDouble(double);
+    };
+    DefaultPortableWriter.prototype.writeFloat = function (fieldName, float) {
+        this.setPosition(fieldName, ClassDefinition_1.FieldType.FLOAT);
+        this.output.writeFloat(float);
+    };
+    DefaultPortableWriter.prototype.writeShort = function (fieldName, value) {
+        this.setPosition(fieldName, ClassDefinition_1.FieldType.SHORT);
+        this.output.writeShort(value);
+    };
+    DefaultPortableWriter.prototype.writePortable = function (fieldName, portable) {
+        var fieldDefinition = this.setPosition(fieldName, ClassDefinition_1.FieldType.PORTABLE);
+        var isNullPortable = (portable == null);
+        this.output.writeBoolean(isNullPortable);
+        this.output.writeInt(fieldDefinition.getFactoryId());
+        this.output.writeInt(fieldDefinition.getClassId());
+        if (!isNullPortable) {
+            this.serializer.writeObject(this.output, portable);
+        }
+    };
+    DefaultPortableWriter.prototype.writeNullPortable = function (fieldName, factoryId, classId) {
+        this.setPosition(fieldName, ClassDefinition_1.FieldType.PORTABLE);
+        this.output.writeBoolean(true);
+        this.output.writeInt(factoryId);
+        this.output.writeInt(classId);
+    };
+    DefaultPortableWriter.prototype.writeByteArray = function (fieldName, bytes) {
+        this.setPosition(fieldName, ClassDefinition_1.FieldType.BYTE_ARRAY);
+        this.output.writeByteArray(bytes);
+    };
+    DefaultPortableWriter.prototype.writeBooleanArray = function (fieldName, booleans) {
+        this.setPosition(fieldName, ClassDefinition_1.FieldType.BOOLEAN_ARRAY);
+        this.output.writeBooleanArray(booleans);
+    };
+    DefaultPortableWriter.prototype.writeCharArray = function (fieldName, chars) {
+        this.setPosition(fieldName, ClassDefinition_1.FieldType.CHAR_ARRAY);
+        this.output.writeCharArray(chars);
+    };
+    DefaultPortableWriter.prototype.writeIntArray = function (fieldName, ints) {
+        this.setPosition(fieldName, ClassDefinition_1.FieldType.INT_ARRAY);
+        this.output.writeIntArray(ints);
+    };
+    DefaultPortableWriter.prototype.writeLongArray = function (fieldName, longs) {
+        this.setPosition(fieldName, ClassDefinition_1.FieldType.LONG_ARRAY);
+        this.output.writeLongArray(longs);
+    };
+    DefaultPortableWriter.prototype.writeDoubleArray = function (fieldName, doubles) {
+        this.setPosition(fieldName, ClassDefinition_1.FieldType.DOUBLE_ARRAY);
+        this.output.writeDoubleArray(doubles);
+    };
+    DefaultPortableWriter.prototype.writeFloatArray = function (fieldName, floats) {
+        this.setPosition(fieldName, ClassDefinition_1.FieldType.FLOAT_ARRAY);
+        this.output.writeFloatArray(floats);
+    };
+    DefaultPortableWriter.prototype.writeShortArray = function (fieldName, shorts) {
+        this.setPosition(fieldName, ClassDefinition_1.FieldType.SHORT_ARRAY);
+        this.output.writeShortArray(shorts);
+    };
+    DefaultPortableWriter.prototype.writeUTFArray = function (fieldName, val) {
+        this.setPosition(fieldName, ClassDefinition_1.FieldType.UTF_ARRAY);
+        this.output.writeUTFArray(val);
+    };
+    DefaultPortableWriter.prototype.writePortableArray = function (fieldName, portables) {
+        var innerOffset;
+        var sample;
+        var i;
+        var fieldDefinition = this.setPosition(fieldName, ClassDefinition_1.FieldType.PORTABLE_ARRAY);
+        var len = (portables == null) ? BitsUtil_1.BitsUtil.NULL_ARRAY_LENGTH : portables.length;
+        this.output.writeInt(len);
+        this.output.writeInt(fieldDefinition.getFactoryId());
+        this.output.writeInt(fieldDefinition.getClassId());
+        if (len > 0) {
+            innerOffset = this.output.position();
+            this.output.writeZeroBytes(len * 4);
+            for (i = 0; i < len; i++) {
+                sample = portables[i];
+                var posVal = this.output.position();
+                this.output.pwriteInt(innerOffset + i * BitsUtil_1.BitsUtil.INT_SIZE_IN_BYTES, posVal);
+                this.serializer.writeObject(this.output, sample);
+            }
+        }
+    };
+    DefaultPortableWriter.prototype.end = function () {
+        var position = this.output.position();
+        this.output.pwriteInt(this.begin, position);
+    };
+    DefaultPortableWriter.prototype.setPosition = function (fieldName, fieldType) {
+        var field = this.classDefinition.getField(fieldName);
+        var pos = this.output.position();
+        var index = field.getIndex();
+        this.output.pwriteInt(this.offset + index * BitsUtil_1.BitsUtil.INT_SIZE_IN_BYTES, pos);
+        this.output.writeShort(fieldName.length);
+        this.output.writeBytes(fieldName);
+        this.output.writeByte(fieldType);
+        return field;
+    };
+    return DefaultPortableWriter;
+}());
+exports.DefaultPortableWriter = DefaultPortableWriter;

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

@@ -0,0 +1,31 @@
+/// <reference types="long" />
+import { DefaultPortableReader } from './DefaultPortableReader';
+import { PortableSerializer } from './PortableSerializer';
+import { DataInput } from '../Data';
+import { ClassDefinition } from './ClassDefinition';
+import { Portable } from '../Serializable';
+import * as Long from 'long';
+export declare class MorphingPortableReader extends DefaultPortableReader {
+    constructor(portableSerializer: PortableSerializer, input: DataInput, classDefinition: ClassDefinition);
+    readInt(fieldName: string): number;
+    readLong(fieldName: string): Long;
+    readDouble(fieldName: string): number;
+    readFloat(fieldName: string): number;
+    readShort(fieldName: string): number;
+    readPortableArray(fieldName: string): Portable[];
+    readUTFArray(fieldName: string): string[];
+    readShortArray(fieldName: string): number[];
+    readFloatArray(fieldName: string): number[];
+    readDoubleArray(fieldName: string): number[];
+    readLongArray(fieldName: string): Long[];
+    readIntArray(fieldName: string): number[];
+    readCharArray(fieldName: string): string[];
+    readBooleanArray(fieldName: string): boolean[];
+    readByteArray(fieldName: string): number[];
+    readChar(fieldName: string): string;
+    readByte(fieldName: string): number;
+    readBoolean(fieldName: string): boolean;
+    readUTF(fieldName: string): string;
+    private validateCompatibleAndCall(fieldName, expectedType, superFunc);
+    private createIncompatibleClassChangeError(fd, expectedType);
+}

package/lib/serialization/portable/MorphingPortableReader.js

@@ -0,0 +1,189 @@
+"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.
+ */
+var __extends = (this && this.__extends) || (function () {
+    var extendStatics = Object.setPrototypeOf ||
+        ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+        function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
+    return function (d, b) {
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+var DefaultPortableReader_1 = require("./DefaultPortableReader");
+var ClassDefinition_1 = require("./ClassDefinition");
+var Long = require("long");
+var MorphingPortableReader = /** @class */ (function (_super) {
+    __extends(MorphingPortableReader, _super);
+    function MorphingPortableReader(portableSerializer, input, classDefinition) {
+        return _super.call(this, portableSerializer, input, classDefinition) || this;
+    }
+    MorphingPortableReader.prototype.readInt = function (fieldName) {
+        var fieldDef = this.classDefinition.getField(fieldName);
+        if (fieldDef == null) {
+            return undefined;
+        }
+        switch (fieldDef.getType()) {
+            case ClassDefinition_1.FieldType.INT:
+                return _super.prototype.readInt.call(this, fieldName);
+            case ClassDefinition_1.FieldType.BYTE:
+                return _super.prototype.readByte.call(this, fieldName);
+            case ClassDefinition_1.FieldType.CHAR:
+                return _super.prototype.readChar.call(this, fieldName).charCodeAt(0);
+            case ClassDefinition_1.FieldType.SHORT:
+                return _super.prototype.readShort.call(this, fieldName);
+            default:
+                throw this.createIncompatibleClassChangeError(fieldDef, ClassDefinition_1.FieldType.INT);
+        }
+    };
+    MorphingPortableReader.prototype.readLong = function (fieldName) {
+        var fieldDef = this.classDefinition.getField(fieldName);
+        if (fieldDef == null) {
+            return undefined;
+        }
+        switch (fieldDef.getType()) {
+            case ClassDefinition_1.FieldType.LONG:
+                return _super.prototype.readLong.call(this, fieldName);
+            case ClassDefinition_1.FieldType.INT:
+                return Long.fromNumber(_super.prototype.readInt.call(this, fieldName));
+            case ClassDefinition_1.FieldType.BYTE:
+                return Long.fromNumber(_super.prototype.readByte.call(this, fieldName));
+            case ClassDefinition_1.FieldType.CHAR:
+                return Long.fromNumber(_super.prototype.readChar.call(this, fieldName).charCodeAt(0));
+            case ClassDefinition_1.FieldType.SHORT:
+                return Long.fromNumber(_super.prototype.readShort.call(this, fieldName));
+            default:
+                throw this.createIncompatibleClassChangeError(fieldDef, ClassDefinition_1.FieldType.LONG);
+        }
+    };
+    MorphingPortableReader.prototype.readDouble = function (fieldName) {
+        var fieldDef = this.classDefinition.getField(fieldName);
+        if (fieldDef == null) {
+            return undefined;
+        }
+        switch (fieldDef.getType()) {
+            case ClassDefinition_1.FieldType.DOUBLE:
+                return _super.prototype.readDouble.call(this, fieldName);
+            case ClassDefinition_1.FieldType.LONG:
+                return _super.prototype.readLong.call(this, fieldName).toNumber();
+            case ClassDefinition_1.FieldType.FLOAT:
+                return _super.prototype.readFloat.call(this, fieldName);
+            case ClassDefinition_1.FieldType.INT:
+                return _super.prototype.readInt.call(this, fieldName);
+            case ClassDefinition_1.FieldType.BYTE:
+                return _super.prototype.readByte.call(this, fieldName);
+            case ClassDefinition_1.FieldType.CHAR:
+                return _super.prototype.readChar.call(this, fieldName).charCodeAt(0);
+            case ClassDefinition_1.FieldType.SHORT:
+                return _super.prototype.readShort.call(this, fieldName);
+            default:
+                throw this.createIncompatibleClassChangeError(fieldDef, ClassDefinition_1.FieldType.DOUBLE);
+        }
+    };
+    MorphingPortableReader.prototype.readFloat = function (fieldName) {
+        var fieldDef = this.classDefinition.getField(fieldName);
+        if (fieldDef == null) {
+            return undefined;
+        }
+        switch (fieldDef.getType()) {
+            case ClassDefinition_1.FieldType.FLOAT:
+                return _super.prototype.readFloat.call(this, fieldName);
+            case ClassDefinition_1.FieldType.INT:
+                return _super.prototype.readInt.call(this, fieldName);
+            case ClassDefinition_1.FieldType.BYTE:
+                return _super.prototype.readByte.call(this, fieldName);
+            case ClassDefinition_1.FieldType.CHAR:
+                return _super.prototype.readChar.call(this, fieldName).charCodeAt(0);
+            case ClassDefinition_1.FieldType.SHORT:
+                return _super.prototype.readShort.call(this, fieldName);
+            default:
+                throw this.createIncompatibleClassChangeError(fieldDef, ClassDefinition_1.FieldType.FLOAT);
+        }
+    };
+    MorphingPortableReader.prototype.readShort = function (fieldName) {
+        var fieldDef = this.classDefinition.getField(fieldName);
+        if (fieldDef == null) {
+            return undefined;
+        }
+        switch (fieldDef.getType()) {
+            case ClassDefinition_1.FieldType.BYTE:
+                return _super.prototype.readByte.call(this, fieldName);
+            case ClassDefinition_1.FieldType.SHORT:
+                return _super.prototype.readShort.call(this, fieldName);
+            default:
+                throw this.createIncompatibleClassChangeError(fieldDef, ClassDefinition_1.FieldType.SHORT);
+        }
+    };
+    MorphingPortableReader.prototype.readPortableArray = function (fieldName) {
+        return this.validateCompatibleAndCall(fieldName, ClassDefinition_1.FieldType.PORTABLE_ARRAY, _super.prototype.readPortableArray);
+    };
+    MorphingPortableReader.prototype.readUTFArray = function (fieldName) {
+        return this.validateCompatibleAndCall(fieldName, ClassDefinition_1.FieldType.UTF_ARRAY, _super.prototype.readUTFArray);
+    };
+    MorphingPortableReader.prototype.readShortArray = function (fieldName) {
+        return this.validateCompatibleAndCall(fieldName, ClassDefinition_1.FieldType.SHORT_ARRAY, _super.prototype.readShortArray);
+    };
+    MorphingPortableReader.prototype.readFloatArray = function (fieldName) {
+        return this.validateCompatibleAndCall(fieldName, ClassDefinition_1.FieldType.FLOAT_ARRAY, _super.prototype.readFloatArray);
+    };
+    MorphingPortableReader.prototype.readDoubleArray = function (fieldName) {
+        return this.validateCompatibleAndCall(fieldName, ClassDefinition_1.FieldType.DOUBLE_ARRAY, _super.prototype.readDoubleArray);
+    };
+    MorphingPortableReader.prototype.readLongArray = function (fieldName) {
+        return this.validateCompatibleAndCall(fieldName, ClassDefinition_1.FieldType.LONG_ARRAY, _super.prototype.readLongArray);
+    };
+    MorphingPortableReader.prototype.readIntArray = function (fieldName) {
+        return this.validateCompatibleAndCall(fieldName, ClassDefinition_1.FieldType.INT_ARRAY, _super.prototype.readIntArray);
+    };
+    MorphingPortableReader.prototype.readCharArray = function (fieldName) {
+        return this.validateCompatibleAndCall(fieldName, ClassDefinition_1.FieldType.CHAR_ARRAY, _super.prototype.readCharArray);
+    };
+    MorphingPortableReader.prototype.readBooleanArray = function (fieldName) {
+        return this.validateCompatibleAndCall(fieldName, ClassDefinition_1.FieldType.BOOLEAN_ARRAY, _super.prototype.readBooleanArray);
+    };
+    MorphingPortableReader.prototype.readByteArray = function (fieldName) {
+        return this.validateCompatibleAndCall(fieldName, ClassDefinition_1.FieldType.BYTE_ARRAY, _super.prototype.readByteArray);
+    };
+    MorphingPortableReader.prototype.readChar = function (fieldName) {
+        return this.validateCompatibleAndCall(fieldName, ClassDefinition_1.FieldType.CHAR, _super.prototype.readChar);
+    };
+    MorphingPortableReader.prototype.readByte = function (fieldName) {
+        return this.validateCompatibleAndCall(fieldName, ClassDefinition_1.FieldType.BYTE, _super.prototype.readByte);
+    };
+    MorphingPortableReader.prototype.readBoolean = function (fieldName) {
+        return this.validateCompatibleAndCall(fieldName, ClassDefinition_1.FieldType.BOOLEAN, _super.prototype.readBoolean);
+    };
+    MorphingPortableReader.prototype.readUTF = function (fieldName) {
+        return this.validateCompatibleAndCall(fieldName, ClassDefinition_1.FieldType.UTF, _super.prototype.readUTF);
+    };
+    MorphingPortableReader.prototype.validateCompatibleAndCall = function (fieldName, expectedType, superFunc) {
+        var fd = this.classDefinition.getField(fieldName);
+        if (fd === null) {
+            return undefined;
+        }
+        if (fd.getType() !== expectedType) {
+            throw this.createIncompatibleClassChangeError(fd, expectedType);
+        }
+        return superFunc.call(this, fieldName);
+    };
+    MorphingPortableReader.prototype.createIncompatibleClassChangeError = function (fd, expectedType) {
+        return new TypeError("Incompatible to read " + expectedType + " from " + fd.getType() + " while reading field : " + fd.getName());
+    };
+    return MorphingPortableReader;
+}(DefaultPortableReader_1.DefaultPortableReader));
+exports.MorphingPortableReader = MorphingPortableReader;

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

@@ -0,0 +1,16 @@
+import { SerializationService } from '../SerializationService';
+import { DataInput } from '../Data';
+import { ClassDefinition } from './ClassDefinition';
+import { Portable, VersionedPortable } from '../Serializable';
+export declare class PortableContext {
+    private service;
+    private version;
+    private classDefContext;
+    constructor(service: SerializationService, portableVersion: number);
+    getVersion(): number;
+    readClassDefinitionFromInput(input: DataInput, factoryId: number, classId: number, version: number): ClassDefinition;
+    lookupOrRegisterClassDefinition(p: Portable): ClassDefinition;
+    lookupClassDefinition(factoryId: number, classId: number, version: number): ClassDefinition;
+    registerClassDefinition(classDefinition: ClassDefinition): ClassDefinition;
+    getClassVersion(portable: VersionedPortable | Portable): number;
+}

package/lib/serialization/portable/PortableContext.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 ClassDefinitionContext_1 = require("./ClassDefinitionContext");
+var ClassDefinition_1 = require("./ClassDefinition");
+var ClassDefinitionWriter_1 = require("./ClassDefinitionWriter");
+var BitsUtil_1 = require("../../BitsUtil");
+var ClassDefinitionBuilder_1 = require("./ClassDefinitionBuilder");
+var PortableContext = /** @class */ (function () {
+    function PortableContext(service, portableVersion) {
+        this.service = service;
+        this.version = portableVersion;
+        this.classDefContext = {};
+    }
+    PortableContext.prototype.getVersion = function () {
+        return this.version;
+    };
+    PortableContext.prototype.readClassDefinitionFromInput = function (input, factoryId, classId, version) {
+        var register = true;
+        var builder = new ClassDefinitionBuilder_1.ClassDefinitionBuilder(factoryId, classId, version);
+        input.readInt();
+        var fieldCount = input.readInt();
+        var offset = input.position();
+        for (var i = 0; i < fieldCount; i++) {
+            var pos = input.readInt(offset + i * BitsUtil_1.BitsUtil.INT_SIZE_IN_BYTES);
+            input.position(pos);
+            var len = input.readShort();
+            var chars = '';
+            for (var j = 0; j < len; j++) {
+                chars += String.fromCharCode(input.readUnsignedByte());
+            }
+            var type = input.readByte();
+            var name = chars;
+            var fieldFactoryId = 0;
+            var fieldClassId = 0;
+            var fieldVersion = this.version;
+            if (type === ClassDefinition_1.FieldType.PORTABLE) {
+                // is null
+                if (input.readBoolean()) {
+                    register = false;
+                }
+                fieldFactoryId = input.readInt();
+                fieldClassId = input.readInt();
+                // TODO: what there's a null inner Portable field
+                if (register) {
+                    fieldVersion = input.readInt();
+                    this.readClassDefinitionFromInput(input, fieldFactoryId, fieldClassId, fieldVersion);
+                }
+            }
+            else if (type === ClassDefinition_1.FieldType.PORTABLE_ARRAY) {
+                var k = input.readInt();
+                fieldFactoryId = input.readInt();
+                fieldClassId = input.readInt();
+                // TODO: what there's a null inner Portable field
+                if (k > 0) {
+                    var p = input.readInt();
+                    input.position(p);
+                    fieldVersion = input.readInt();
+                    this.readClassDefinitionFromInput(input, fieldFactoryId, fieldClassId, fieldVersion);
+                }
+                else {
+                    register = false;
+                }
+            }
+            builder.addField(new ClassDefinition_1.FieldDefinition(i, name, type, fieldVersion, fieldFactoryId, fieldClassId));
+        }
+        var classDefinition = builder.build();
+        if (register) {
+            classDefinition = this.registerClassDefinition(classDefinition);
+        }
+        return classDefinition;
+    };
+    PortableContext.prototype.lookupOrRegisterClassDefinition = function (p) {
+        var portableVersion = this.getClassVersion(p);
+        var cd = this.lookupClassDefinition(p.getFactoryId(), p.getClassId(), portableVersion);
+        if (cd == null) {
+            var writer = new ClassDefinitionWriter_1.ClassDefinitionWriter(this, new ClassDefinitionBuilder_1.ClassDefinitionBuilder(p.getFactoryId(), p.getClassId(), portableVersion));
+            p.writePortable(writer);
+            cd = writer.registerAndGet();
+        }
+        return cd;
+    };
+    PortableContext.prototype.lookupClassDefinition = function (factoryId, classId, version) {
+        var factory = this.classDefContext[factoryId];
+        if (factory == null) {
+            return null;
+        }
+        else {
+            return factory.lookup(classId, version);
+        }
+    };
+    PortableContext.prototype.registerClassDefinition = function (classDefinition) {
+        var factoryId = classDefinition.getFactoryId();
+        if (!this.classDefContext[factoryId]) {
+            this.classDefContext[factoryId] = new ClassDefinitionContext_1.ClassDefinitionContext(factoryId);
+        }
+        return this.classDefContext[factoryId].register(classDefinition);
+    };
+    PortableContext.prototype.getClassVersion = function (portable) {
+        if (portable.getVersion) {
+            if (portable.getVersion() < 0) {
+                throw new RangeError('Version cannot be negative!');
+            }
+            return portable.getVersion();
+        }
+        else {
+            return this.version;
+        }
+    };
+    return PortableContext;
+}());
+exports.PortableContext = PortableContext;

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

@@ -0,0 +1,68 @@
+/// <reference types="long" />
+import { SerializationService, Serializer } from '../SerializationService';
+import { Portable } from '../Serializable';
+import { DataInput, PositionalDataOutput } from '../Data';
+import { FieldType } from './ClassDefinition';
+import * as Long from 'long';
+import { SerializationConfig } from '../../config/SerializationConfig';
+export declare class PortableSerializer implements Serializer {
+    private portableContext;
+    private factories;
+    private service;
+    constructor(service: SerializationService, serializationConfig: SerializationConfig);
+    getId(): number;
+    read(input: DataInput): any;
+    readObject(input: DataInput, factoryId: number, classId: number): Portable;
+    write(output: PositionalDataOutput, object: Portable): void;
+    writeObject(output: PositionalDataOutput, object: Portable): void;
+    private createNewPortableInstance(factoryId, classId);
+}
+export interface PortableWriter {
+    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;
+}
+export interface PortableReader {
+    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[];
+}