All Downloads are FREE. Search and download functionalities are using the official Maven repository.

org.apache.geode.DataSerializer Maven / Gradle / Ivy

Go to download

Apache Geode provides a database-like consistency model, reliable transaction processing and a shared-nothing architecture to maintain very low latency performance with high concurrency processing

There is a newer version: 1.15.1
Show newest version
/*
 * 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.geode;

import java.io.DataInput;
import java.io.DataOutput;
import java.io.File;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.io.Serializable;
import java.lang.reflect.Array;
import java.net.InetAddress;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Comparator;
import java.util.Date;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Hashtable;
import java.util.IdentityHashMap;
import java.util.LinkedHashMap;
import java.util.LinkedHashSet;
import java.util.LinkedList;
import java.util.Map;
import java.util.Properties;
import java.util.Set;
import java.util.Stack;
import java.util.TreeMap;
import java.util.TreeSet;
import java.util.Vector;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.ConcurrentMap;

import org.apache.logging.log4j.Logger;

import org.apache.geode.admin.RegionNotFoundException;
import org.apache.geode.annotations.internal.MakeNotStatic;
import org.apache.geode.cache.Cache;
import org.apache.geode.cache.CacheFactory;
import org.apache.geode.cache.Region;
import org.apache.geode.internal.HeapDataOutputStream;
import org.apache.geode.internal.InternalDataSerializer;
import org.apache.geode.internal.ObjToByteArraySerializer;
import org.apache.geode.internal.cache.CachedDeserializable;
import org.apache.geode.internal.cache.EventID;
import org.apache.geode.internal.cache.GemFireCacheImpl;
import org.apache.geode.internal.cache.InternalCache;
import org.apache.geode.internal.cache.tier.sockets.ClientProxyMembershipID;
import org.apache.geode.internal.logging.log4j.LogMarker;
import org.apache.geode.internal.offheap.StoredObject;
import org.apache.geode.internal.serialization.DSCODE;
import org.apache.geode.internal.serialization.StaticSerialization;
import org.apache.geode.internal.serialization.Version;
import org.apache.geode.logging.internal.log4j.api.LogService;
import org.apache.geode.pdx.PdxInstance;

/**
 * Provides static helper methods for reading and writing non-primitive data when working with a
 * {@link DataSerializable}. For instance, classes that implement DataSerializable can
 * use the DataSerializer in their toData and fromData
 * methods:
 *
 * 
 *
 * 
 * public class Employee implements DataSerializable {
 *   private int id;
 *   private String name;
 *   private Date birthday;
 *   private Company employer;
 *
 *   public void toData(DataOutput out) throws IOException {
 *     out.writeInt(this.id);
 *     out.writeUTF(this.name);
 *     DataSerializer.writeDate(this.birthday, out);
 *     DataSerializer.writeObject(this.employer, out);
 *   }
 *
 *   public void fromData(DataInput in) throws IOException, ClassNotFoundException {
 *
 *     this.id = in.readInt();
 *     this.name = in.readUTF();
 *     this.birthday = DataSerializer.readDate(in);
 *     this.employer = (Company) DataSerializer.readObject(in);
 *   }
 * }
 *
 * 
* *

* * Instances of DataSerializer are used to data serialize objects (such as instances of * standard Java classes or third-party classes for which the source code is not available) that do * not implement the DataSerializable interface. * *

* * The following DataSerializer data serializes instances of Company. In * order for the data serialization framework to consult this custom serializer, it must be * {@linkplain #register(Class) registered} with the framework. * * * *

public class CompanySerializer extends DataSerializer {

  static {
    DataSerializer.register(CompanySerializer.class);
  }

  /**
   * May be invoked reflectively if instances of Company are
   * distributed to other VMs.
   */
  public CompanySerializer() {

  }

  public Class[] getSupportedClasses() {
    return new Class[] { Company.class };
  }
  public int getId() {
    return 42;
  }

  public boolean toData(Object o, DataOutput out)
    throws IOException {
    if (o instanceof Company) {
      Company company = (Company) o;
      out.writeUTF(company.getName());

      // Let's assume that Address is java.io.Serializable
      Address address = company.getAddress();
      writeObject(address, out);
      return true;

    } else {
      return false;
    }
  }

  public Object fromData(DataInput in)
    throws IOException, ClassNotFoundException {

    String name = in.readUTF();
    Address address = (Address) readObject(in);
    return new Company(name, address);
  }
}
 * 
