ignite-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From akuznet...@apache.org
Subject [30/66] [abbrv] ignite git commit: Merge branch ignite-1282 into ignite-950-new
Date Thu, 05 Nov 2015 03:28:22 GMT
Merge branch ignite-1282  into ignite-950-new


Project: http://git-wip-us.apache.org/repos/asf/ignite/repo
Commit: http://git-wip-us.apache.org/repos/asf/ignite/commit/c050b4ce
Tree: http://git-wip-us.apache.org/repos/asf/ignite/tree/c050b4ce
Diff: http://git-wip-us.apache.org/repos/asf/ignite/diff/c050b4ce

Branch: refs/heads/ignite-1753-1282
Commit: c050b4ce6cb27fce48e0cae1f9a78f99c7d6ee3f
Parents: 7b9136e 845c4f2
Author: Alexey Goncharuk <alexey.goncharuk@gmail.com>
Authored: Tue Nov 3 13:30:14 2015 +0300
Committer: Alexey Goncharuk <alexey.goncharuk@gmail.com>
Committed: Tue Nov 3 13:30:14 2015 +0300

----------------------------------------------------------------------
 .gitignore                                      |   7 +
 .../internal/portable/BinaryFieldImpl.java      |  10 +-
 .../internal/portable/BinaryObjectEx.java       |   2 +-
 .../internal/portable/BinaryObjectImpl.java     |  46 ++-
 .../portable/BinaryObjectOffheapImpl.java       |  89 +++++-
 .../internal/portable/BinaryReaderExImpl.java   |  43 +--
 .../internal/portable/BinaryWriterExImpl.java   |  76 ++++-
 .../portable/PortableClassDescriptor.java       |  33 ++-
 .../internal/portable/PortableSchema.java       | 133 ++++-----
 .../ignite/internal/portable/PortableUtils.java |  46 ++-
 .../builder/BinaryObjectBuilderImpl.java        | 283 ++++++++++---------
 .../src/portable_reader_writer_test.cpp         | 251 +++++++++++++---
 .../ignite/impl/interop/interop_input_stream.h  |  16 ++
 .../ignite/impl/interop/interop_output_stream.h |   8 +
 .../ignite/impl/portable/portable_common.h      |   6 +
 .../ignite/impl/portable/portable_reader_impl.h |  29 +-
 .../ignite/impl/portable/portable_schema.h      |  26 +-
 .../src/impl/interop/interop_input_stream.cpp   |  20 ++
 .../src/impl/interop/interop_output_stream.cpp  |   7 +
 .../src/impl/portable/portable_reader_impl.cpp  |  45 ++-
 .../core/src/impl/portable/portable_schema.cpp  |  53 +++-
 .../src/impl/portable/portable_writer_impl.cpp  |  21 +-
 .../Portable/PortableSelfTest.cs                |  32 +++
 .../Impl/Common/ResizeableArray.cs              |  14 +-
 .../Apache.Ignite.Core/Impl/ExceptionUtils.cs   |   2 -
 .../Impl/Portable/PortableBuilderImpl.cs        |   8 +-
 .../Impl/Portable/PortableObjectHeader.cs       | 196 ++++++++++---
 .../Impl/Portable/PortableObjectSchema.cs       |   6 +-
 .../Impl/Portable/PortableObjectSchemaField.cs  |  69 +----
 .../Impl/Portable/PortableReaderImpl.cs         | 113 +++-----
 .../Impl/Portable/PortableUtils.cs              |   4 +-
 .../Impl/Portable/PortableWriterImpl.cs         |   7 +-
 .../Impl/Portable/PortablesImpl.cs              |   2 +-
 .../Impl/Unmanaged/UnmanagedCallbackHandlers.cs |   2 +-
 34 files changed, 1146 insertions(+), 559 deletions(-)
----------------------------------------------------------------------


