001    /**
002     * Copyright (c) 2000-present Liferay, Inc. All rights reserved.
003     *
004     * This library is free software; you can redistribute it and/or modify it under
005     * the terms of the GNU Lesser General Public License as published by the Free
006     * Software Foundation; either version 2.1 of the License, or (at your option)
007     * any later version.
008     *
009     * This library is distributed in the hope that it will be useful, but WITHOUT
010     * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
011     * FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more
012     * details.
013     */
014    
015    package com.liferay.portal.kernel.io;
016    
017    import com.liferay.portal.kernel.util.ClassLoaderPool;
018    import com.liferay.portal.kernel.util.ClassResolverUtil;
019    
020    import java.io.IOException;
021    import java.io.InputStream;
022    import java.io.ObjectInputStream;
023    import java.io.Serializable;
024    
025    import java.nio.ByteBuffer;
026    import java.nio.CharBuffer;
027    
028    /**
029     * Deserializes data in a ClassLoader-aware manner. This class is the
030     * counterpart of {@link Serializer} for deserialization.
031     *
032     * @author Shuyang Zhou
033     * @see    Serializer
034     */
035    public class Deserializer {
036    
037            public Deserializer(ByteBuffer byteBuffer) {
038                    buffer = byteBuffer.array();
039                    index = byteBuffer.arrayOffset();
040                    limit = index + byteBuffer.remaining();
041            }
042    
043            public boolean readBoolean() {
044                    detectBufferUnderflow(1);
045    
046                    return BigEndianCodec.getBoolean(buffer, index++);
047            }
048    
049            public byte readByte() {
050                    detectBufferUnderflow(1);
051    
052                    return buffer[index++];
053            }
054    
055            public char readChar() {
056                    detectBufferUnderflow(2);
057    
058                    char c = BigEndianCodec.getChar(buffer, index);
059    
060                    index += 2;
061    
062                    return c;
063            }
064    
065            public double readDouble() {
066                    detectBufferUnderflow(8);
067    
068                    double d = BigEndianCodec.getDouble(buffer, index);
069    
070                    index += 8;
071    
072                    return d;
073            }
074    
075            public float readFloat() {
076                    detectBufferUnderflow(4);
077    
078                    float f = BigEndianCodec.getFloat(buffer, index);
079    
080                    index += 4;
081    
082                    return f;
083            }
084    
085            public int readInt() {
086                    detectBufferUnderflow(4);
087    
088                    int i = BigEndianCodec.getInt(buffer, index);
089    
090                    index += 4;
091    
092                    return i;
093            }
094    
095            public long readLong() {
096                    detectBufferUnderflow(8);
097    
098                    long l = BigEndianCodec.getLong(buffer, index);
099    
100                    index += 8;
101    
102                    return l;
103            }
104    
105            public <T extends Serializable> T readObject()
106                    throws ClassNotFoundException {
107    
108                    byte tcByte = buffer[index++];
109    
110                    switch (tcByte) {
111                            case SerializationConstants.TC_BOOLEAN:
112                                    return (T)Boolean.valueOf(readBoolean());
113    
114                            case SerializationConstants.TC_BYTE:
115                                    return (T)Byte.valueOf(readByte());
116    
117                            case SerializationConstants.TC_CHARACTER:
118                                    return (T)Character.valueOf(readChar());
119    
120                            case SerializationConstants.TC_CLASS:
121                                    String contextName = readString();
122                                    String className = readString();
123    
124                                    ClassLoader classLoader = ClassLoaderPool.getClassLoader(
125                                            contextName);
126    
127                                    return (T)ClassResolverUtil.resolve(className, classLoader);
128    
129                            case SerializationConstants.TC_DOUBLE:
130                                    return (T)Double.valueOf(readDouble());
131    
132                            case SerializationConstants.TC_FLOAT:
133                                    return (T)Float.valueOf(readFloat());
134    
135                            case SerializationConstants.TC_INTEGER:
136                                    return (T)Integer.valueOf(readInt());
137    
138                            case SerializationConstants.TC_LONG:
139                                    return (T)Long.valueOf(readLong());
140    
141                            case SerializationConstants.TC_NULL:
142                                    return null;
143    
144                            case SerializationConstants.TC_SHORT:
145                                    return (T)Short.valueOf(readShort());
146    
147                            case SerializationConstants.TC_STRING:
148                                    return (T)readString();
149    
150                            case SerializationConstants.TC_OBJECT:
151                                    try {
152                                            ObjectInputStream objectInpputStream =
153                                                    new AnnotatedObjectInputStream(new BufferInputStream());
154    
155                                            return (T)objectInpputStream.readObject();
156                                    }
157                                    catch (IOException ioe) {
158                                            throw new RuntimeException(ioe);
159                                    }
160    
161                            default :
162                                    throw new IllegalStateException("Unkown TC code " + tcByte);
163                    }
164            }
165    
166            public short readShort() {
167                    detectBufferUnderflow(2);
168    
169                    short s = BigEndianCodec.getShort(buffer, index);
170    
171                    index += 2;
172    
173                    return s;
174            }
175    
176            public String readString() {
177                    detectBufferUnderflow(5);
178    
179                    boolean asciiCode = BigEndianCodec.getBoolean(buffer, index++);
180    
181                    int length = BigEndianCodec.getInt(buffer, index);
182    
183                    index += 4;
184    
185                    if (asciiCode) {
186                            detectBufferUnderflow(length);
187    
188                            String s = new String(buffer, index, length);
189    
190                            index += length;
191    
192                            return s;
193                    }
194    
195                    length <<= 1;
196    
197                    detectBufferUnderflow(length);
198    
199                    ByteBuffer byteBuffer = ByteBuffer.wrap(buffer, index, length);
200    
201                    index += length;
202    
203                    CharBuffer charBuffer = byteBuffer.asCharBuffer();
204    
205                    return charBuffer.toString();
206            }
207    
208            /**
209             * Detects a buffer underflow throwing an {@link
210             * java.lang.IllegalStateException} if the input data is shorter than the
211             * reserved space. This method is final so JIT can perform an inline
212             * expansion.
213             *
214             * @param availableBytes number of bytes available in input buffer
215             */
216            protected final void detectBufferUnderflow(int availableBytes) {
217                    if ((index + availableBytes) > limit) {
218                            throw new IllegalStateException("Buffer underflow");
219                    }
220            }
221    
222            protected byte[] buffer;
223            protected int index;
224            protected int limit;
225    
226            protected class BufferInputStream extends InputStream {
227    
228                    @Override
229                    public int read() {
230                            return buffer[index++];
231                    }
232    
233                    @Override
234                    public int read(byte[] bytes) {
235                            return read(bytes, 0, bytes.length);
236                    }
237    
238                    @Override
239                    public int read(byte[] bytes, int offset, int length) {
240                            int remain = limit - index;
241    
242                            if (remain < length) {
243                                    length = remain;
244                            }
245    
246                            System.arraycopy(buffer, index, bytes, offset, length);
247    
248                            index += length;
249    
250                            return length;
251                    }
252    
253            }
254    
255    }