* * Just like {@link Instantiator}s, a DataSerializer may be sent to other members of * the distributed system when it is {@linkplain #register(Class) registered}. The data * serialization framework does not require that a DataSerializer be * {@link Serializable}, but it does require that it provide a {@linkplain #DataSerializer() * zero-argument constructor}. * * @see #writeObject(Object, DataOutput) * @see #readObject * * @since GemFire 3.5 */ public abstract class DataSerializer { private static final Logger logger = LogService.getLogger(); /** The eventId of this DataSerializer */ private EventID eventId; /** The originator of this DataSerializer */ private ClientProxyMembershipID context; /** * @deprecated Use Boolean.getBoolean("DataSerializer.TRACE_SERIALIZABLE") instead. */ @Deprecated protected static final boolean TRACE_SERIALIZABLE = Boolean.getBoolean("DataSerializer.TRACE_SERIALIZABLE"); /* Used to prevent standard Java serialization when sending data to a non-Java client */ protected static final ThreadLocal DISALLOW_JAVA_SERIALIZATION = new ThreadLocal<>(); /** * Writes an instance of Class to a DataOutput. This method will handle * a null value and not throw a NullPointerException. * * @throws IOException A problem occurs while writing to out * * @see #readClass */ public static void writeClass(Class c, DataOutput out) throws IOException { InternalDataSerializer.checkOut(out); if (logger.isTraceEnabled(LogMarker.SERIALIZER_VERBOSE)) { logger.trace(LogMarker.SERIALIZER_VERBOSE, "Writing Class {}", c); } if (c == null || c.isPrimitive()) { StaticSerialization.writePrimitiveClass(c, out); } else { // non-primitive classes have a second CLASS byte // if readObject/writeObject is called: // the first CLASS byte indicates it's a Class, the second // one indicates it's a non-primitive Class out.writeByte(DSCODE.CLASS.toByte()); String cname = c.getName(); cname = InternalDataSerializer.processOutgoingClassName(cname, out); writeString(cname, out); } } /** * Writes class name to a DataOutput. This method will handle a null * value and not throw a NullPointerException. * * @throws IOException A problem occurs while writing to out * * @see #readNonPrimitiveClassName(DataInput) */ public static void writeNonPrimitiveClassName(String className, DataOutput out) throws IOException { InternalDataSerializer.checkOut(out); if (logger.isTraceEnabled(LogMarker.SERIALIZER_VERBOSE)) { logger.trace(LogMarker.SERIALIZER_VERBOSE, "Writing Class name {}", className); } writeString(InternalDataSerializer.processOutgoingClassName(className, out), out); } /** * Reads an instance of Class from a DataInput. The class will be loaded * using the {@linkplain Thread#getContextClassLoader current content class loader}. The return * value may be null. * * @throws IOException A problem occurs while reading from in * @throws ClassNotFoundException The class cannot be loaded */ public static Class readClass(DataInput in) throws IOException, ClassNotFoundException { InternalDataSerializer.checkIn(in); byte typeCode = in.readByte(); if (typeCode == DSCODE.CLASS.toByte()) { String className = readString(in); return InternalDataSerializer.getCachedClass(className); } else { return StaticSerialization.decodePrimitiveClass(typeCode); } } /** * Reads name of an instance of Class from a DataInput. * * The return value may be null. * * @throws IOException A problem occurs while reading from in * @see #writeNonPrimitiveClassName(String, DataOutput) */ public static String readNonPrimitiveClassName(DataInput in) throws IOException { InternalDataSerializer.checkIn(in); return InternalDataSerializer.processIncomingClassName(readString(in)); } /** * Writes an instance of Region. A Region is serialized as just a reference to a full path only. * It will be recreated on the other end by calling {@link CacheFactory#getAnyInstance} and then * calling getRegion on it. This method will handle a null value and not * throw a NullPointerException. */ public static void writeRegion(Region rgn, DataOutput out) throws IOException { writeString((rgn != null) ? rgn.getFullPath() : null, out); } /** * Reads an instance of Region. A Region is serialized as a reference to a full path only. It is * recreated on the other end by calling {@link CacheFactory#getAnyInstance} and then calling * getRegion on it. The return value may be null. * * @param in the input stream * @return the Region instance * @throws org.apache.geode.cache.CacheClosedException if a cache has not been created or the only * created one is closed. * @throws RegionNotFoundException if there is no region by this name in the Cache */ public static Region readRegion(DataInput in) throws IOException, ClassNotFoundException { String fullPath = readString(in); Region rgn = null; if (fullPath != null) { // use getExisting to fix bug 43151 rgn = ((Cache) GemFireCacheImpl.getExisting("Needed cache to find region.")) .getRegion(fullPath); if (rgn == null) { throw new RegionNotFoundException( String.format( "Region ' %s ' could not be found while reading a DataSerializer stream", fullPath)); } } return rgn; } /** * Writes an instance of Date to a DataOutput. Note that even though * date may be an instance of a subclass of Date, readDate * will always return an instance of Date, not an instance of the subclass. To * preserve the class type of date,\ {@link #writeObject(Object, DataOutput)} should * be used for data serialization. This method will handle a null value and not throw * a NullPointerException. * * @throws IOException A problem occurs while writing to out * * @see #readDate */ public static void writeDate(Date date, DataOutput out) throws IOException { InternalDataSerializer.checkOut(out); if (logger.isTraceEnabled(LogMarker.SERIALIZER_VERBOSE)) { logger.trace(LogMarker.SERIALIZER_VERBOSE, "Writing Date {}", date); } long v; if (date == null) { v = -1L; } else { v = date.getTime(); if (v == -1L) { throw new IllegalArgumentException( "Dates whose getTime returns -1 can not be DataSerialized."); } } out.writeLong(v); } /** * Reads an instance of Date from a DataInput. The return value may be * null. * * @throws IOException A problem occurs while reading from in */ public static Date readDate(DataInput in) throws IOException { InternalDataSerializer.checkIn(in); long time = in.readLong(); Date date = null; if (time != -1L) { date = new Date(time); } if (logger.isTraceEnabled(LogMarker.SERIALIZER_VERBOSE)) { logger.trace(LogMarker.SERIALIZER_VERBOSE, "Read Date {}", date); } return date; } /** * Writes an instance of File to a DataOutput. Note that even though * file may be an instance of a subclass of File, readFile * will always return an instance of File, not an instance of the subclass. To * preserve the class type of file, {@link #writeObject(Object, DataOutput)} should * be used for data serialization. This method will handle a null value and not throw * a NullPointerException. * * @throws IOException A problem occurs while writing to out * * @see #readFile * @see File#getCanonicalPath */ public static void writeFile(File file, DataOutput out) throws IOException { InternalDataSerializer.checkOut(out); if (logger.isTraceEnabled(LogMarker.SERIALIZER_VERBOSE)) { logger.trace(LogMarker.SERIALIZER_VERBOSE, "Writing File {}", file); } writeString((file != null) ? file.getCanonicalPath() : null, out); } /** * Reads an instance of File from a DataInput. The return value may be * null. * * @throws IOException A problem occurs while reading from in */ public static File readFile(DataInput in) throws IOException { InternalDataSerializer.checkIn(in); String s = readString(in); File file = null; if (s != null) { file = new File(s); } if (logger.isTraceEnabled(LogMarker.SERIALIZER_VERBOSE)) { logger.trace(LogMarker.SERIALIZER_VERBOSE, "Read File {}", file); } return file; } /** * Writes an instance of InetAddress to a DataOutput. The * InetAddress is data serialized by writing its {@link InetAddress#getAddress byte} * representation to the DataOutput. {@link #readInetAddress} converts the * byte representation to an instance of InetAddress using * {@link InetAddress#getAddress}. As a result, if address is an instance of a * user-defined subclass of InetAddress (that is, not an instance of one of the * subclasses from the java.net package), its class will not be preserved. In order * to be able to read an instance of the user-defined class, * {@link #writeObject(Object, DataOutput)} should be used. This method will handle a * null value and not throw a NullPointerException. * * @throws IOException A problem occurs while writing to out * * @see #readInetAddress */ public static void writeInetAddress(InetAddress address, DataOutput out) throws IOException { InternalDataSerializer.checkOut(out); if (logger.isTraceEnabled(LogMarker.SERIALIZER_VERBOSE)) { logger.trace(LogMarker.SERIALIZER_VERBOSE, "Writing InetAddress {}", address); } StaticSerialization.writeInetAddress(address, out); } /** * Reads an instance of InetAddress from a DataInput. The return value * may be null. * * @throws IOException A problem occurs while reading from in or the address read * from in is unknown * * @see InetAddress#getAddress */ public static InetAddress readInetAddress(DataInput in) throws IOException { InternalDataSerializer.checkIn(in); InetAddress address = StaticSerialization.readInetAddress(in); if (logger.isTraceEnabled(LogMarker.SERIALIZER_VERBOSE)) { logger.trace(LogMarker.SERIALIZER_VERBOSE, "Read InetAddress {}", address); } return address; } /** * Writes an instance of String to a DataOutput. This method will handle * a null value and not throw a NullPointerException. *

* As of 5.7 strings longer than 0xFFFF can be serialized. * * @throws IOException A problem occurs while writing to out * * @see #readString */ public static void writeString(String value, DataOutput out) throws IOException { InternalDataSerializer.checkOut(out); final boolean isTraceSerialzerVerbose = logger.isTraceEnabled(LogMarker.SERIALIZER_VERBOSE); if (isTraceSerialzerVerbose) { logger.trace(LogMarker.SERIALIZER_VERBOSE, "Writing String \"{}\"", value); } StaticSerialization.writeString(value, out); } /** * Reads an instance of String from a DataInput. The return value may be * null. * * @throws IOException A problem occurs while reading from in * * @see #writeString */ public static String readString(DataInput in) throws IOException { return StaticSerialization.readString(in); } /** * Writes an instance of Boolean to a DataOutput. * * @throws IOException A problem occurs while writing to out * @throws NullPointerException if value is null. * * @see #readBoolean */ public static void writeBoolean(Boolean value, DataOutput out) throws IOException { InternalDataSerializer.checkOut(out); if (logger.isTraceEnabled(LogMarker.SERIALIZER_VERBOSE)) { logger.trace(LogMarker.SERIALIZER_VERBOSE, "Writing Boolean {}", value); } out.writeBoolean(value); } /** * Reads an instance of Boolean from a DataInput. * * @throws IOException A problem occurs while reading from in */ public static Boolean readBoolean(DataInput in) throws IOException { InternalDataSerializer.checkIn(in); Boolean value = in.readBoolean(); if (logger.isTraceEnabled(LogMarker.SERIALIZER_VERBOSE)) { logger.trace(LogMarker.SERIALIZER_VERBOSE, "Read Boolean {}", value); } return value; } /** * Writes an instance of Character to a DataOutput. * * @throws IOException A problem occurs while writing to out * @throws NullPointerException if value is null. * * @see #readCharacter */ public static void writeCharacter(Character value, DataOutput out) throws IOException { InternalDataSerializer.checkOut(out); if (logger.isTraceEnabled(LogMarker.SERIALIZER_VERBOSE)) { logger.trace(LogMarker.SERIALIZER_VERBOSE, "Writing Character {}", value); } out.writeChar(value); } /** * Reads an instance of Character from a DataInput. * * @throws IOException A problem occurs while reading from in */ public static Character readCharacter(DataInput in) throws IOException { InternalDataSerializer.checkIn(in); Character value = in.readChar(); if (logger.isTraceEnabled(LogMarker.SERIALIZER_VERBOSE)) { logger.trace(LogMarker.SERIALIZER_VERBOSE, "Read Character {}", value); } return value; } /** * Writes an instance of Byte to a DataOutput. * * @throws IOException A problem occurs while writing to out * @throws NullPointerException if value is null. * * @see #readByte */ public static void writeByte(Byte value, DataOutput out) throws IOException { InternalDataSerializer.checkOut(out); if (logger.isTraceEnabled(LogMarker.SERIALIZER_VERBOSE)) { logger.trace(LogMarker.SERIALIZER_VERBOSE, "Writing Byte {}", value); } out.writeByte(value); } /** * Reads an instance of Byte from a DataInput. * * @throws IOException A problem occurs while reading from in */ public static Byte readByte(DataInput in) throws IOException { InternalDataSerializer.checkIn(in); Byte value = in.readByte(); if (logger.isTraceEnabled(LogMarker.SERIALIZER_VERBOSE)) { logger.trace(LogMarker.SERIALIZER_VERBOSE, "Read Byte {}", value); } return value; } /** * Writes an instance of Short to a DataOutput. * * @throws IOException A problem occurs while writing to out * @throws NullPointerException if value is null. * * @see #readShort */ public static void writeShort(Short value, DataOutput out) throws IOException { InternalDataSerializer.checkOut(out); if (logger.isTraceEnabled(LogMarker.SERIALIZER_VERBOSE)) { logger.trace(LogMarker.SERIALIZER_VERBOSE, "Writing Short {}", value); } out.writeShort(value); } /** * Reads an instance of Short from a DataInput. * * @throws IOException A problem occurs while reading from in */ public static Short readShort(DataInput in) throws IOException { InternalDataSerializer.checkIn(in); Short value = in.readShort(); if (logger.isTraceEnabled(LogMarker.SERIALIZER_VERBOSE)) { logger.trace(LogMarker.SERIALIZER_VERBOSE, "Read Short {}", value); } return value; } /** * Writes an instance of Integer to a DataOutput. * * @throws IOException A problem occurs while writing to out * @throws NullPointerException if value is null. * * @see #readInteger */ public static void writeInteger(Integer value, DataOutput out) throws IOException { InternalDataSerializer.checkOut(out); if (logger.isTraceEnabled(LogMarker.SERIALIZER_VERBOSE)) { logger.trace(LogMarker.SERIALIZER_VERBOSE, "Writing Integer {}", value); } out.writeInt(value); } /** * Reads an instance of Integer from a DataInput. * * @throws IOException A problem occurs while reading from in */ public static Integer readInteger(DataInput in) throws IOException { InternalDataSerializer.checkIn(in); Integer value = in.readInt(); if (logger.isTraceEnabled(LogMarker.SERIALIZER_VERBOSE)) { logger.trace(LogMarker.SERIALIZER_VERBOSE, "Read Integer {}", value); } return value; } /** * Writes an instance of Long to a DataOutput. * * @throws IOException A problem occurs while writing to out * @throws NullPointerException if value is null. * * @see #readLong */ public static void writeLong(Long value, DataOutput out) throws IOException { InternalDataSerializer.checkOut(out); if (logger.isTraceEnabled(LogMarker.SERIALIZER_VERBOSE)) { logger.trace(LogMarker.SERIALIZER_VERBOSE, "Writing Long {}", value); } out.writeLong(value); } /** * Reads an instance of Long from a DataInput. * * @throws IOException A problem occurs while reading from in */ public static Long readLong(DataInput in) throws IOException { InternalDataSerializer.checkIn(in); Long value = in.readLong(); if (logger.isTraceEnabled(LogMarker.SERIALIZER_VERBOSE)) { logger.trace(LogMarker.SERIALIZER_VERBOSE, "Read Long {}", value); } return value; } /** * Writes an instance of Float to a DataOutput. * * @throws IOException A problem occurs while writing to out * @throws NullPointerException if value is null. * * @see #readFloat */ public static void writeFloat(Float value, DataOutput out) throws IOException { InternalDataSerializer.checkOut(out); if (logger.isTraceEnabled(LogMarker.SERIALIZER_VERBOSE)) { logger.trace(LogMarker.SERIALIZER_VERBOSE, "Writing Float {}", value); } out.writeFloat(value); } /** * Reads an instance of Float from a DataInput. * * @throws IOException A problem occurs while reading from in */ public static Float readFloat(DataInput in) throws IOException { InternalDataSerializer.checkIn(in); Float value = in.readFloat(); if (logger.isTraceEnabled(LogMarker.SERIALIZER_VERBOSE)) { logger.trace(LogMarker.SERIALIZER_VERBOSE, "Read Float {}", value); } return value; } /** * Writes an instance of Double to a DataOutput. * * @throws IOException A problem occurs while writing to out * @throws NullPointerException if value is null. * * @see #readDouble */ public static void writeDouble(Double value, DataOutput out) throws IOException { InternalDataSerializer.checkOut(out); if (logger.isTraceEnabled(LogMarker.SERIALIZER_VERBOSE)) { logger.trace(LogMarker.SERIALIZER_VERBOSE, "Writing Double {}", value); } out.writeDouble(value); } /** * Reads an instance of Double from a DataInput. * * @throws IOException A problem occurs while reading from in */ public static Double readDouble(DataInput in) throws IOException { InternalDataSerializer.checkIn(in); Double value = in.readDouble(); if (logger.isTraceEnabled(LogMarker.SERIALIZER_VERBOSE)) { logger.trace(LogMarker.SERIALIZER_VERBOSE, "Read Double {}", value); } return value; } /** * Writes a primitive boolean to a DataOutput. * * @throws IOException A problem occurs while writing to out * * @see DataOutput#writeBoolean * @since GemFire 5.1 */ public static void writePrimitiveBoolean(boolean value, DataOutput out) throws IOException { InternalDataSerializer.checkOut(out); if (logger.isTraceEnabled(LogMarker.SERIALIZER_VERBOSE)) { logger.trace(LogMarker.SERIALIZER_VERBOSE, "Writing Boolean {}", value); } out.writeBoolean(value); } /** * Reads a primitive boolean from a DataInput. * * @throws IOException A problem occurs while reading from in * @see DataInput#readBoolean * @since GemFire 5.1 */ public static boolean readPrimitiveBoolean(DataInput in) throws IOException { InternalDataSerializer.checkIn(in); boolean value = in.readBoolean(); if (logger.isTraceEnabled(LogMarker.SERIALIZER_VERBOSE)) { logger.trace(LogMarker.SERIALIZER_VERBOSE, "Read Boolean {}", value); } return value; } /** * Writes a primitive byte to a DataOutput. * * @throws IOException A problem occurs while writing to out * * @see DataOutput#writeByte * @since GemFire 5.1 */ public static void writePrimitiveByte(byte value, DataOutput out) throws IOException { InternalDataSerializer.checkOut(out); if (logger.isTraceEnabled(LogMarker.SERIALIZER_VERBOSE)) { logger.trace(LogMarker.SERIALIZER_VERBOSE, "Writing Byte {}", value); } out.writeByte(value); } /** * Reads a primitive byte from a DataInput. * * @throws IOException A problem occurs while reading from in * @see DataInput#readByte * @since GemFire 5.1 */ public static byte readPrimitiveByte(DataInput in) throws IOException { InternalDataSerializer.checkIn(in); byte value = in.readByte(); if (logger.isTraceEnabled(LogMarker.SERIALIZER_VERBOSE)) { logger.trace(LogMarker.SERIALIZER_VERBOSE, "Read Byte {}", value); } return value; } /** * Writes a primitive char to a DataOutput. * * @throws IOException A problem occurs while writing to out * * @see DataOutput#writeChar * @since GemFire 5.1 */ public static void writePrimitiveChar(char value, DataOutput out) throws IOException { InternalDataSerializer.checkOut(out); if (logger.isTraceEnabled(LogMarker.SERIALIZER_VERBOSE)) { logger.trace(LogMarker.SERIALIZER_VERBOSE, "Writing Char {}", value); } out.writeChar(value); } /** * Reads a primitive char from a DataInput. * * @throws IOException A problem occurs while reading from in * @see DataInput#readChar * @since GemFire 5.1 */ public static char readPrimitiveChar(DataInput in) throws IOException { InternalDataSerializer.checkIn(in); char value = in.readChar(); if (logger.isTraceEnabled(LogMarker.SERIALIZER_VERBOSE)) { logger.trace(LogMarker.SERIALIZER_VERBOSE, "Read Char {}", value); } return value; } /** * Writes a primitive short to a DataOutput. * * @throws IOException A problem occurs while writing to out * * @see DataOutput#writeShort * @since GemFire 5.1 */ public static void writePrimitiveShort(short value, DataOutput out) throws IOException { InternalDataSerializer.checkOut(out); if (logger.isTraceEnabled(LogMarker.SERIALIZER_VERBOSE)) { logger.trace(LogMarker.SERIALIZER_VERBOSE, "Writing Short {}", value); } out.writeShort(value); } /** * Reads a primitive short from a DataInput. * * @throws IOException A problem occurs while reading from in * @see DataInput#readShort * @since GemFire 5.1 */ public static short readPrimitiveShort(DataInput in) throws IOException { InternalDataSerializer.checkIn(in); short value = in.readShort(); if (logger.isTraceEnabled(LogMarker.SERIALIZER_VERBOSE)) { logger.trace(LogMarker.SERIALIZER_VERBOSE, "Read Short {}", value); } return value; } /** * Writes a primitive int as an unsigned byte to a DataOutput. * * @throws IOException A problem occurs while writing to out * * @see DataOutput#writeByte * @see DataInput#readUnsignedByte * @since GemFire 5.1 */ public static void writeUnsignedByte(int value, DataOutput out) throws IOException { InternalDataSerializer.checkOut(out); if (logger.isTraceEnabled(LogMarker.SERIALIZER_VERBOSE)) { logger.trace(LogMarker.SERIALIZER_VERBOSE, "Writing Unsigned Byte {}", value); } out.writeByte(value); } /** * Reads a primitive int as an unsigned byte from a DataInput using * {@link DataInput#readUnsignedByte}. * * @throws IOException A problem occurs while reading from in * @since GemFire 5.1 */ public static int readUnsignedByte(DataInput in) throws IOException { InternalDataSerializer.checkIn(in); int value = in.readUnsignedByte(); if (logger.isTraceEnabled(LogMarker.SERIALIZER_VERBOSE)) { logger.trace(LogMarker.SERIALIZER_VERBOSE, "Read Unsigned Byte {}", value); } return value; } /** * Writes a primitive int as an unsigned short to a DataOutput. * * @throws IOException A problem occurs while writing to out * * @see DataOutput#writeShort * @see DataInput#readUnsignedShort * @since GemFire 5.1 */ public static void writeUnsignedShort(int value, DataOutput out) throws IOException { InternalDataSerializer.checkOut(out); if (logger.isTraceEnabled(LogMarker.SERIALIZER_VERBOSE)) { logger.trace(LogMarker.SERIALIZER_VERBOSE, "Writing Unsigned Short {}", value); } out.writeShort(value); } /** * Reads a primitive int as an unsigned short from a DataInput using * {@link DataInput#readUnsignedShort}. * * @throws IOException A problem occurs while reading from in * @since GemFire 5.1 */ public static int readUnsignedShort(DataInput in) throws IOException { InternalDataSerializer.checkIn(in); int value = in.readUnsignedShort(); if (logger.isTraceEnabled(LogMarker.SERIALIZER_VERBOSE)) { logger.trace(LogMarker.SERIALIZER_VERBOSE, "Read Unsigned Short {}", value); } return value; } /** * Writes a primitive int to a DataOutput. * * @throws IOException A problem occurs while writing to out * * @see DataOutput#writeInt */ public static void writePrimitiveInt(int value, DataOutput out) throws IOException { InternalDataSerializer.checkOut(out); if (logger.isTraceEnabled(LogMarker.SERIALIZER_VERBOSE)) { logger.trace(LogMarker.SERIALIZER_VERBOSE, "Writing Integer {}", value); } out.writeInt(value); } /** * Reads a primitive int from a DataInput. * * @throws IOException A problem occurs while reading from in * @see DataInput#readInt * @since GemFire 5.1 */ public static int readPrimitiveInt(DataInput in) throws IOException { InternalDataSerializer.checkIn(in); int value = in.readInt(); if (logger.isTraceEnabled(LogMarker.SERIALIZER_VERBOSE)) { logger.trace(LogMarker.SERIALIZER_VERBOSE, "Read Integer {}", value); } return value; } /** * Writes a primitive long to a DataOutput. * * @throws IOException A problem occurs while writing to out * * @see DataOutput#writeLong * @since GemFire 5.1 */ public static void writePrimitiveLong(long value, DataOutput out) throws IOException { InternalDataSerializer.checkOut(out); if (logger.isTraceEnabled(LogMarker.SERIALIZER_VERBOSE)) { logger.trace(LogMarker.SERIALIZER_VERBOSE, "Writing Long {}", value); } out.writeLong(value); } /** * Reads a primitive long from a DataInput. * * @throws IOException A problem occurs while reading from in * @see DataInput#readLong * @since GemFire 5.1 */ public static long readPrimitiveLong(DataInput in) throws IOException { InternalDataSerializer.checkIn(in); long value = in.readLong(); if (logger.isTraceEnabled(LogMarker.SERIALIZER_VERBOSE)) { logger.trace(LogMarker.SERIALIZER_VERBOSE, "Read Long {}", value); } return value; } /** * Writes a primitive float to a DataOutput. * * @throws IOException A problem occurs while writing to out * * @see DataOutput#writeFloat * @since GemFire 5.1 */ public static void writePrimitiveFloat(float value, DataOutput out) throws IOException { InternalDataSerializer.checkOut(out); if (logger.isTraceEnabled(LogMarker.SERIALIZER_VERBOSE)) { logger.trace(LogMarker.SERIALIZER_VERBOSE, "Writing Float {}", value); } out.writeFloat(value); } /** * Reads a primitive float from a DataInput. * * @throws IOException A problem occurs while reading from in * @see DataInput#readFloat * @since GemFire 5.1 */ public static float readPrimitiveFloat(DataInput in) throws IOException { InternalDataSerializer.checkIn(in); float value = in.readFloat(); if (logger.isTraceEnabled(LogMarker.SERIALIZER_VERBOSE)) { logger.trace(LogMarker.SERIALIZER_VERBOSE, "Read Float {}", value); } return value; } /** * Writes a primtive double to a DataOutput. * * @throws IOException A problem occurs while writing to out * * @see DataOutput#writeDouble * @since GemFire 5.1 */ public static void writePrimitiveDouble(double value, DataOutput out) throws IOException { InternalDataSerializer.checkOut(out); if (logger.isTraceEnabled(LogMarker.SERIALIZER_VERBOSE)) { logger.trace(LogMarker.SERIALIZER_VERBOSE, "Writing Double {}", value); } out.writeDouble(value); } /** * Reads a primitive double from a DataInput. * * @throws IOException A problem occurs while reading from in * @see DataInput#readDouble * @since GemFire 5.1 */ public static double readPrimitiveDouble(DataInput in) throws IOException { InternalDataSerializer.checkIn(in); double value = in.readDouble(); if (logger.isTraceEnabled(LogMarker.SERIALIZER_VERBOSE)) { logger.trace(LogMarker.SERIALIZER_VERBOSE, "Read Double {}", value); } return value; } /** * Writes an array of bytes to a DataOutput. This method will serialize * a null array and not throw a NullPointerException. * * @throws IOException A problem occurs while writing to out * * @see #readByteArray */ public static void writeByteArray(byte[] array, DataOutput out) throws IOException { int len = 0; if (array != null) { len = array.length; } writeByteArray(array, len, out); } /** * Writes the first len elements of an array of bytes to a * DataOutput. This method will serialize a null array and not throw a * NullPointerException. * * @param len the actual number of entries to write. If len is greater than then length of the * array then the entire array is written. * @throws IOException A problem occurs while writing to out * * @see #readByteArray */ public static void writeByteArray(byte[] array, int len, DataOutput out) throws IOException { InternalDataSerializer.checkOut(out); int length = len; // to avoid warnings about parameter assignment if (array == null) { length = -1; } else { if (length > array.length) { length = array.length; } } InternalDataSerializer.writeArrayLength(length, out); if (logger.isTraceEnabled(LogMarker.SERIALIZER_VERBOSE)) { logger.trace(LogMarker.SERIALIZER_VERBOSE, "Writing byte array of length {}", length); } if (length > 0) { out.write(array, 0, length); } } /** * Serialize the given object obj into a byte array using * {@link #writeObject(Object, DataOutput)} and then writes the byte array to the given data * output out in the same format {@link #writeByteArray(byte[], DataOutput)} does. * This method will serialize a null obj and not throw a * NullPointerException. * * @param obj the object to serialize and write * @param out the data output to write the byte array to * @throws IllegalArgumentException if a problem occurs while serialize obj * @throws IOException if a problem occurs while writing to out * * @see #readByteArray * @since GemFire 5.0.2 */ public static void writeObjectAsByteArray(Object obj, DataOutput out) throws IOException { Object object = obj; if (obj instanceof CachedDeserializable) { if (obj instanceof StoredObject) { StoredObject so = (StoredObject) obj; if (logger.isTraceEnabled(LogMarker.SERIALIZER_VERBOSE)) { logger.trace(LogMarker.SERIALIZER_VERBOSE, "writeObjectAsByteArray StoredObject"); } so.sendAsByteArray(out); return; } else { object = ((CachedDeserializable) obj).getSerializedValue(); } } if (logger.isTraceEnabled(LogMarker.SERIALIZER_VERBOSE)) { if (object == null) { logger.trace(LogMarker.SERIALIZER_VERBOSE, "writeObjectAsByteArray null"); } else { logger.trace(LogMarker.SERIALIZER_VERBOSE, "writeObjectAsByteArray obj.getClass={}", object.getClass()); } } if (object instanceof byte[] || object == null) { writeByteArray((byte[]) object, out); } else if (out instanceof ObjToByteArraySerializer) { ((ObjToByteArraySerializer) out).writeAsSerializedByteArray(object); } /* * else if (obj instanceof Sendable) { ((Sendable)obj).sendTo(out); } */ else { HeapDataOutputStream hdos; if (object instanceof HeapDataOutputStream) { hdos = (HeapDataOutputStream) object; } else { Version v = StaticSerialization.getVersionForDataStreamOrNull(out); if (v == null) { v = Version.CURRENT; } hdos = new HeapDataOutputStream(v); try { DataSerializer.writeObject(object, hdos); } catch (IOException e) { throw new IllegalArgumentException("Problem while serializing.", e); } } InternalDataSerializer.writeArrayLength(hdos.size(), out); hdos.sendTo(out); } } /** * Reads an array of bytes from a DataInput. * * @throws IOException A problem occurs while reading from in * * @see #writeByteArray(byte[], DataOutput) */ public static byte[] readByteArray(DataInput in) throws IOException { InternalDataSerializer.checkIn(in); byte[] result = StaticSerialization.readByteArray(in); if (logger.isTraceEnabled(LogMarker.SERIALIZER_VERBOSE)) { logger.trace(LogMarker.SERIALIZER_VERBOSE, "Read byte array of length {}", result == null ? "null" : result.length); } return result; } /** * Writes an array of Strings to a DataOutput. This method will * serialize a null array and not throw a NullPointerException. * * @throws IOException A problem occurs while writing to out * * @see #readStringArray * @see #writeString */ public static void writeStringArray(String[] array, DataOutput out) throws IOException { InternalDataSerializer.checkOut(out); StaticSerialization.writeStringArray(array, out); if (logger.isTraceEnabled(LogMarker.SERIALIZER_VERBOSE)) { int length; if (array == null) { length = -1; } else { length = array.length; } logger.trace(LogMarker.SERIALIZER_VERBOSE, "Writing String array of length {}", length); } } /** * Reads an array of Strings from a DataInput. * * @throws IOException A problem occurs while reading from in * * @see #writeStringArray */ public static String[] readStringArray(DataInput in) throws IOException { InternalDataSerializer.checkIn(in); String array[] = StaticSerialization.readStringArray(in); if (logger.isTraceEnabled(LogMarker.SERIALIZER_VERBOSE)) { logger.trace(LogMarker.SERIALIZER_VERBOSE, "Read String array of length {}", array == null ? "null" : array.length); } return array; } /** * Writes an array of shorts to a DataOutput. This method will serialize * a null array and not throw a NullPointerException. * * @throws IOException A problem occurs while writing to out * * @see #readShortArray */ public static void writeShortArray(short[] array, DataOutput out) throws IOException { InternalDataSerializer.checkOut(out); int length; if (array == null) { length = -1; } else { length = array.length; } InternalDataSerializer.writeArrayLength(length, out); if (logger.isTraceEnabled(LogMarker.SERIALIZER_VERBOSE)) { logger.trace(LogMarker.SERIALIZER_VERBOSE, "Writing short array of length {}", length); } if (length > 0) { for (int i = 0; i < length; i++) { out.writeShort(array[i]); } } } /** * Reads an array of shorts from a DataInput. * * @throws IOException A problem occurs while reading from in * * @see #writeShortArray */ public static short[] readShortArray(DataInput in) throws IOException { InternalDataSerializer.checkIn(in); int length = InternalDataSerializer.readArrayLength(in); if (length == -1) { return null; } else { short[] array = new short[length]; for (int i = 0; i < length; i++) { array[i] = in.readShort(); } if (logger.isTraceEnabled(LogMarker.SERIALIZER_VERBOSE)) { logger.trace(LogMarker.SERIALIZER_VERBOSE, "Read short array of length {}", length); } return array; } } /** * Writes an array of chars to a DataOutput. * * @throws IOException A problem occurs while writing to out * * @see #readCharArray * @since GemFire 5.7 */ public static void writeCharArray(char[] array, DataOutput out) throws IOException { InternalDataSerializer.writeCharArray(array, out); } /** * Reads an array of chars from a DataInput. * * @throws IOException A problem occurs while reading from in * * @see #writeCharArray * @since GemFire 5.7 */ public static char[] readCharArray(DataInput in) throws IOException { InternalDataSerializer.checkIn(in); int length = InternalDataSerializer.readArrayLength(in); if (length == -1) { return null; } else { char[] array = new char[length]; for (int i = 0; i < length; i++) { array[i] = in.readChar(); } if (logger.isTraceEnabled(LogMarker.SERIALIZER_VERBOSE)) { logger.trace(LogMarker.SERIALIZER_VERBOSE, "Read char array of length {}", length); } return array; } } /** * Writes an array of booleans to a DataOutput. * * @throws IOException A problem occurs while writing to out * * @see #readBooleanArray * @since GemFire 5.7 */ public static void writeBooleanArray(boolean[] array, DataOutput out) throws IOException { InternalDataSerializer.checkOut(out); int length; if (array == null) { length = -1; } else { length = array.length; } InternalDataSerializer.writeArrayLength(length, out); if (logger.isTraceEnabled(LogMarker.SERIALIZER_VERBOSE)) { logger.trace(LogMarker.SERIALIZER_VERBOSE, "Writing boolean array of length {}", length); } if (length > 0) { for (int i = 0; i < length; i++) { out.writeBoolean(array[i]); } } } /** * Reads an array of booleans from a DataInput. * * @throws IOException A problem occurs while reading from in * * @see #writeBooleanArray * @since GemFire 5.7 */ public static boolean[] readBooleanArray(DataInput in) throws IOException { InternalDataSerializer.checkIn(in); int length = InternalDataSerializer.readArrayLength(in); if (length == -1) { return null; } else { boolean[] array = new boolean[length]; for (int i = 0; i < length; i++) { array[i] = in.readBoolean(); } if (logger.isTraceEnabled(LogMarker.SERIALIZER_VERBOSE)) { logger.trace(LogMarker.SERIALIZER_VERBOSE, "Read boolean array of length {}", length); } return array; } } /** * Writes an int array to a DataOutput. This method will serialize a * null array and not throw a NullPointerException. * * @throws IOException A problem occurs while writing to out * * @see #readIntArray */ public static void writeIntArray(int[] array, DataOutput out) throws IOException { InternalDataSerializer.checkOut(out); StaticSerialization.writeIntArray(array, out); if (logger.isTraceEnabled(LogMarker.SERIALIZER_VERBOSE)) { logger.trace(LogMarker.SERIALIZER_VERBOSE, "Writing int array of length {}", array == null ? "null" : array.length); } } /** * Reads an int array from a DataInput. * * @throws IOException A problem occurs while reading from in * * @see #writeIntArray */ public static int[] readIntArray(DataInput in) throws IOException { InternalDataSerializer.checkIn(in); int[] result = StaticSerialization.readIntArray(in); if (logger.isTraceEnabled(LogMarker.SERIALIZER_VERBOSE)) { logger.trace(LogMarker.SERIALIZER_VERBOSE, "Read int array of length {}", result == null ? "null" : result.length); } return result; } /** * Writes an array of longs to a DataOutput. This method will serialize * a null array and not throw a NullPointerException. * * @throws IOException A problem occurs while writing to out * * @see #readLongArray */ public static void writeLongArray(long[] array, DataOutput out) throws IOException { InternalDataSerializer.checkOut(out); int length; if (array == null) { length = -1; } else { length = array.length; } InternalDataSerializer.writeArrayLength(length, out); if (logger.isTraceEnabled(LogMarker.SERIALIZER_VERBOSE)) { logger.trace(LogMarker.SERIALIZER_VERBOSE, "Writing long array of length {}", length); } if (length > 0) { for (int i = 0; i < length; i++) { out.writeLong(array[i]); } } } /** * Reads an array of longs from a DataInput. * * @throws IOException A problem occurs while reading from in * * @see #writeLongArray */ public static long[] readLongArray(DataInput in) throws IOException { InternalDataSerializer.checkIn(in); int length = InternalDataSerializer.readArrayLength(in); if (length == -1) { return null; } else { long[] array = new long[length]; for (int i = 0; i < length; i++) { array[i] = in.readLong(); } if (logger.isTraceEnabled(LogMarker.SERIALIZER_VERBOSE)) { logger.trace(LogMarker.SERIALIZER_VERBOSE, "Read long array of length {}", length); } return array; } } /** * Writes an array of floats to a DataOutput. This method will serialize * a null array and not throw a NullPointerException. * * @throws IOException A problem occurs while writing to out * * @see #readFloatArray */ public static void writeFloatArray(float[] array, DataOutput out) throws IOException { InternalDataSerializer.checkOut(out); int length; if (array == null) { length = -1; } else { length = array.length; } InternalDataSerializer.writeArrayLength(length, out); if (logger.isTraceEnabled(LogMarker.SERIALIZER_VERBOSE)) { logger.trace(LogMarker.SERIALIZER_VERBOSE, "Writing float array of length {}", length); } if (length > 0) { for (int i = 0; i < length; i++) { out.writeFloat(array[i]); } } } /** * Reads an array of floats from a DataInput. * * @throws IOException A problem occurs while reading from in * * @see #writeFloatArray */ public static float[] readFloatArray(DataInput in) throws IOException { InternalDataSerializer.checkIn(in); int length = InternalDataSerializer.readArrayLength(in); if (length == -1) { return null; } else { float[] array = new float[length]; for (int i = 0; i < length; i++) { array[i] = in.readFloat(); } if (logger.isTraceEnabled(LogMarker.SERIALIZER_VERBOSE)) { logger.trace(LogMarker.SERIALIZER_VERBOSE, "Read float array of length {}", length); } return array; } } /** * Writes an array of doubles to a DataOutput. This method will * serialize a null array and not throw a NullPointerException. * * @throws IOException A problem occurs while writing to out * * @see #readDoubleArray */ public static void writeDoubleArray(double[] array, DataOutput out) throws IOException { InternalDataSerializer.checkOut(out); int length; if (array == null) { length = -1; } else { length = array.length; } InternalDataSerializer.writeArrayLength(length, out); if (logger.isTraceEnabled(LogMarker.SERIALIZER_VERBOSE)) { logger.trace(LogMarker.SERIALIZER_VERBOSE, "Writing double array of length {}", length); } if (length > 0) { for (int i = 0; i < length; i++) { out.writeDouble(array[i]); } } } /** * Reads an array of doubles from a DataInput. * * @throws IOException A problem occurs while reading from in * * @see #writeDoubleArray */ public static double[] readDoubleArray(DataInput in) throws IOException { InternalDataSerializer.checkIn(in); int length = InternalDataSerializer.readArrayLength(in); if (length == -1) { return null; } else { double[] array = new double[length]; for (int i = 0; i < length; i++) { array[i] = in.readDouble(); } if (logger.isTraceEnabled(LogMarker.SERIALIZER_VERBOSE)) { logger.trace(LogMarker.SERIALIZER_VERBOSE, "Read double array of length {}", length); } return array; } } /** * Writes an array of Objects to a DataOutput. This method will * serialize a null array and not throw a NullPointerException. * * @throws IOException A problem occurs while writing to out * * @see #readObjectArray * @see #writeObject(Object, DataOutput) */ public static void writeObjectArray(Object[] array, DataOutput out) throws IOException { InternalDataSerializer.writeObjectArray(array, out, false); } /** * Reads an array of Objects from a DataInput. * * @throws IOException A problem occurs while reading from in * * @see #writeObjectArray * @see #readObject */ public static Object[] readObjectArray(DataInput in) throws IOException, ClassNotFoundException { InternalDataSerializer.checkIn(in); int length = InternalDataSerializer.readArrayLength(in); if (length == -1) { return null; } else { Class c; byte typeCode = in.readByte(); String typeString = null; if (typeCode == DSCODE.CLASS.toByte()) { typeString = readString(in); } InternalCache cache = GemFireCacheImpl.getInstance(); boolean lookForPdxInstance = false; ClassNotFoundException cnfEx = null; if (typeCode == DSCODE.CLASS.toByte() && cache != null && cache.getPdxReadSerializedByAnyGemFireServices()) { try { c = InternalDataSerializer.getCachedClass(typeString); lookForPdxInstance = true; } catch (ClassNotFoundException e) { c = Object.class; cnfEx = e; } } else { if (typeCode == DSCODE.CLASS.toByte()) { c = InternalDataSerializer.getCachedClass(typeString); } else { c = StaticSerialization.decodePrimitiveClass(typeCode); } } Object o = null; if (length > 0) { o = readObject(in); if (lookForPdxInstance && o instanceof PdxInstance) { lookForPdxInstance = false; c = Object.class; } } Object[] array = (Object[]) Array.newInstance(c, length); if (length > 0) { array[0] = o; } for (int i = 1; i < length; i++) { o = readObject(in); if (lookForPdxInstance && o instanceof PdxInstance) { // create an Object[] and copy all the entries we already did into it lookForPdxInstance = false; c = Object.class; Object[] newArray = (Object[]) Array.newInstance(c, length); System.arraycopy(array, 0, newArray, 0, i); array = newArray; } array[i] = o; } if (lookForPdxInstance && cnfEx != null && length > 0) { // We have a non-empty array and didn't find any // PdxInstances in it. So we should have been able // to load the element type. // Note that empty arrays in this case will deserialize // as an Object[] since we can't tell if the element // type is a pdx one. throw cnfEx; } if (logger.isTraceEnabled(LogMarker.SERIALIZER_VERBOSE)) { logger.trace(LogMarker.SERIALIZER_VERBOSE, "Read Object array of length {}", length); } return array; } } /** * Writes an array of byte[] to a DataOutput. * * @throws IOException A problem occurs while writing to out. * */ public static void writeArrayOfByteArrays(byte[][] array, DataOutput out) throws IOException { InternalDataSerializer.checkOut(out); int length; if (array == null) { length = -1; } else { length = array.length; } InternalDataSerializer.writeArrayLength(length, out); if (logger.isTraceEnabled(LogMarker.SERIALIZER_VERBOSE)) { logger.trace(LogMarker.SERIALIZER_VERBOSE, "Writing byte[][] of length {}", length); } if (length >= 0) { for (int i = 0; i < length; i++) { writeByteArray(array[i], out); } } } /** * Reads an array of byte[]s from a DataInput. * * @throws IOException A problem occurs while reading from in */ public static byte[][] readArrayOfByteArrays(DataInput in) throws IOException, ClassNotFoundException { InternalDataSerializer.checkIn(in); int length = InternalDataSerializer.readArrayLength(in); if (length == -1) { return null; } else { byte[][] array = new byte[length][]; for (int i = 0; i < length; i++) { array[i] = readByteArray(in); } if (logger.isTraceEnabled(LogMarker.SERIALIZER_VERBOSE)) { logger.trace(LogMarker.SERIALIZER_VERBOSE, "Read byte[][] of length {}", length); } return array; } } /** * Writes an ArrayList to a DataOutput. Note that even though * list may be an instance of a subclass of ArrayList, * readArrayList will always return an instance of ArrayList, not * an instance of the subclass. To preserve the class type of list, * {@link #writeObject(Object, DataOutput)} should be used for data serialization. This method * will serialize a null list and not throw a NullPointerException. * * @throws IOException A problem occurs while writing to out * * @see #readArrayList */ public static void writeArrayList(ArrayList list, DataOutput out) throws IOException { InternalDataSerializer.checkOut(out); int size; if (list == null) { size = -1; } else { size = list.size(); } InternalDataSerializer.writeArrayLength(size, out); if (logger.isTraceEnabled(LogMarker.SERIALIZER_VERBOSE)) { logger.trace(LogMarker.SERIALIZER_VERBOSE, "Writing ArrayList with {} elements: {}", size, list); } if (size > 0) { for (int i = 0; i < size; i++) { writeObject(list.get(i), out); } } } /** * Reads an ArrayList from a DataInput. * * @throws IOException A problem occurs while reading from in * @throws ClassNotFoundException The class of one of the ArrayList's elements cannot * be found. * * @see #writeArrayList */ public static ArrayList readArrayList(DataInput in) throws IOException, ClassNotFoundException { InternalDataSerializer.checkIn(in); int size = InternalDataSerializer.readArrayLength(in); if (size == -1) { return null; } else { ArrayList list = new ArrayList<>(size); for (int i = 0; i < size; i++) { E element = DataSerializer.readObject(in); list.add(element); } if (logger.isTraceEnabled(LogMarker.SERIALIZER_VERBOSE)) { logger.trace(LogMarker.SERIALIZER_VERBOSE, "Read ArrayList with {} elements: {}", size, list); } return list; } } /** * Writes an Vector to a DataOutput. Note that even though * list may be an instance of a subclass of Vector, * readVector will always return an instance of Vector, not an * instance of the subclass. To preserve the class type of list, * {@link #writeObject(Object, DataOutput)} should be used for data serialization. * * @throws IOException A problem occurs while writing to out * * @see #readVector * @since GemFire 5.7 */ public static void writeVector(Vector list, DataOutput out) throws IOException { InternalDataSerializer.checkOut(out); int size; if (list == null) { size = -1; } else { size = list.size(); } InternalDataSerializer.writeArrayLength(size, out); if (logger.isTraceEnabled(LogMarker.SERIALIZER_VERBOSE)) { logger.trace(LogMarker.SERIALIZER_VERBOSE, "Writing Vector with {} elements: {}", size, list); } if (size > 0) { for (int i = 0; i < size; i++) { writeObject(list.get(i), out); } } } /** * Reads an Vector from a DataInput. * * @throws IOException A problem occurs while reading from in * @throws ClassNotFoundException The class of one of the Vector's elements cannot be * found. * * @see #writeVector * @since GemFire 5.7 */ public static Vector readVector(DataInput in) throws IOException, ClassNotFoundException { InternalDataSerializer.checkIn(in); int size = InternalDataSerializer.readArrayLength(in); if (size == -1) { return null; } else { Vector list = new Vector<>(size); for (int i = 0; i < size; i++) { E element = DataSerializer.readObject(in); list.add(element); } if (logger.isTraceEnabled(LogMarker.SERIALIZER_VERBOSE)) { logger.trace(LogMarker.SERIALIZER_VERBOSE, "Read Vector with {} elements: {}", size, list); } return list; } } /** * Writes an Stack to a DataOutput. Note that even though * list may be an instance of a subclass of Stack, * readStack will always return an instance of Stack, not an * instance of the subclass. To preserve the class type of list, * {@link #writeObject(Object, DataOutput)} should be used for data serialization. * * @throws IOException A problem occurs while writing to out * * @see #readStack * @since GemFire 5.7 */ public static void writeStack(Stack list, DataOutput out) throws IOException { InternalDataSerializer.checkOut(out); int size; if (list == null) { size = -1; } else { size = list.size(); } InternalDataSerializer.writeArrayLength(size, out); if (logger.isTraceEnabled(LogMarker.SERIALIZER_VERBOSE)) { logger.trace(LogMarker.SERIALIZER_VERBOSE, "Writing Stack with {} elements: {}", size, list); } if (size > 0) { for (int i = 0; i < size; i++) { writeObject(list.get(i), out); } } } /** * Reads an Stack from a DataInput. * * @throws IOException A problem occurs while reading from in * @throws ClassNotFoundException The class of one of the Stack's elements cannot be * found. * * @see #writeStack * @since GemFire 5.7 */ public static Stack readStack(DataInput in) throws IOException, ClassNotFoundException { InternalDataSerializer.checkIn(in); int size = InternalDataSerializer.readArrayLength(in); if (size == -1) { return null; } else { Stack list = new Stack<>(); for (int i = 0; i < size; i++) { E element = DataSerializer.readObject(in); list.add(element); } if (logger.isTraceEnabled(LogMarker.SERIALIZER_VERBOSE)) { logger.trace(LogMarker.SERIALIZER_VERBOSE, "Read Stack with {} elements: {}", size, list); } return list; } } /** * Writes an LinkedList to a DataOutput. Note that even though * list may be an instance of a subclass of LinkedList, * readLinkedList will always return an instance of LinkedList, * not an instance of the subclass. To preserve the class type of list, * {@link #writeObject(Object, DataOutput)} should be used for data serialization. This method * will serialize a null list and not throw a NullPointerException. * * @throws IOException A problem occurs while writing to out * * @see #readLinkedList */ public static void writeLinkedList(LinkedList list, DataOutput out) throws IOException { InternalDataSerializer.checkOut(out); int size; if (list == null) { size = -1; } else { size = list.size(); } InternalDataSerializer.writeArrayLength(size, out); if (logger.isTraceEnabled(LogMarker.SERIALIZER_VERBOSE)) { logger.trace(LogMarker.SERIALIZER_VERBOSE, "Writing LinkedList with {} elements: {}", size, list); } if (size > 0) { for (Object e : list) { writeObject(e, out); } } } /** * Reads an LinkedList from a DataInput. * * @throws IOException A problem occurs while reading from in * @throws ClassNotFoundException The class of one of the LinkedList's elements * cannot be found. * * @see #writeLinkedList */ public static LinkedList readLinkedList(DataInput in) throws IOException, ClassNotFoundException { InternalDataSerializer.checkIn(in); int size = InternalDataSerializer.readArrayLength(in); if (size == -1) { return null; } else { LinkedList list = new LinkedList<>(); for (int i = 0; i < size; i++) { E element = DataSerializer.readObject(in); list.add(element); } if (logger.isTraceEnabled(LogMarker.SERIALIZER_VERBOSE)) { logger.trace(LogMarker.SERIALIZER_VERBOSE, "Read LinkedList with {} elements: {}", size, list); } return list; } } /** * Writes a HashSet to a DataOutput. Note that even though * set may be an instance of a subclass of HashSet, * readHashSet will always return an instance of HashSet, not an * instance of the subclass. To preserve the class type of set, * {@link #writeObject(Object, DataOutput)} should be used for data serialization. This method * will serialize a null set and not throw a NullPointerException. * * @throws IOException A problem occurs while writing to out * * @see #readHashSet */ public static void writeHashSet(HashSet set, DataOutput out) throws IOException { InternalDataSerializer.writeSet(set, out); } /** * Reads a HashSet from a DataInput. * * @throws IOException A problem occurs while reading from in * @throws ClassNotFoundException The class of one of the HashSet's elements cannot * be found. * * @see #writeHashSet */ public static HashSet readHashSet(DataInput in) throws IOException, ClassNotFoundException { InternalDataSerializer.checkIn(in); int size = InternalDataSerializer.readArrayLength(in); if (size == -1) { return null; } else { HashSet set = new HashSet<>(size); for (int i = 0; i < size; i++) { E element = DataSerializer.readObject(in); set.add(element); } if (logger.isTraceEnabled(LogMarker.SERIALIZER_VERBOSE)) { logger.trace(LogMarker.SERIALIZER_VERBOSE, "Read HashSet with {} elements: {}", size, set); } return set; } } /** * Writes a LinkedHashSet to a DataOutput. Note that even though * set may be an instance of a subclass of LinkedHashSet, * readLinkedHashSet will always return an instance of LinkedHashSet, * not an instance of the subclass. To preserve the class type of set, * {@link #writeObject(Object, DataOutput)} should be used for data serialization. * * @throws IOException A problem occurs while writing to out * * @see #readLinkedHashSet * @since GemFire 5.7 */ public static void writeLinkedHashSet(LinkedHashSet set, DataOutput out) throws IOException { InternalDataSerializer.writeSet(set, out); } /** * Reads a LinkedHashSet from a DataInput. * * @throws IOException A problem occurs while reading from in * @throws ClassNotFoundException The class of one of the LinkedHashSet's elements * cannot be found. * * @see #writeLinkedHashSet * @since GemFire 5.7 */ public static LinkedHashSet readLinkedHashSet(DataInput in) throws IOException, ClassNotFoundException { InternalDataSerializer.checkIn(in); int size = InternalDataSerializer.readArrayLength(in); if (size == -1) { return null; } else { LinkedHashSet set = new LinkedHashSet<>(size); for (int i = 0; i < size; i++) { E element = DataSerializer.readObject(in); set.add(element); } if (logger.isTraceEnabled(LogMarker.SERIALIZER_VERBOSE)) { logger.trace(LogMarker.SERIALIZER_VERBOSE, "Read LinkedHashSet with {} elements: {}", size, set); } return set; } } /** * Writes a HashMap to a DataOutput. Note that even though * map may be an instance of a subclass of HashMap, * readHashMap will always return an instance of HashMap, not an * instance of the subclass. To preserve the class type of map, * {@link #writeObject(Object, DataOutput)} should be used for data serialization. This method * will serialize a null map and not throw a NullPointerException. * * @throws IOException A problem occurs while writing to out * * @see #readHashMap */ public static void writeHashMap(Map map, DataOutput out) throws IOException { InternalDataSerializer.checkOut(out); int size; if (map == null) { size = -1; } else { size = map.size(); } InternalDataSerializer.writeArrayLength(size, out); if (logger.isTraceEnabled(LogMarker.SERIALIZER_VERBOSE)) { logger.trace(LogMarker.SERIALIZER_VERBOSE, "Writing HashMap with {} elements: {}", size, map); } if (size > 0) { for (Map.Entry entry : map.entrySet()) { writeObject(entry.getKey(), out); writeObject(entry.getValue(), out); } } } /** * Reads a HashMap from a DataInput. * * @throws IOException A problem occurs while reading from in * @throws ClassNotFoundException The class of one of the HashMap's elements cannot * be found. * * @see #writeHashMap */ public static HashMap readHashMap(DataInput in) throws IOException, ClassNotFoundException { InternalDataSerializer.checkIn(in); int size = InternalDataSerializer.readArrayLength(in); if (size == -1) { return null; } else { HashMap map = new HashMap<>(size); for (int i = 0; i < size; i++) { K key = DataSerializer.readObject(in); V value = DataSerializer.readObject(in); map.put(key, value); } if (logger.isTraceEnabled(LogMarker.SERIALIZER_VERBOSE)) { logger.trace(LogMarker.SERIALIZER_VERBOSE, "Read HashMap with {} elements: {}", size, map); } return map; } } /** * Writes a IdentityHashMap to a DataOutput. Note that even though * map may be an instance of a subclass of IdentityHashMap, * readIdentityHashMap will always return an instance of * IdentityHashMap, not an instance of the subclass. To preserve the class * type of map, {@link #writeObject(Object, DataOutput)} should be used for data * serialization. * * @throws IOException A problem occurs while writing to out * * @see #readIdentityHashMap */ public static void writeIdentityHashMap(IdentityHashMap map, DataOutput out) throws IOException { InternalDataSerializer.checkOut(out); int size; if (map == null) { size = -1; } else { size = map.size(); } InternalDataSerializer.writeArrayLength(size, out); if (logger.isTraceEnabled(LogMarker.SERIALIZER_VERBOSE)) { logger.trace(LogMarker.SERIALIZER_VERBOSE, "Writing IdentityHashMap with {} elements: {}", size, map); } if (size > 0) { for (Map.Entry entry : map.entrySet()) { writeObject(entry.getKey(), out); writeObject(entry.getValue(), out); } } } /** * Reads a IdentityHashMap from a DataInput. Note that key identity is * not preserved unless the keys belong to a class whose serialization preserves identity. * * @throws IOException A problem occurs while reading from in * @throws ClassNotFoundException The class of one of the IdentityHashMap's elements * cannot be found. * * @see #writeIdentityHashMap */ public static IdentityHashMap readIdentityHashMap(DataInput in) throws IOException, ClassNotFoundException { InternalDataSerializer.checkIn(in); int size = InternalDataSerializer.readArrayLength(in); if (size == -1) { return null; } else { IdentityHashMap map = new IdentityHashMap<>(size); for (int i = 0; i < size; i++) { K key = DataSerializer.readObject(in); V value = DataSerializer.readObject(in); map.put(key, value); } if (logger.isTraceEnabled(LogMarker.SERIALIZER_VERBOSE)) { logger.trace(LogMarker.SERIALIZER_VERBOSE, "Read IdentityHashMap with {} elements: {}", size, map); } return map; } } /** * Writes a ConcurrentHashMap to a DataOutput. Note that even though * map may be an instance of a subclass of ConcurrentHashMap, * readConcurrentHashMap will always return an instance of * ConcurrentHashMap, not an instance of the subclass. To preserve the class * type of map, {@link #writeObject(Object, DataOutput)} should be used for data * serialization. *

* At this time if {@link #writeObject(Object, DataOutput)} is called with an instance of * ConcurrentHashMap then it will be serialized with normal java.io Serialization. So if you want * the keys and values of a ConcurrentHashMap to take advantage of GemFire serialization it must * be serialized with this method. * * @throws IOException A problem occurs while writing to out * * @see #readConcurrentHashMap * @since GemFire 6.6 */ public static void writeConcurrentHashMap(ConcurrentHashMap map, DataOutput out) throws IOException { InternalDataSerializer.checkOut(out); int size; Collection> entrySnapshot = null; if (map == null) { size = -1; } else { entrySnapshot = new ArrayList<>(map.entrySet()); size = entrySnapshot.size(); } InternalDataSerializer.writeArrayLength(size, out); if (logger.isTraceEnabled(LogMarker.SERIALIZER_VERBOSE)) { logger.trace(LogMarker.SERIALIZER_VERBOSE, "Writing ConcurrentHashMap with {} elements: {}", size, entrySnapshot); } if (size > 0) { for (Map.Entry entry : entrySnapshot) { writeObject(entry.getKey(), out); writeObject(entry.getValue(), out); } } } /** * Reads a ConcurrentHashMap from a DataInput. * * @throws IOException A problem occurs while reading from in * @throws ClassNotFoundException The class of one of the ConcurrentHashMap's * elements cannot be found. * * @see #writeConcurrentHashMap * @since GemFire 6.6 */ public static ConcurrentHashMap readConcurrentHashMap(DataInput in) throws IOException, ClassNotFoundException { InternalDataSerializer.checkIn(in); int size = InternalDataSerializer.readArrayLength(in); if (size == -1) { return null; } else { ConcurrentHashMap map = new ConcurrentHashMap<>(size); for (int i = 0; i < size; i++) { K key = DataSerializer.readObject(in); V value = DataSerializer.readObject(in); map.put(key, value); } if (logger.isTraceEnabled(LogMarker.SERIALIZER_VERBOSE)) { logger.trace(LogMarker.SERIALIZER_VERBOSE, "Read ConcurrentHashMap with {} elements: {}", size, map); } return map; } } /** * Writes a Hashtable to a DataOutput. Note that even though * map may be an instance of a subclass of Hashtable, * readHashtable will always return an instance of Hashtable, not * an instance of the subclass. To preserve the class type of map, * {@link #writeObject(Object, DataOutput)} should be used for data serialization. * * @throws IOException A problem occurs while writing to out * * @see #readHashtable * @since GemFire 5.7 */ public static void writeHashtable(Hashtable map, DataOutput out) throws IOException { InternalDataSerializer.checkOut(out); int size; if (map == null) { size = -1; } else { size = map.size(); } InternalDataSerializer.writeArrayLength(size, out); if (logger.isTraceEnabled(LogMarker.SERIALIZER_VERBOSE)) { logger.trace(LogMarker.SERIALIZER_VERBOSE, "Writing Hashtable with {} elements: {}", size, map); } if (size > 0) { for (Map.Entry entry : map.entrySet()) { writeObject(entry.getKey(), out); writeObject(entry.getValue(), out); } } } /** * Reads a Hashtable from a DataInput. * * @throws IOException A problem occurs while reading from in * @throws ClassNotFoundException The class of one of the Hashtable's elements cannot * be found. * * @see #writeHashtable * @since GemFire 5.7 */ public static Hashtable readHashtable(DataInput in) throws IOException, ClassNotFoundException { InternalDataSerializer.checkIn(in); int size = InternalDataSerializer.readArrayLength(in); if (size == -1) { return null; } else { Hashtable map = new Hashtable<>(size); for (int i = 0; i < size; i++) { K key = DataSerializer.readObject(in); V value = DataSerializer.readObject(in); map.put(key, value); } if (logger.isTraceEnabled(LogMarker.SERIALIZER_VERBOSE)) { logger.trace(LogMarker.SERIALIZER_VERBOSE, "Read Hashtable with {} elements: {}", size, map); } return map; } } /** * Writes a TreeMap to a DataOutput. Note that even though * map may be an instance of a subclass of TreeMap, * readTreeMap will always return an instance of TreeMap, not an * instance of the subclass. To preserve the class type of map, * {@link #writeObject(Object, DataOutput)} should be used for data serialization. *

* If the map has a comparator then it must also be serializable. * * @throws IOException A problem occurs while writing to out * * @see #readTreeMap * @since GemFire 5.7 */ public static void writeTreeMap(TreeMap map, DataOutput out) throws IOException { InternalDataSerializer.checkOut(out); int size; if (map == null) { size = -1; } else { size = map.size(); } InternalDataSerializer.writeArrayLength(size, out); if (logger.isTraceEnabled(LogMarker.SERIALIZER_VERBOSE)) { logger.trace(LogMarker.SERIALIZER_VERBOSE, "Writing TreeMap with {} elements: {}", size, map); } if (size >= 0) { writeObject(map.comparator(), out); for (Map.Entry entry : map.entrySet()) { writeObject(entry.getKey(), out); writeObject(entry.getValue(), out); } } } /** * Reads a TreeMap from a DataInput. * * @throws IOException A problem occurs while reading from in * @throws ClassNotFoundException The class of one of the TreeMap's elements cannot * be found. * * @see #writeTreeMap * @since GemFire 5.7 */ public static TreeMap readTreeMap(DataInput in) throws IOException, ClassNotFoundException { InternalDataSerializer.checkIn(in); int size = InternalDataSerializer.readArrayLength(in); if (size == -1) { return null; } else { Comparator c = InternalDataSerializer.readNonPdxInstanceObject(in); TreeMap map = new TreeMap<>(c); for (int i = 0; i < size; i++) { K key = DataSerializer.readObject(in); V value = DataSerializer.readObject(in); map.put(key, value); } if (logger.isTraceEnabled(LogMarker.SERIALIZER_VERBOSE)) { logger.trace(LogMarker.SERIALIZER_VERBOSE, "Read TreeMap with {} elements: {}", size, map); } return map; } } /** * Writes a LinkedHashMap to a DataOutput. Note that even though * map may be an instance of a subclass of LinkedHashMap, * readLinkedHashMap will always return an instance of LinkedHashMap, * not an instance of the subclass. To preserve the class type of map, * {@link #writeObject(Object, DataOutput)} should be used for data serialization. This method * will serialize a null map and not throw a NullPointerException. * * @throws IOException A problem occurs while writing to out * @see #readLinkedHashMap */ public static void writeLinkedHashMap(Map map, DataOutput out) throws IOException { InternalDataSerializer.checkOut(out); int size; if (map == null) { size = -1; } else { size = map.size(); } InternalDataSerializer.writeArrayLength(size, out); if (logger.isTraceEnabled(LogMarker.SERIALIZER_VERBOSE)) { logger.trace(LogMarker.SERIALIZER_VERBOSE, "Writing LinkedHashMap with {} elements: {}", size, map); } if (size > 0) { for (Map.Entry entry : map.entrySet()) { writeObject(entry.getKey(), out); writeObject(entry.getValue(), out); } } } /** * Reads a LinkedHashMap from a DataInput. * * @throws IOException A problem occurs while reading from in * @throws ClassNotFoundException The class of one of the HashMap's elements cannot * be found. * @see #writeLinkedHashMap */ public static LinkedHashMap readLinkedHashMap(DataInput in) throws IOException, ClassNotFoundException { InternalDataSerializer.checkIn(in); int size = InternalDataSerializer.readArrayLength(in); if (size == -1) { return null; } else { LinkedHashMap map = new LinkedHashMap<>(size); for (int i = 0; i < size; i++) { K key = DataSerializer.readObject(in); V value = DataSerializer.readObject(in); map.put(key, value); } if (logger.isTraceEnabled(LogMarker.SERIALIZER_VERBOSE)) { logger.trace(LogMarker.SERIALIZER_VERBOSE, "Read LinkedHashMap with {} elements: {}", size, map); } return map; } } /** * Writes a TreeSet to a DataOutput. Note that even though * set may be an instance of a subclass of TreeSet, * readTreeSet will always return an instance of TreeSet, not an * instance of the subclass. To preserve the class type of set, * {@link #writeObject(Object, DataOutput)} should be used for data serialization. *

* If the set has a comparator then it must also be serializable. * * @throws IOException A problem occurs while writing to out * * @see #readTreeSet */ public static void writeTreeSet(TreeSet set, DataOutput out) throws IOException { InternalDataSerializer.checkOut(out); int size; if (set == null) { size = -1; } else { size = set.size(); } InternalDataSerializer.writeArrayLength(size, out); if (logger.isTraceEnabled(LogMarker.SERIALIZER_VERBOSE)) { logger.trace(LogMarker.SERIALIZER_VERBOSE, "Writing TreeSet with {} elements: {}", size, set); } if (size >= 0) { writeObject(set.comparator(), out); for (Object e : set) { writeObject(e, out); } } } /** * Reads a TreeSet from a DataInput. * * @throws IOException A problem occurs while reading from in * @throws ClassNotFoundException The class of one of the TreeSet's elements cannot * be found. * * @see #writeTreeSet */ public static TreeSet readTreeSet(DataInput in) throws IOException, ClassNotFoundException { InternalDataSerializer.checkIn(in); int size = InternalDataSerializer.readArrayLength(in); if (size == -1) { return null; } else { Comparator c = InternalDataSerializer.readNonPdxInstanceObject(in); TreeSet set = new TreeSet<>(c); for (int i = 0; i < size; i++) { E element = DataSerializer.readObject(in); set.add(element); } if (logger.isTraceEnabled(LogMarker.SERIALIZER_VERBOSE)) { logger.trace(LogMarker.SERIALIZER_VERBOSE, "Read TreeSet with {} elements: {}", size, set); } return set; } } /** * Writes a Properties to a DataOutput. *

* NOTE: The defaults of the specified props are not serialized. *

* Note that even though props may be an instance of a subclass of * Properties, readProperties will always return an instance of * Properties, not an instance of the subclass. To preserve the class type of * props, {@link #writeObject(Object, DataOutput)} should be used for data * serialization. * * @throws IOException A problem occurs while writing to out * * @see #readProperties */ public static void writeProperties(Properties props, DataOutput out) throws IOException { InternalDataSerializer.checkOut(out); Set> s; int size; if (props == null) { s = null; size = -1; } else { s = props.entrySet(); size = s.size(); } InternalDataSerializer.writeArrayLength(size, out); if (logger.isTraceEnabled(LogMarker.SERIALIZER_VERBOSE)) { logger.trace(LogMarker.SERIALIZER_VERBOSE, "Writing Properties with {} elements: {}", size, props); } if (size > 0) { for (Map.Entry entry : s) { // although we should have just String instances in a Properties // object our security code stores byte[] instances in them // so the following code must use writeObject instead of writeString. Object key = entry.getKey(); Object val = entry.getValue(); writeObject(key, out); writeObject(val, out); } } } /** * Reads a Properties from a DataInput. *

* NOTE: the defaults are always empty in the returned Properties. * * * @throws IOException A problem occurs while reading from in * * @see #writeProperties */ public static Properties readProperties(DataInput in) throws IOException, ClassNotFoundException { InternalDataSerializer.checkIn(in); int size = InternalDataSerializer.readArrayLength(in); if (size == -1) { return null; } else { Properties props = new Properties(); for (int index = 0; index < size; index++) { Object key = readObject(in); Object value = readObject(in); props.put(key, value); } if (logger.isTraceEnabled(LogMarker.SERIALIZER_VERBOSE)) { logger.trace(LogMarker.SERIALIZER_VERBOSE, "Read Properties with {} elements: {}", size, props); } return props; } } // since 5.7 moved all time unit code to InternalDataSerializer // since the TimeUnit class is part of the non-public backport. /** * Writes an arbitrary object to a DataOutput. If o is not an instance * of a specially-handled standard Java class (see the list in {@link #getSupportedClasses}), the * {@link DataSerializer#toData toData} method of each registered DataSerializer is * invoked until the object is serialized. If no registered serializer can serialize the object * and o does not implement DataSerializable, then it is serialized to * out using standard Java {@linkplain java.io.Serializable serialization}. This * method will serialize a null o and not throw a NullPointerException. * * @param allowJavaSerialization If false, then a NotSerializableException is thrown in the case * where standard Java serialization would otherwise be used for object o or * for any nested subobject of o. This is used to prevent Java serialization * from being used when sending data to a non-Java client * @throws IOException A problem occurs while writing o to out * * @see #readObject(DataInput) * @see Instantiator * @see ObjectOutputStream#writeObject */ public static void writeObject(Object o, DataOutput out, boolean allowJavaSerialization) throws IOException { if (allowJavaSerialization) { writeObject(o, out); return; } DISALLOW_JAVA_SERIALIZATION.set(Boolean.TRUE); try { writeObject(o, out); } finally { DISALLOW_JAVA_SERIALIZATION.set(Boolean.FALSE); // with JDK 1.5 this can be changed to // remove() } } /** * Writes an arbitrary object to a DataOutput. If o is not an instance * of a specially-handled standard Java class (such as Date, Integer, or * ArrayList), the {@link DataSerializer#toData toData} method of each registered * DataSerializer is invoked until the object is serialized. If no registered * serializer can serialize the object and o does not implement * DataSerializable, then it is serialized to out using standard Java * {@linkplain java.io.Serializable serialization}. This method will serialize a null * o and not throw a NullPointerException. * * @throws IOException A problem occurs while writing o to out * * @see #readObject(DataInput) * @see DataSerializer * @see ObjectOutputStream#writeObject */ public static void writeObject(Object o, DataOutput out) throws IOException { InternalDataSerializer.basicWriteObject(o, out, false); } /** * Reads an arbitrary object from a DataInput. Instances of classes that are not * handled specially (such as String, Class, and * DataSerializable) are read using standard Java {@linkplain java.io.Serializable * serialization}. * *

* * Note that if an object is deserialized using standard Java serialization, its class will be * loaded using the current thread's {@link Thread#getContextClassLoader context class loader} * before the one normally used by Java serialization is consulted. * * @throws IOException A problem occurred while reading from in (may wrap another * exception) * @throws ClassNotFoundException The class of an object read from in could not be * found * * @see #writeObject(Object, DataOutput) * @see ObjectInputStream#readObject */ @SuppressWarnings("unchecked") public static T readObject(final DataInput in) throws IOException, ClassNotFoundException { return (T) InternalDataSerializer.basicReadObject(in); } /** * Registers a DataSerializer class with the data serialization framework. This * method uses reflection to create an instance of the DataSerializer class by * invoking its zero-argument constructor. * *

* * The DataSerializer instance will be consulted by the * {@link #writeObject(Object, DataOutput)} and {@link #readObject} methods. Note that no two * serializers can support the same class. *

* * This method invokes the DataSerializer instance's {@link #getSupportedClasses} * method and keeps track of which classes can have their instances serialized by by this data * serializer. * * @param c the DataSerializer class to create and register with the data * serialization framework. * @return the registered serializer instance * * @throws IllegalArgumentException If c does not subclass * DataSerializer, if c does not have a zero-argument * constructor, if id is 0, if getSupportedClasses returns null or an empty * array, if getSupportedClasses returns and array with null elements * @throws IllegalStateException if another serializer instance with id id has * already been registered, if another serializer instance that supports one of this * instances classes has already been registered, if an attempt is made to support any of * the classes reserved by DataSerializer (see {@link #getSupportedClasses} for a list). * @see #getSupportedClasses */ @SuppressWarnings("unchecked") public static DataSerializer register(Class c) { return InternalDataSerializer.register((Class) c, true); } /** * Creates a new DataSerializer. All class that implement DataSerializer * must provide a zero-argument constructor. * * @see #register(Class) */ public DataSerializer() { // nothing } /** * Returns the Classes whose instances are data serialized by this * DataSerializer. This method is invoked when this serializer is * {@linkplain #register(Class) registered}. This method is not allowed to return * null nor an empty array. Only instances whose class name is the same as one of the * class names in the result will be serialized by this DataSerializer. Two * DataSerializers are not allowed to support the same class. The following classes * can not be supported by user defined data serializers since they are all supported by the * predefined data serializer: *

    *
  • {@link java.lang.Class} *
  • {@link java.lang.String} *
  • {@link java.lang.Boolean} *
  • {@link java.lang.Byte} *
  • {@link java.lang.Character} *
  • {@link java.lang.Short} *
  • {@link java.lang.Integer} *
  • {@link java.lang.Long} *
  • {@link java.lang.Float} *
  • {@link java.lang.Double} *
  • {@link java.io.File} *
  • {@link java.net.InetAddress} *
  • {@link java.net.Inet4Address} *
  • {@link java.net.Inet6Address} *
  • {@link java.util.ArrayList} *
  • {@link java.util.Date} *
  • {@link java.util.HashMap} *
  • {@link java.util.IdentityHashMap} *
  • {@link java.util.HashSet} *
  • {@link java.util.Hashtable} *
  • {@link java.util.LinkedHashSet} *
  • {@link java.util.LinkedList} *
  • {@link java.util.Properties} *
  • {@link java.util.TreeMap} *
  • {@link java.util.TreeSet} *
  • {@link java.util.Vector} *
  • any array class *
*/ public abstract Class[] getSupportedClasses(); /** * Data serializes an object to a DataOutput. It is very important that when * performing the "switch" on o's class, your code test for a subclass before it * tests for a superclass. Otherwise, the incorrect class id could be written to the serialization * stream. * * @param o The object to data serialize. It will never be null. * * @return false if this DataSerializer does not know how to data * serialize o. */ public abstract boolean toData(Object o, DataOutput out) throws IOException; /** * Reads an object from a DataInput. This implementation must support deserializing * everything serialized by the matching {@link #toData}. * * @throws IOException If this serializer cannot read an object from in. * * @see #toData */ public abstract Object fromData(DataInput in) throws IOException, ClassNotFoundException; /** * Returns the id of this DataSerializer. *

* Returns an int instead of a byte since 5.7. */ public abstract int getId(); /** * Two DataSerializers are consider to be equal if they have the same id and the same * class */ @Override public boolean equals(Object o) { if (o instanceof DataSerializer) { DataSerializer oDS = (DataSerializer) o; return oDS.getId() == getId() && getClass().equals(oDS.getClass()); } else { return false; } } @Override public int hashCode() { return getId(); } /** * For internal use only. Sets the unique eventId of this * DataSerializer. * * @since GemFire 6.5 */ public void setEventId(Object/* EventID */ eventId) { this.eventId = (EventID) eventId; } /** * For internal use only. Returns the unique eventId of this * DataSerializer. * * @since GemFire 6.5 */ public Object/* EventID */ getEventId() { return this.eventId; } /** * For internal use only. Sets the context of this DataSerializer. * * @since GemFire 6.5 */ public void setContext(Object/* ClientProxyMembershipID */ context) { this.context = (ClientProxyMembershipID) context; } /** * For internal use only. Returns the context of this DataSerializer. * * @since GemFire 6.5 */ public Object/* ClientProxyMembershipID */ getContext() { return this.context; } /** * maps a class to its enum constants. */ @MakeNotStatic private static final ConcurrentMap, Enum[]> knownEnums = new ConcurrentHashMap<>(); /** * gets the enum constants for the given class. {@link Class#getEnumConstants()} uses reflection, * so we keep around the class to enumConstants mapping in the {@link #knownEnums} map * * @return enum constants for the given class */ @SuppressWarnings("unchecked") private static E[] getEnumConstantsForClass(Class clazz) { E[] returnVal = (E[]) knownEnums.get(clazz); if (returnVal == null) { returnVal = clazz.getEnumConstants(); knownEnums.put(clazz, returnVal); } return returnVal; } /** * Writes the Enum constant to DataOutput. Unlike standard java * serialization which serializes both the enum name String and the ordinal, GemFire only * serializes the ordinal byte, so for backward compatibility new enum constants should only be * added to the end of the enum type.
* Example: DataSerializer.writeEnum(DAY_OF_WEEK.SUN, out); * * @see #readEnum(Class, DataInput) * @since GemFire 6.5 */ public static void writeEnum(Enum e, DataOutput out) throws IOException { InternalDataSerializer.checkOut(out); if (e == null) { throw new NullPointerException( "The enum constant to serialize is null"); } if (logger.isTraceEnabled(LogMarker.SERIALIZER_VERBOSE)) { logger.trace(LogMarker.SERIALIZER_VERBOSE, "Writing enum {}", e); } InternalDataSerializer.writeArrayLength(e.ordinal(), out); } /** * Reads a Enum constant from DataInput. Unlike standard java * serialization which serializes both the enum name String and the ordinal, GemFire only * serializes the ordinal byte, so be careful about using the correct enum class. Also, for * backward compatibility new enum constants should only be added to the end of the enum * type.
* Example: DAY_OF_WEEK d = DataSerializer.readEnum(DAY_OF_WEEK.class, in); * * @since GemFire 6.5 * @see #writeEnum(Enum, DataOutput) * @throws IOException A problem occurs while writing to out * @throws ArrayIndexOutOfBoundsException if the wrong enum class/enum class with a different * version and less enum constants is used */ public static > E readEnum(Class clazz, DataInput in) throws IOException { InternalDataSerializer.checkIn(in); if (clazz == null) { throw new NullPointerException( "the enum class to deserialize is null"); } else if (!clazz.isEnum()) { throw new IllegalArgumentException( String.format("Class %s is not an enum", clazz.getName())); } int ordinal = InternalDataSerializer.readArrayLength(in); return getEnumConstantsForClass(clazz)[ordinal]; } }





© 2015 - 2024 Weber Informatics LLC | Privacy Policy