http://git-wip-us.apache.org/repos/asf/ignite/blob/c050b4ce/modules/core/src/main/java/org/apache/ignite/internal/portable/BinaryFieldImpl.java
----------------------------------------------------------------------
diff --cc modules/core/src/main/java/org/apache/ignite/internal/portable/BinaryFieldImpl.java
index da60a8b,0000000..ac0b353
mode 100644,000000..100644
--- a/modules/core/src/main/java/org/apache/ignite/internal/portable/BinaryFieldImpl.java
+++ b/modules/core/src/main/java/org/apache/ignite/internal/portable/BinaryFieldImpl.java
@@@ -1,82 -1,0 +1,82 @@@
 +/*
 + * Licensed to the Apache Software Foundation (ASF) under one or more
 + * contributor license agreements.  See the NOTICE file distributed with
 + * this work for additional information regarding copyright ownership.
 + * The ASF licenses this file to You 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.
 + */
 +
 +package org.apache.ignite.internal.portable;
 +
 +import org.apache.ignite.binary.BinaryObject;
 +import org.apache.ignite.binary.BinaryField;
 +
 +/**
 + * Implementation of portable field descriptor.
 + */
 +public class BinaryFieldImpl implements BinaryField {
 +    /** Well-known object schemas. */
 +    private final PortableSchemaRegistry schemas;
 +
 +    /** Pre-calculated field ID. */
 +    private final int fieldId;
 +
 +    /**
 +     * Constructor.
 +     *
 +     * @param schemas Schemas.
 +     * @param fieldId Field ID.
 +     */
 +    public BinaryFieldImpl(PortableSchemaRegistry schemas, int fieldId) {
 +        this.schemas = schemas;
 +        this.fieldId = fieldId;
 +    }
 +
 +    /** {@inheritDoc} */
 +    @Override public boolean exists(BinaryObject obj) {
 +        BinaryObjectEx obj0 = (BinaryObjectEx)obj;
 +
-         return fieldOffset(obj0) != 0;
++        return fieldOrder(obj0) != 0;
 +    }
 +
 +    /** {@inheritDoc} */
 +    @SuppressWarnings("unchecked")
 +    @Override public <T> T value(BinaryObject obj) {
 +        BinaryObjectEx obj0 = (BinaryObjectEx)obj;
 +
-         int offset = fieldOffset(obj0);
++        int order = fieldOrder(obj0);
 +
-         return offset != 0 ? (T)obj0.fieldByOffset(offset) : null;
++        return order != 0 ? (T)obj0.fieldByOrder(order) : null;
 +    }
 +
 +    /**
 +     * Get relative field offset.
 +     *
 +     * @param obj Object.
 +     * @return Field offset.
 +     */
-     private int fieldOffset(BinaryObjectEx obj) {
++    private int fieldOrder(BinaryObjectEx obj) {
 +        int schemaId = obj.schemaId();
 +
 +        PortableSchema schema = schemas.schema(schemaId);
 +
 +        if (schema == null) {
 +            schema = obj.createSchema();
 +
 +            schemas.addSchema(schemaId, schema);
 +        }
 +
 +        assert schema != null;
 +
-         return schema.offset(fieldId);
++        return schema.order(fieldId);
 +    }
 +}

http://git-wip-us.apache.org/repos/asf/ignite/blob/c050b4ce/modules/core/src/main/java/org/apache/ignite/internal/portable/BinaryObjectEx.java
----------------------------------------------------------------------
diff --cc modules/core/src/main/java/org/apache/ignite/internal/portable/BinaryObjectEx.java
index aadaca8,0000000..bfbb997
mode 100644,000000..100644
--- a/modules/core/src/main/java/org/apache/ignite/internal/portable/BinaryObjectEx.java
+++ b/modules/core/src/main/java/org/apache/ignite/internal/portable/BinaryObjectEx.java
@@@ -1,245 -1,0 +1,245 @@@
 +/*
 + * Licensed to the Apache Software Foundation (ASF) under one or more
 + * contributor license agreements.  See the NOTICE file distributed with
 + * this work for additional information regarding copyright ownership.
 + * The ASF licenses this file to You 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.
 + */
 +
 +package org.apache.ignite.internal.portable;
 +
 +import java.math.BigDecimal;
 +import java.util.Arrays;
 +import java.util.IdentityHashMap;
 +import org.apache.ignite.IgniteException;
 +import org.apache.ignite.internal.util.offheap.unsafe.GridUnsafeMemory;
 +import org.apache.ignite.internal.util.typedef.internal.SB;
 +import org.apache.ignite.binary.BinaryObjectException;
 +import org.apache.ignite.binary.BinaryType;
 +import org.apache.ignite.binary.BinaryObject;
 +import org.jetbrains.annotations.Nullable;
 +
 +/**
 + * Internal portable object interface.
 + */
 +public abstract class BinaryObjectEx implements BinaryObject {
 +    /**
 +     * @return Length.
 +     */
 +    public abstract int length();
 +
 +    /**
 +     * @return Object start.
 +     */
 +    public abstract int start();
 +
 +    /**
 +     * @return {@code True} if object is array based.
 +     */
 +    protected abstract boolean hasArray();
 +
 +    /**
 +     * @return Object array if object is array based, otherwise {@code null}.
 +     */
 +    public abstract byte[] array();
 +
 +    /**
 +     * @return Object offheap address is object is offheap based, otherwise 0.
 +     */
 +    public abstract long offheapAddress();
 +
 +    /**
 +     * Gets field value.
 +     *
 +     * @param fieldId Field ID.
 +     * @return Field value.
 +     * @throws org.apache.ignite.binary.BinaryObjectException In case of any other error.
 +     */
 +    @Nullable public abstract <F> F field(int fieldId) throws BinaryObjectException;
 +
 +    /**
 +     * Get field by offset.
 +     *
 +     * @param fieldOffset Field offset.
 +     * @return Field value.
 +     */
-     @Nullable protected abstract <F> F fieldByOffset(int fieldOffset);
++    @Nullable protected abstract <F> F fieldByOrder(int fieldOffset);
 +
 +    /**
 +     * @param ctx Reader context.
 +     * @param fieldName Field name.
 +     * @return Field value.
 +     */
 +    @Nullable protected abstract <F> F field(PortableReaderContext ctx, String fieldName);
 +
 +    /**
 +     * Get schema ID.
 +     *
 +     * @return Schema ID.
 +     */
 +    protected abstract int schemaId();
 +
 +    /**
 +     * Create schema for object.
 +     *
 +     * @return Schema.
 +     */
 +    protected abstract PortableSchema createSchema();
 +
 +    /** {@inheritDoc} */
 +    @Override public BinaryObject clone() throws CloneNotSupportedException {
 +        return (BinaryObject)super.clone();
 +    }
 +
 +    /** {@inheritDoc} */
 +    public boolean equals(Object other) {
 +        if (other == this)
 +            return true;
 +
 +        if (other == null)
 +            return false;
 +
 +        if (!(other instanceof BinaryObjectEx))
 +            return false;
 +
 +        BinaryObjectEx otherPo = (BinaryObjectEx)other;
 +
 +        if (length() != otherPo.length() || typeId() != otherPo.typeId())
 +            return false;
 +
 +        if (hasArray()) {
 +            if (otherPo.hasArray()) {
 +                int len = length();
 +                int end = start() + len;
 +
 +                byte[] arr = array();
 +                byte[] otherArr = otherPo.array();
 +
 +                for (int i = start(), j = otherPo.start(); i < end; i++, j++) {
 +                    if (arr[i] != otherArr[j])
 +                        return false;
 +                }
 +
 +                return true;
 +            }
 +            else {
 +                assert otherPo.offheapAddress() > 0;
 +
 +                return GridUnsafeMemory.compare(otherPo.offheapAddress() + otherPo.start(),
array());
 +            }
 +        }
 +        else {
 +            assert offheapAddress() > 0;
 +
 +            if (otherPo.hasArray())
 +                return GridUnsafeMemory.compare(offheapAddress() + start(), otherPo.array());
 +            else {
 +                assert otherPo.offheapAddress() > 0;
 +
 +                return GridUnsafeMemory.compare(offheapAddress() + start(),
 +                    otherPo.offheapAddress() + otherPo.start(),
 +                    length());
 +            }
 +        }
 +    }
 +
 +    /**
 +     * @param ctx Reader context.
 +     * @param handles Handles for already traversed objects.
 +     * @return String representation.
 +     */
 +    private String toString(PortableReaderContext ctx, IdentityHashMap<BinaryObject,
Integer> handles) {
 +        int idHash = System.identityHashCode(this);
 +
 +        BinaryType meta;
 +
 +        try {
 +            meta = metaData();
 +        }
 +        catch (BinaryObjectException ignore) {
 +            meta = null;
 +        }
 +
 +        if (meta == null)
 +            return "PortableObject [hash=" + idHash + ", typeId=" + typeId() + ']';
 +
 +        handles.put(this, idHash);
 +
 +        SB buf = new SB(meta.typeName());
 +
 +        if (meta.fields() != null) {
 +            buf.a(" [hash=").a(idHash);
 +
 +            for (String name : meta.fields()) {
 +                Object val = field(ctx, name);
 +
 +                buf.a(", ").a(name).a('=');
 +
 +                if (val instanceof byte[])
 +                    buf.a(Arrays.toString((byte[]) val));
 +                else if (val instanceof short[])
 +                    buf.a(Arrays.toString((short[])val));
 +                else if (val instanceof int[])
 +                    buf.a(Arrays.toString((int[])val));
 +                else if (val instanceof long[])
 +                    buf.a(Arrays.toString((long[])val));
 +                else if (val instanceof float[])
 +                    buf.a(Arrays.toString((float[])val));
 +                else if (val instanceof double[])
 +                    buf.a(Arrays.toString((double[])val));
 +                else if (val instanceof char[])
 +                    buf.a(Arrays.toString((char[])val));
 +                else if (val instanceof boolean[])
 +                    buf.a(Arrays.toString((boolean[]) val));
 +                else if (val instanceof BigDecimal[])
 +                    buf.a(Arrays.toString((BigDecimal[])val));
 +                else {
 +                    if (val instanceof BinaryObjectEx) {
 +                        BinaryObjectEx po = (BinaryObjectEx)val;
 +
 +                        Integer idHash0 = handles.get(val);
 +
 +                        if (idHash0 != null) {  // Circular reference.
 +                            BinaryType meta0 = po.metaData();
 +
 +                            assert meta0 != null;
 +
 +                            buf.a(meta0.typeName()).a(" [hash=").a(idHash0).a(", ...]");
 +                        }
 +                        else
 +                            buf.a(po.toString(ctx, handles));
 +                    }
 +                    else
 +                        buf.a(val);
 +                }
 +            }
 +
 +            buf.a(']');
 +        }
 +
 +        return buf.toString();
 +    }
 +
 +    /** {@inheritDoc} */
 +    @Override public String toString() {
 +        try {
 +            PortableReaderContext ctx = new PortableReaderContext();
 +
 +            ctx.setPortableHandler(start(), this);
 +
 +            return toString(ctx, new IdentityHashMap<BinaryObject, Integer>());
 +        }
 +        catch (BinaryObjectException e) {
 +            throw new IgniteException("Failed to create string representation of portable
object.", e);
 +        }
 +    }
 +}

http://git-wip-us.apache.org/repos/asf/ignite/blob/c050b4ce/modules/core/src/main/java/org/apache/ignite/internal/portable/BinaryObjectImpl.java
----------------------------------------------------------------------
diff --cc modules/core/src/main/java/org/apache/ignite/internal/portable/BinaryObjectImpl.java
index d533c22,0000000..992f92c
mode 100644,000000..100644
--- a/modules/core/src/main/java/org/apache/ignite/internal/portable/BinaryObjectImpl.java
+++ b/modules/core/src/main/java/org/apache/ignite/internal/portable/BinaryObjectImpl.java
@@@ -1,538 -1,0 +1,526 @@@
 +/*
 + * Licensed to the Apache Software Foundation (ASF) under one or more
 + * contributor license agreements.  See the NOTICE file distributed with
 + * this work for additional information regarding copyright ownership.
 + * The ASF licenses this file to You 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.
 + */
 +
 +package org.apache.ignite.internal.portable;
 +
 +import org.apache.ignite.IgniteCheckedException;
 +import org.apache.ignite.internal.GridDirectTransient;
 +import org.apache.ignite.internal.IgniteCodeGeneratingFail;
 +import org.apache.ignite.internal.portable.streams.PortableHeapInputStream;
 +import org.apache.ignite.internal.processors.cache.CacheObject;
 +import org.apache.ignite.internal.processors.cache.CacheObjectContext;
 +import org.apache.ignite.internal.processors.cache.KeyCacheObject;
 +import org.apache.ignite.internal.processors.cache.portable.CacheObjectPortableProcessorImpl;
 +import org.apache.ignite.internal.util.typedef.internal.U;
 +import org.apache.ignite.plugin.extensions.communication.Message;
 +import org.apache.ignite.plugin.extensions.communication.MessageReader;
 +import org.apache.ignite.plugin.extensions.communication.MessageWriter;
 +import org.apache.ignite.binary.BinaryObjectException;
 +import org.apache.ignite.binary.BinaryType;
 +import org.apache.ignite.binary.BinaryObject;
 +import org.apache.ignite.binary.BinaryField;
 +import org.jetbrains.annotations.Nullable;
 +
 +import java.io.Externalizable;
 +import java.io.IOException;
 +import java.io.ObjectInput;
 +import java.io.ObjectOutput;
 +import java.nio.ByteBuffer;
 +
 +import static org.apache.ignite.internal.portable.GridPortableMarshaller.BOOLEAN;
 +import static org.apache.ignite.internal.portable.GridPortableMarshaller.BYTE;
 +import static org.apache.ignite.internal.portable.GridPortableMarshaller.CHAR;
 +import static org.apache.ignite.internal.portable.GridPortableMarshaller.DOUBLE;
 +import static org.apache.ignite.internal.portable.GridPortableMarshaller.FLOAT;
 +import static org.apache.ignite.internal.portable.GridPortableMarshaller.INT;
 +import static org.apache.ignite.internal.portable.GridPortableMarshaller.LONG;
 +import static org.apache.ignite.internal.portable.GridPortableMarshaller.SHORT;
 +
 +/**
 + * Portable object implementation.
 + */
 +@IgniteCodeGeneratingFail // Fields arr and start should not be generated by MessageCodeGenerator.
 +public final class BinaryObjectImpl extends BinaryObjectEx implements Externalizable,
 +    Message, CacheObject, KeyCacheObject {
 +    /** */
 +    public static final byte TYPE_PORTABLE = 100;
 +
 +    /** */
 +    private static final long serialVersionUID = 0L;
 +
 +    /** */
 +    @GridDirectTransient
 +    private PortableContext ctx;
 +
 +    /** */
 +    private byte[] arr;
 +
 +    /** */
 +    private int start;
 +
 +    /** */
 +    @GridDirectTransient
 +    private Object obj;
 +
 +    /** */
 +    @GridDirectTransient
 +    private boolean detachAllowed;
 +
 +    /**
 +     * For {@link Externalizable}.
 +     */
 +    public BinaryObjectImpl() {
 +        // No-op.
 +    }
 +
 +    /**
 +     * @param ctx Context.
 +     * @param arr Array.
 +     * @param start Start.
 +     */
 +    public BinaryObjectImpl(PortableContext ctx, byte[] arr, int start) {
 +        assert ctx != null;
 +        assert arr != null;
 +
 +        this.ctx = ctx;
 +        this.arr = arr;
 +        this.start = start;
 +    }
 +
 +    /** {@inheritDoc} */
 +    @Override public byte type() {
 +        return TYPE_PORTABLE;
 +    }
 +
 +    /** {@inheritDoc} */
 +    @Override public boolean isPlatformType() {
 +        return false;
 +    }
 +
 +    /** {@inheritDoc} */
 +    @Override public boolean internal() {
 +        return false;
 +    }
 +
 +    /** {@inheritDoc} */
 +    @SuppressWarnings("unchecked")
 +    @Nullable @Override public <T> T value(CacheObjectContext ctx, boolean cpy) {
 +        Object obj0 = obj;
 +
 +        if (obj0 == null || cpy)
 +            obj0 = deserializeValue();
 +
 +        return (T)obj0;
 +    }
 +
 +    /** {@inheritDoc} */
 +    @Override public byte[] valueBytes(CacheObjectContext ctx) throws IgniteCheckedException
{
 +        if (detached())
 +            return array();
 +
 +        int len = length();
 +
 +        byte[] arr0 = new byte[len];
 +
 +        U.arrayCopy(arr, start, arr0, 0, len);
 +
 +        return arr0;
 +    }
 +
 +    /** {@inheritDoc} */
 +    @Override public CacheObject prepareForCache(CacheObjectContext ctx) {
 +        if (detached())
 +            return this;
 +
 +        return (BinaryObjectImpl)detach();
 +    }
 +
 +    /** {@inheritDoc} */
 +    @Override public void finishUnmarshal(CacheObjectContext ctx, ClassLoader ldr) throws
IgniteCheckedException {
 +        this.ctx = ((CacheObjectPortableProcessorImpl)ctx.processor()).portableContext();
 +    }
 +
 +    /** {@inheritDoc} */
 +    @Override public void prepareMarshal(CacheObjectContext ctx) throws IgniteCheckedException
{
 +        // No-op.
 +    }
 +
 +    /** {@inheritDoc} */
 +    @Override public int length() {
 +        return PortablePrimitives.readInt(arr, start + GridPortableMarshaller.TOTAL_LEN_POS);
 +    }
 +
 +    /**
 +     * @return Detached portable object.
 +     */
 +    public BinaryObject detach() {
 +        if (!detachAllowed || detached())
 +            return this;
 +
 +        int len = length();
 +
 +        byte[] arr0 = new byte[len];
 +
 +        U.arrayCopy(arr, start, arr0, 0, len);
 +
 +        return new BinaryObjectImpl(ctx, arr0, 0);
 +    }
 +
 +    /**
 +     * @return Detached or not.
 +     */
 +    public boolean detached() {
 +        return start == 0 && length() == arr.length;
 +    }
 +
 +    /**
 +     * @return {@code True} if detach is allowed.
 +     */
 +    public boolean detachAllowed() {
 +        return true;
 +    }
 +
 +    /**
 +     * @param detachAllowed Detach allowed flag.
 +     */
 +    public void detachAllowed(boolean detachAllowed) {
 +        this.detachAllowed = detachAllowed;
 +    }
 +
 +    /**
 +     * @return Context.
 +     */
 +    public PortableContext context() {
 +        return ctx;
 +    }
 +
 +    /**
 +     * @param ctx Context.
 +     */
 +    public void context(PortableContext ctx) {
 +        this.ctx = ctx;
 +    }
 +
 +    /** {@inheritDoc} */
 +    @Override public byte[] array() {
 +        return arr;
 +    }
 +
 +    /** {@inheritDoc} */
 +    @Override public int start() {
 +        return start;
 +    }
 +
 +    /** {@inheritDoc} */
 +    @Override public long offheapAddress() {
 +        return 0;
 +    }
 +
 +    /** {@inheritDoc} */
 +    @Override protected boolean hasArray() {
 +        return true;
 +    }
 +
 +    /** {@inheritDoc} */
 +    @Override public int typeId() {
 +        return PortablePrimitives.readInt(arr, start + GridPortableMarshaller.TYPE_ID_POS);
 +    }
 +
 +    /** {@inheritDoc} */
 +    @Nullable @Override public BinaryType metaData() throws BinaryObjectException {
 +        if (ctx == null)
 +            throw new BinaryObjectException("PortableContext is not set for the object.");
 +
 +        return ctx.metaData(typeId());
 +    }
 +
 +    /** {@inheritDoc} */
 +    @SuppressWarnings("unchecked")
 +    @Nullable @Override public <F> F field(String fieldName) throws BinaryObjectException
{
 +        BinaryReaderExImpl reader = new BinaryReaderExImpl(ctx, arr, start, null);
 +
 +        return (F)reader.unmarshalField(fieldName);
 +    }
 +
 +    /** {@inheritDoc} */
 +    @SuppressWarnings("unchecked")
 +    @Nullable @Override public <F> F field(int fieldId) throws BinaryObjectException
{
 +        BinaryReaderExImpl reader = new BinaryReaderExImpl(ctx, arr, start, null);
 +
 +        return (F)reader.unmarshalField(fieldId);
 +    }
 +
 +    /** {@inheritDoc} */
 +    @SuppressWarnings("unchecked")
-     @Nullable @Override protected <F> F fieldByOffset(int fieldOffset) {
++    @Nullable @Override protected <F> F fieldByOrder(int order) {
 +        Object val;
 +
++        // Calculate field position.
 +        int schemaOffset = PortablePrimitives.readInt(arr, start + GridPortableMarshaller.SCHEMA_OR_RAW_OFF_POS);
-         int fieldPos = PortablePrimitives.readInt(arr, start + schemaOffset + fieldOffset);
++
++        short flags = PortablePrimitives.readShort(arr, start + GridPortableMarshaller.FLAGS_POS);
++        int fieldOffsetSize = PortableUtils.fieldOffsetSize(flags);
++
++        int fieldOffsetPos = start + schemaOffset + order * (4 + fieldOffsetSize) + 4;
++
++        int fieldPos;
++
++        if (fieldOffsetSize == PortableUtils.OFFSET_1)
++            fieldPos = start + (int)PortablePrimitives.readByte(arr, fieldOffsetPos) &
0xFF;
++        else if (fieldOffsetSize == PortableUtils.OFFSET_2)
++            fieldPos = start + (int)PortablePrimitives.readShort(arr, fieldOffsetPos) &
0xFFFF;
++        else
++            fieldPos = start + PortablePrimitives.readInt(arr, fieldOffsetPos);
 +
 +        // Read header and try performing fast lookup for well-known types (the most common
types go first).
 +        byte hdr = PortablePrimitives.readByte(arr, fieldPos);
 +
 +        switch (hdr) {
 +            case INT:
 +                val = PortablePrimitives.readInt(arr, fieldPos + 1);
 +
 +                break;
 +
 +            case LONG:
 +                val = PortablePrimitives.readLong(arr, fieldPos + 1);
 +
 +                break;
 +
 +            case BOOLEAN:
 +                val = PortablePrimitives.readBoolean(arr, fieldPos + 1);
 +
 +                break;
 +
 +            case SHORT:
 +                val = PortablePrimitives.readShort(arr, fieldPos + 1);
 +
 +                break;
 +
 +            case BYTE:
 +                val = PortablePrimitives.readByte(arr, fieldPos + 1);
 +
 +                break;
 +
 +            case CHAR:
 +                val = PortablePrimitives.readChar(arr, fieldPos + 1);
 +
 +                break;
 +
 +            case FLOAT:
 +                val = PortablePrimitives.readFloat(arr, fieldPos + 1);
 +
 +                break;
 +
 +            case DOUBLE:
 +                val = PortablePrimitives.readDouble(arr, fieldPos + 1);
 +
 +                break;
 +
- //            case DECIMAL:
- //                val = doReadDecimal();
- //
- //                break;
- //
- //            case STRING:
- //                val = doReadString();
- //
- //                break;
- //
- //            case UUID:
- //                val = doReadUuid();
- //
- //                break;
- //
- //            case DATE:
- //                val = doReadDate();
- //
- //                break;
- //
- //            case TIMESTAMP:
- //                val = doReadTimestamp();
- //
- //                break;
- 
 +            default: {
-                 // TODO: Pass absolute offset, not relative.
 +                BinaryReaderExImpl reader = new BinaryReaderExImpl(ctx, arr, start, null);
 +
-                 val = reader.unmarshalFieldByOffset(fieldOffset);
++                val = reader.unmarshalFieldByAbsolutePosition(fieldPos);
 +            }
 +        }
 +
 +        return (F)val;
 +    }
 +
 +    /** {@inheritDoc} */
 +    @SuppressWarnings("unchecked")
 +    @Nullable @Override protected <F> F field(PortableReaderContext rCtx, String fieldName)
{
 +        BinaryReaderExImpl reader = new BinaryReaderExImpl(ctx,
 +            new PortableHeapInputStream(arr),
 +            start,
 +            null,
 +            rCtx);
 +
 +        return (F)reader.unmarshalField(fieldName);
 +    }
 +
 +    /** {@inheritDoc} */
 +    @Override public boolean hasField(String fieldName) {
 +        BinaryReaderExImpl reader = new BinaryReaderExImpl(ctx, arr, start, null);
 +
 +        return reader.hasField(fieldName);
 +    }
 +
 +    /** {@inheritDoc} */
 +    @SuppressWarnings("unchecked")
 +    @Nullable @Override public <T> T deserialize() throws BinaryObjectException {
 +        Object obj0 = obj;
 +
 +        if (obj0 == null)
 +            obj0 = deserializeValue();
 +
 +        return (T)obj0;
 +
 +    }
 +
 +    /** {@inheritDoc} */
 +    @Override public BinaryObject clone() throws CloneNotSupportedException {
 +        return super.clone();
 +    }
 +
 +    /** {@inheritDoc} */
 +    @Override public int hashCode() {
 +        return PortablePrimitives.readInt(arr, start + GridPortableMarshaller.HASH_CODE_POS);
 +    }
 +
 +    /** {@inheritDoc} */
 +    @Override protected int schemaId() {
 +        return PortablePrimitives.readInt(arr, start + GridPortableMarshaller.SCHEMA_ID_POS);
 +    }
 +
 +    /** {@inheritDoc} */
 +    @Override protected PortableSchema createSchema() {
 +        BinaryReaderExImpl reader = new BinaryReaderExImpl(ctx, arr, start, null);
 +
 +        return reader.createSchema();
 +    }
 +
 +    /** {@inheritDoc} */
 +    @Override public BinaryField fieldDescriptor(String fieldName) throws BinaryObjectException
{
 +        int typeId = typeId();
 +
 +        PortableSchemaRegistry schemaReg = ctx.schemaRegistry(typeId);
 +
 +        int fieldId = ctx.userTypeIdMapper(typeId).fieldId(typeId, fieldName);
 +
 +        return new BinaryFieldImpl(schemaReg, fieldId);
 +    }
 +
 +    /** {@inheritDoc} */
 +    @Override public void writeExternal(ObjectOutput out) throws IOException {
 +        out.writeObject(ctx);
 +
 +        if (detachAllowed) {
 +            int len = length();
 +
 +            out.writeInt(len);
 +            out.write(arr, start, len);
 +            out.writeInt(0);
 +        }
 +        else {
 +            out.writeInt(arr.length);
 +            out.write(arr);
 +            out.writeInt(start);
 +        }
 +    }
 +
 +    /** {@inheritDoc} */
 +    @Override public void readExternal(ObjectInput in) throws IOException, ClassNotFoundException
{
 +        ctx = (PortableContext)in.readObject();
 +
 +        arr = new byte[in.readInt()];
 +
 +        in.readFully(arr);
 +
 +        start = in.readInt();
 +    }
 +
 +    /** {@inheritDoc} */
 +    @Override public boolean writeTo(ByteBuffer buf, MessageWriter writer) {
 +        writer.setBuffer(buf);
 +
 +        if (!writer.isHeaderWritten()) {
 +            if (!writer.writeHeader(directType(), fieldsCount()))
 +                return false;
 +
 +            writer.onHeaderWritten();
 +        }
 +
 +        switch (writer.state()) {
 +            case 0:
 +                if (!writer.writeByteArray("arr",
 +                    arr,
 +                    detachAllowed ? start : 0,
 +                    detachAllowed ? length() : arr.length))
 +                    return false;
 +
 +                writer.incrementState();
 +
 +            case 1:
 +                if (!writer.writeInt("start", detachAllowed ? 0 : start))
 +                    return false;
 +
 +                writer.incrementState();
 +
 +        }
 +
 +        return true;
 +    }
 +
 +    /** {@inheritDoc} */
 +    @Override public boolean readFrom(ByteBuffer buf, MessageReader reader) {
 +        reader.setBuffer(buf);
 +
 +        if (!reader.beforeMessageRead())
 +            return false;
 +
 +        switch (reader.state()) {
 +            case 0:
 +                arr = reader.readByteArray("arr");
 +
 +                if (!reader.isLastRead())
 +                    return false;
 +
 +                reader.incrementState();
 +
 +            case 1:
 +                start = reader.readInt("start");
 +
 +                if (!reader.isLastRead())
 +                    return false;
 +
 +                reader.incrementState();
 +
 +        }
 +
 +        return true;
 +    }
 +
 +    /** {@inheritDoc} */
 +    @Override public byte directType() {
 +        return 113;
 +    }
 +
 +    /** {@inheritDoc} */
 +    @Override public byte fieldsCount() {
 +        return 3;
 +    }
 +
 +    /**
 +     * Runs value deserialization regardless of whether obj already has the deserialized
value.
 +     * Will set obj if descriptor is configured to keep deserialized values.
 +     */
 +    private Object deserializeValue() {
 +        // TODO: IGNITE-1272 - Deserialize with proper class loader.
 +        BinaryReaderExImpl reader = new BinaryReaderExImpl(ctx, arr, start, null);
 +
 +        Object obj0 = reader.deserialize();
 +
 +        PortableClassDescriptor desc = reader.descriptor();
 +
 +        assert desc != null;
 +
 +        if (desc.keepDeserialized())
 +            obj = obj0;
 +
 +        return obj0;
 +    }
 +}

http://git-wip-us.apache.org/repos/asf/ignite/blob/c050b4ce/modules/core/src/main/java/org/apache/ignite/internal/portable/BinaryObjectOffheapImpl.java
----------------------------------------------------------------------
diff --cc modules/core/src/main/java/org/apache/ignite/internal/portable/BinaryObjectOffheapImpl.java
index e588a95,0000000..b543b9e
mode 100644,000000..100644
--- a/modules/core/src/main/java/org/apache/ignite/internal/portable/BinaryObjectOffheapImpl.java
+++ b/modules/core/src/main/java/org/apache/ignite/internal/portable/BinaryObjectOffheapImpl.java
@@@ -1,304 -1,0 +1,381 @@@
 +/*
 + * Licensed to the Apache Software Foundation (ASF) under one or more
 + * contributor license agreements.  See the NOTICE file distributed with
 + * this work for additional information regarding copyright ownership.
 + * The ASF licenses this file to You 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.
 + */
 +
 +package org.apache.ignite.internal.portable;
 +
 +import java.io.Externalizable;
 +import java.io.IOException;
 +import java.io.ObjectInput;
 +import java.io.ObjectOutput;
 +import java.nio.ByteBuffer;
 +import org.apache.ignite.IgniteCheckedException;
 +import org.apache.ignite.internal.portable.streams.PortableOffheapInputStream;
 +import org.apache.ignite.internal.processors.cache.CacheObject;
 +import org.apache.ignite.internal.processors.cache.CacheObjectContext;
 +import org.apache.ignite.internal.util.GridUnsafe;
 +import org.apache.ignite.internal.util.typedef.internal.U;
 +import org.apache.ignite.plugin.extensions.communication.MessageReader;
 +import org.apache.ignite.plugin.extensions.communication.MessageWriter;
 +import org.apache.ignite.binary.BinaryObjectException;
 +import org.apache.ignite.binary.BinaryType;
 +import org.apache.ignite.binary.BinaryObject;
 +import org.apache.ignite.binary.BinaryField;
 +import org.jetbrains.annotations.Nullable;
 +import sun.misc.Unsafe;
 +
++import static org.apache.ignite.internal.portable.GridPortableMarshaller.BOOLEAN;
++import static org.apache.ignite.internal.portable.GridPortableMarshaller.BYTE;
++import static org.apache.ignite.internal.portable.GridPortableMarshaller.CHAR;
++import static org.apache.ignite.internal.portable.GridPortableMarshaller.DOUBLE;
++import static org.apache.ignite.internal.portable.GridPortableMarshaller.FLOAT;
++import static org.apache.ignite.internal.portable.GridPortableMarshaller.INT;
++import static org.apache.ignite.internal.portable.GridPortableMarshaller.LONG;
++import static org.apache.ignite.internal.portable.GridPortableMarshaller.SHORT;
++
 +/**
 + *  Portable object implementation over offheap memory
 + */
 +public class BinaryObjectOffheapImpl extends BinaryObjectEx implements Externalizable, CacheObject
{
 +    /** */
 +    private static final long serialVersionUID = 0L;
 +
 +    /** */
 +    private static final Unsafe UNSAFE = GridUnsafe.unsafe();
 +
 +    /** */
 +    private final PortableContext ctx;
 +
 +    /** */
 +    private final long ptr;
 +
 +    /** */
 +    private final int start;
 +
 +    /** */
 +    private final int size;
 +
 +    /**
 +     * For {@link Externalizable} (not supported).
 +     */
 +    public BinaryObjectOffheapImpl() {
 +        throw new UnsupportedOperationException();
 +    }
 +
 +    /**
 +     * @param ctx Context.
 +     * @param ptr Memory address.
 +     * @param start Object start.
 +     * @param size Memory size.
 +     */
 +    public BinaryObjectOffheapImpl(PortableContext ctx, long ptr, int start, int size) {
 +        this.ctx = ctx;
 +        this.ptr = ptr;
 +        this.start = start;
 +        this.size = size;
 +    }
 +
 +    /**
 +     * @return Heap-based copy.
 +     */
 +    public BinaryObject heapCopy() {
 +        return new BinaryObjectImpl(ctx, U.copyMemory(ptr, size), start);
 +    }
 +
 +    /** {@inheritDoc} */
 +    @Override public int typeId() {
 +        return UNSAFE.getInt(ptr + start + GridPortableMarshaller.TYPE_ID_POS);
 +    }
 +
 +    /** {@inheritDoc} */
 +    @Override public int length() {
 +        return UNSAFE.getInt(ptr + start + GridPortableMarshaller.TOTAL_LEN_POS);
 +    }
 +
 +    /** {@inheritDoc} */
 +    @Override public int hashCode() {
 +        return UNSAFE.getInt(ptr + start + GridPortableMarshaller.HASH_CODE_POS);
 +    }
 +
 +    /** {@inheritDoc} */
 +    @Override protected int schemaId() {
 +        return UNSAFE.getInt(ptr + start + GridPortableMarshaller.SCHEMA_ID_POS);
 +    }
 +
 +    /** {@inheritDoc} */
 +    @Override protected PortableSchema createSchema() {
 +        BinaryReaderExImpl reader = new BinaryReaderExImpl(ctx,
 +            new PortableOffheapInputStream(ptr, size, false),
 +            start,
 +            null);
 +
 +        return reader.createSchema();
 +    }
 +
 +    /** {@inheritDoc} */
 +    @Override public BinaryField fieldDescriptor(String fieldName) throws BinaryObjectException
{
 +        int typeId = typeId();
 +
 +        PortableSchemaRegistry schemaReg = ctx.schemaRegistry(typeId);
 +
 +        int fieldId = ctx.userTypeIdMapper(typeId).fieldId(typeId, fieldName);
 +
 +        return new BinaryFieldImpl(schemaReg, fieldId);
 +    }
 +
 +    /** {@inheritDoc} */
 +    @Override public int start() {
 +        return start;
 +    }
 +
 +    /** {@inheritDoc} */
 +    @Override public byte[] array() {
 +        return null;
 +    }
 +
 +    /** {@inheritDoc} */
 +    @Override public long offheapAddress() {
 +        return ptr;
 +    }
 +
 +    /** {@inheritDoc} */
 +    @Override protected boolean hasArray() {
 +        return false;
 +    }
 +
 +    /** {@inheritDoc} */
 +    @Nullable @Override public BinaryType metaData() throws BinaryObjectException {
 +        if (ctx == null)
 +            throw new BinaryObjectException("PortableContext is not set for the object.");
 +
 +        return ctx.metaData(typeId());
 +    }
 +
 +    /** {@inheritDoc} */
 +    @SuppressWarnings("unchecked")
 +    @Nullable @Override public <F> F field(String fieldName) throws BinaryObjectException
{
 +        BinaryReaderExImpl reader = new BinaryReaderExImpl(ctx,
 +            new PortableOffheapInputStream(ptr, size, false),
 +            start,
 +            null);
 +
 +        return (F)reader.unmarshalField(fieldName);
 +    }
 +
 +    /** {@inheritDoc} */
 +    @SuppressWarnings("unchecked")
 +    @Nullable @Override public <F> F field(int fieldId) throws BinaryObjectException
{
 +        BinaryReaderExImpl reader = new BinaryReaderExImpl(ctx,
 +            new PortableOffheapInputStream(ptr, size, false),
 +            start,
 +            null);
 +
 +        return (F)reader.unmarshalField(fieldId);
 +    }
 +
 +    /** {@inheritDoc} */
 +    @SuppressWarnings("unchecked")
-     @Nullable @Override protected <F> F fieldByOffset(int fieldOffset) {
-         BinaryReaderExImpl reader = new BinaryReaderExImpl(ctx,
-             new PortableOffheapInputStream(ptr, size, false),
-             start,
-             null);
++    @Nullable @Override protected <F> F fieldByOrder(int order) {
++        Object val;
++
++        // Calculate field position.
++        int schemaOffset = PortablePrimitives.readInt(ptr, start + GridPortableMarshaller.SCHEMA_OR_RAW_OFF_POS);
++
++        short flags = PortablePrimitives.readShort(ptr, start + GridPortableMarshaller.FLAGS_POS);
++        int fieldOffsetSize = PortableUtils.fieldOffsetSize(flags);
++
++        int fieldOffsetPos = start + schemaOffset + order * (4 + fieldOffsetSize) + 4;
++
++        int fieldPos;
++
++        if (fieldOffsetSize == PortableUtils.OFFSET_1)
++            fieldPos = start + (int)PortablePrimitives.readByte(ptr, fieldOffsetPos) &
0xFF;
++        else if (fieldOffsetSize == PortableUtils.OFFSET_2)
++            fieldPos = start + (int)PortablePrimitives.readShort(ptr, fieldOffsetPos) &
0xFFFF;
++        else
++            fieldPos = start + PortablePrimitives.readInt(ptr, fieldOffsetPos);
++
++        // Read header and try performing fast lookup for well-known types (the most common
types go first).
++        byte hdr = PortablePrimitives.readByte(ptr, fieldPos);
++
++        switch (hdr) {
++            case INT:
++                val = PortablePrimitives.readInt(ptr, fieldPos + 1);
++
++                break;
++
++            case LONG:
++                val = PortablePrimitives.readLong(ptr, fieldPos + 1);
++
++                break;
++
++            case BOOLEAN:
++                val = PortablePrimitives.readBoolean(ptr, fieldPos + 1);
++
++                break;
++
++            case SHORT:
++                val = PortablePrimitives.readShort(ptr, fieldPos + 1);
++
++                break;
++
++            case BYTE:
++                val = PortablePrimitives.readByte(ptr, fieldPos + 1);
++
++                break;
++
++            case CHAR:
++                val = PortablePrimitives.readChar(ptr, fieldPos + 1);
++
++                break;
++
++            case FLOAT:
++                val = PortablePrimitives.readFloat(ptr, fieldPos + 1);
++
++                break;
++
++            case DOUBLE:
++                val = PortablePrimitives.readDouble(ptr, fieldPos + 1);
++
++                break;
++
++            default: {
++                PortableReaderExImpl reader = new PortableReaderExImpl(ctx,
++                    new PortableOffheapInputStream(ptr, size, false),
++                    start,
++                    null);
++
++                val = reader.unmarshalFieldByAbsolutePosition(fieldPos);
++            }
++        }
 +
-         return (F)reader.unmarshalFieldByOffset(fieldOffset);
++        return (F)val;
 +    }
 +
 +    /** {@inheritDoc} */
 +    @SuppressWarnings("unchecked")
 +    @Nullable @Override protected <F> F field(PortableReaderContext rCtx, String fieldName)
{
 +        BinaryReaderExImpl reader = new BinaryReaderExImpl(ctx,
 +            new PortableOffheapInputStream(ptr, size, false),
 +            start,
 +            null,
 +            rCtx);
 +
 +        return (F)reader.unmarshalField(fieldName);
 +    }
 +
 +    /** {@inheritDoc} */
 +    @Override public boolean hasField(String fieldName) {
 +        BinaryReaderExImpl reader = new BinaryReaderExImpl(ctx,
 +            new PortableOffheapInputStream(ptr, size, false),
 +            start,
 +            null);
 +
 +        return reader.hasField(fieldName);
 +    }
 +
 +    /** {@inheritDoc} */
 +    @SuppressWarnings("unchecked")
 +    @Nullable @Override public <T> T deserialize() throws BinaryObjectException {
 +        return (T)deserializeValue();
 +    }
 +
 +    /** {@inheritDoc} */
 +    @SuppressWarnings("CloneDoesntCallSuperClone")
 +    @Override public BinaryObject clone() throws CloneNotSupportedException {
 +        return heapCopy();
 +    }
 +
 +    /** {@inheritDoc} */
 +    @Override public byte type() {
 +        throw new UnsupportedOperationException();
 +    }
 +
 +    /** {@inheritDoc} */
 +    @Override public boolean isPlatformType() {
 +        return false;
 +    }
 +
 +    /** {@inheritDoc} */
 +    @SuppressWarnings("unchecked")
 +    @Nullable @Override public <T> T value(CacheObjectContext ctx, boolean cpy) {
 +        return (T)deserializeValue();
 +    }
 +
 +    /** {@inheritDoc} */
 +    @Override public byte[] valueBytes(CacheObjectContext ctx) throws IgniteCheckedException
{
 +        throw new UnsupportedOperationException();
 +    }
 +
 +    /** {@inheritDoc} */
 +    @Override public CacheObject prepareForCache(CacheObjectContext ctx) {
 +        throw new UnsupportedOperationException();
 +    }
 +
 +    /** {@inheritDoc} */
 +    @Override public void finishUnmarshal(CacheObjectContext ctx, ClassLoader ldr) throws
IgniteCheckedException {
 +        throw new UnsupportedOperationException();
 +    }
 +
 +    /** {@inheritDoc} */
 +    @Override public void prepareMarshal(CacheObjectContext ctx) throws IgniteCheckedException
{
 +        throw new UnsupportedOperationException();
 +    }
 +
 +    /** {@inheritDoc} */
 +    @Override public boolean writeTo(ByteBuffer buf, MessageWriter writer) {
 +        throw new UnsupportedOperationException();
 +    }
 +
 +    /** {@inheritDoc} */
 +    @Override public boolean readFrom(ByteBuffer buf, MessageReader reader) {
 +        throw new UnsupportedOperationException();
 +    }
 +
 +    /** {@inheritDoc} */
 +    @Override public byte directType() {
 +        throw new UnsupportedOperationException();
 +    }
 +
 +    /** {@inheritDoc} */
 +    @Override public byte fieldsCount() {
 +        throw new UnsupportedOperationException();
 +    }
 +
 +    /** {@inheritDoc} */
 +    @Override public void writeExternal(ObjectOutput out) throws IOException {
 +        throw new UnsupportedOperationException(); // To make sure it is not marshalled.
 +    }
 +
 +    /** {@inheritDoc} */
 +    @Override public void readExternal(ObjectInput in) throws IOException, ClassNotFoundException
{
 +        throw new UnsupportedOperationException(); // To make sure it is not marshalled.
 +    }
 +
 +    /**
 +     * @return Deserialized value.
 +     */
 +    private Object deserializeValue() {
 +        // TODO: IGNITE-1272 - Deserialize with proper class loader.
 +        BinaryReaderExImpl reader = new BinaryReaderExImpl(
 +            ctx,
 +            new PortableOffheapInputStream(ptr, size, false),
 +            start,
 +            null);
 +
 +        return reader.deserialize();
 +    }
 +}


Mime
View raw message