How to use

Message

in

io.protostuff

public UninitializedMessageException(String msg, Message<?> targetMessage)
{
  this(msg, targetMessage, targetMessage.cachedSchema());
}

public UninitializedMessageException(Message<?> targetMessage)
{
  this(targetMessage, targetMessage.cachedSchema());
}

@Override
protected <T> Schema<T> writeMessageIdTo(Output output, int fieldNumber,
    Message<T> message) throws IOException
{
  output.writeString(fieldNumber, message.getClass().getName(), false);
  return message.cachedSchema();
}

@Override
protected <T> Schema<T> writeMessageIdTo(Output output, int fieldNumber,
    Message<T> message) throws IOException
{
  output.writeString(fieldNumber, message.getClass().getName(), false);
  return message.cachedSchema();
}

/**
 * Serializes the {@code message} into an {@link OutputStream} via {@link JsonXOutput} with the supplied buffer.
 */
public static <T extends Message<T>> void writeTo(OutputStream out, T message, boolean numeric,
    LinkedBuffer buffer)
    throws IOException
{
  writeTo(out, message, message.cachedSchema(), numeric, buffer);
}

/**
 * Serializes the {@code message} into an {@link OutputStream} via {@link MsgpackXOutput} with the supplied buffer.
 */
public static <T extends Message<T>> void writeTo(OutputStream out, T message, boolean numeric,
    LinkedBuffer buffer)
    throws IOException
{
  writeTo(out, message, message.cachedSchema(), numeric, buffer);
}

@Override
@SuppressWarnings("unchecked")
protected <T> Schema<T> writeMessageIdTo(Output output, int fieldNumber,
    Message<T> message) throws IOException
{
  final BaseHS<T> wrapper = (BaseHS<T>) pojoMapping.get(message.getClass());
  if (wrapper == null)
    throw new UnknownTypeException("pojo: " + message.getClass());
  output.writeUInt32(fieldNumber, wrapper.id, false);
  // TODO allow the wrapper to return an override schema?
  return message.cachedSchema();
}

static <T extends Message<T>> Schema<T> getCachedSchema(Class<T> clazz)
    throws InstantiationException, IllegalAccessException
{
  Schema<T> schema = clazz.newInstance().cachedSchema();
  // System.err.println("! " + schema + " | " +
  // System.identityHashCode(schema));
  return schema;
}

@Override
@SuppressWarnings("unchecked")
protected <T> Schema<T> writeMessageIdTo(Output output, int fieldNumber,
    Message<T> message) throws IOException
{
  int id;
  BaseHS<T> wrapper = (BaseHS<T>) getSchemaWrapper(message.getClass(), true);
  // wait till everything is completely set
  while (0 == (id = wrapper.id))
    LockSupport.parkNanos(1);
  output.writeUInt32(fieldNumber, id, false);
  // TODO allow the wrapper to return an override schema?
  return message.cachedSchema();
}

@Override
@SuppressWarnings("unchecked")
public Schema<T> getSchema()
{
  Schema<T> schema = this.schema;
  if (schema == null)
  {
    synchronized (this)
    {
      if ((schema = this.schema) == null)
      {
        if (Message.class.isAssignableFrom(typeClass))
        {
          // use the message's schema.
          Message<T> m = (Message<T>) createMessageInstance(typeClass);
          this.schema = schema = m.cachedSchema();
        }
        else
        {
          // create new
          this.schema = schema = strategy
              .newSchema(typeClass);
        }
      }
    }
  }
  return schema;
}

@Override
@SuppressWarnings("unchecked")
public Schema<T> getSchema()
{
  Schema<T> schema = this.schema;
  if (schema == null)
  {
    synchronized (this)
    {
      if ((schema = this.schema) == null)
      {
        if (Message.class.isAssignableFrom(typeClass))
        {
          // use the message's schema.
          final Message<T> m = (Message<T>) createMessageInstance(typeClass);
          this.schema = schema = m.cachedSchema();
        }
        else
        {
          // create new
          this.schema = schema = strategy.newSchema(typeClass);
        }
      }
    }
  }
  return schema;
}

@Override
@SuppressWarnings("unchecked")
public Schema<T> getSchema()
{
  Schema<T> schema = this.schema;
  if (schema == null)
  {
    synchronized (this)
    {
      if ((schema = this.schema) == null)
      {
        if (Message.class.isAssignableFrom(typeClass))
        {
          // use the message's schema.
          final Message<T> m = (Message<T>) createMessageInstance(typeClass);
          this.schema = schema = m.cachedSchema();
        }
        else
        {
          // create new
          this.schema = schema = strategy.newSchema(typeClass);
        }
      }
    }
  }
  return schema;
}

@Override
@SuppressWarnings("unchecked")
public Schema<T> getSchema()
{
  Schema<T> schema = this.schema;
  if (schema == null)
  {
    synchronized (this)
    {
      if ((schema = this.schema) == null)
      {
        if (Message.class.isAssignableFrom(typeClass))
        {
          // use the message's schema.
          Message<T> m = (Message<T>) createMessageInstance(typeClass);
          this.schema = schema = m.cachedSchema();
        }
        else
        {
          // create new
          this.schema = schema = strategy
              .newSchema(typeClass);
        }
      }
    }
  }
  return schema;
}

@Override
public <T extends Message<T>> byte[] serialize(T message)
{
  return JsonIOUtil.toByteArray(message, message.cachedSchema(), false);
}

/**
 * Computes the serialized size of a message.
 */
public static <T extends Message<T>> int getSize(T message)
{
  return getSize(message, message.cachedSchema(), false);
}

/**
 * Computes the buffer size and serializes the {@code message} into a byte array.
 */
public static <T extends Message<T>> byte[] toByteArray(T message)
{
  return toByteArray(message, message.cachedSchema(), false);
}

@Override
public <T extends Message<T>> byte[] serialize(T message)
{
  return toByteArrayBufferedProtobuf(message, message.cachedSchema());
}

/**
 * Serializes the {@code message} into a byte array.
 */
protected <T extends Message<T>> byte[] toByteArray(T message)
{
  return toByteArray(message, message.cachedSchema());
}

/**
 * Serializes the {@code message} (delimited) into an {@link OutputStream} via {@link DeferredOutput} using the
 * given schema.
 */
protected abstract <T> void writeDelimitedTo(OutputStream out, T message, Schema<T> schema)
    throws IOException;

/**
 * Serializes the {@code message} into a byte array.
 */
protected <T extends Message<T>> byte[] toByteArray(T message)
{
  return toByteArray(message, message.cachedSchema());
}