org.bitcoinj.core

Class MessageSerializer

java.lang.Object

org.bitcoinj.core.MessageSerializer

Direct Known Subclasses:

BitcoinSerializer

public abstract class MessageSerializer
extends Object

Generic interface for classes which serialize/deserialize messages. Implementing classes should be immutable.

Constructor Summary

Constructors

Constructor and Description
MessageSerializer()

Method Summary

Modifier and Type	Method and Description
abstract Message	deserialize(ByteBuffer in) Reads a message from the given ByteBuffer and returns it.
abstract BitcoinSerializer.BitcoinPacketHeader	deserializeHeader(ByteBuffer in) Deserializes only the header in case packet meta data is needed before decoding the payload.
abstract Message	deserializePayload(BitcoinSerializer.BitcoinPacketHeader header, ByteBuffer in) Deserialize payload only.
abstract boolean	isParseRetainMode() Whether the serializer will produce cached mode Messages
abstract AddressMessage	makeAddressMessage(byte[] payloadBytes, int length) Make an address message from the payload.
abstract Message	makeAlertMessage(byte[] payloadBytes) Make an alert message from the payload.
Block	makeBlock(byte[] payloadBytes) Make a block from the payload, using an offset of zero and the payload length as block length.
Block	makeBlock(byte[] payloadBytes, int length) Make a block from the payload, using an offset of zero and the provided length as block length.
abstract Block	makeBlock(byte[] payloadBytes, int offset, int length) Make a block from the payload, using an offset of zero and the provided length as block length.
abstract Message	makeBloomFilter(byte[] payloadBytes) Make an filter message from the payload.
abstract FilteredBlock	makeFilteredBlock(byte[] payloadBytes) Make a filtered block from the payload.
abstract InventoryMessage	makeInventoryMessage(byte[] payloadBytes, int length) Make an inventory message from the payload.
Transaction	makeTransaction(byte[] payloadBytes) Make a transaction from the payload.
Transaction	makeTransaction(byte[] payloadBytes, int offset) Make a transaction from the payload.
abstract Transaction	makeTransaction(byte[] payloadBytes, int offset, int length, byte[] hash) Make a transaction from the payload.
abstract void	seekPastMagicBytes(ByteBuffer in)
abstract void	serialize(Message message, OutputStream out) Writes message to to the output stream.
abstract void	serialize(String name, byte[] message, OutputStream out) Writes message to to the output stream.

Methods inherited from class java.lang.Object

clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Constructor Detail

MessageSerializer

public MessageSerializer()

Method Detail

deserialize

public abstract Message deserialize(ByteBuffer in)
                             throws ProtocolException,
                                    IOException,
                                    UnsupportedOperationException

Reads a message from the given ByteBuffer and returns it.

Throws:

ProtocolException

IOException

UnsupportedOperationException

deserializeHeader

public abstract BitcoinSerializer.BitcoinPacketHeader deserializeHeader(ByteBuffer in)
                                                                 throws ProtocolException,
                                                                        IOException,
                                                                        UnsupportedOperationException

Deserializes only the header in case packet meta data is needed before decoding the payload. This method assumes you have already called seekPastMagicBytes()

Throws:

ProtocolException

IOException

UnsupportedOperationException

deserializePayload

public abstract Message deserializePayload(BitcoinSerializer.BitcoinPacketHeader header,
                                           ByteBuffer in)
                                    throws ProtocolException,
                                           BufferUnderflowException,
                                           UnsupportedOperationException

Deserialize payload only. You must provide a header, typically obtained by calling BitcoinSerializer.deserializeHeader(java.nio.ByteBuffer).

Throws:

ProtocolException

BufferUnderflowException

UnsupportedOperationException

isParseRetainMode

public abstract boolean isParseRetainMode()

Whether the serializer will produce cached mode Messages

makeAddressMessage

public abstract AddressMessage makeAddressMessage(byte[] payloadBytes,
                                                  int length)
                                           throws ProtocolException,
                                                  UnsupportedOperationException

Make an address message from the payload. Extension point for alternative serialization format support.

Throws:

ProtocolException

UnsupportedOperationException

makeAlertMessage

public abstract Message makeAlertMessage(byte[] payloadBytes)
                                  throws ProtocolException,
                                         UnsupportedOperationException

Make an alert message from the payload. Extension point for alternative serialization format support.

Throws:

ProtocolException

UnsupportedOperationException

makeBlock

public final Block makeBlock(byte[] payloadBytes)
                      throws ProtocolException

Make a block from the payload, using an offset of zero and the payload length as block length.

Throws:

ProtocolException

makeBlock

public final Block makeBlock(byte[] payloadBytes,
                             int length)
                      throws ProtocolException

Make a block from the payload, using an offset of zero and the provided length as block length.

Throws:

ProtocolException

makeBlock

public abstract Block makeBlock(byte[] payloadBytes,
                                int offset,
                                int length)
                         throws ProtocolException,
                                UnsupportedOperationException

Make a block from the payload, using an offset of zero and the provided length as block length. Extension point for alternative serialization format support.

Throws:

ProtocolException

UnsupportedOperationException

makeBloomFilter

public abstract Message makeBloomFilter(byte[] payloadBytes)
                                 throws ProtocolException,
                                        UnsupportedOperationException

Make an filter message from the payload. Extension point for alternative serialization format support.

Throws:

ProtocolException

UnsupportedOperationException

makeFilteredBlock

public abstract FilteredBlock makeFilteredBlock(byte[] payloadBytes)
                                         throws ProtocolException,
                                                UnsupportedOperationException

Make a filtered block from the payload. Extension point for alternative serialization format support.

Throws:

ProtocolException

UnsupportedOperationException

makeInventoryMessage

public abstract InventoryMessage makeInventoryMessage(byte[] payloadBytes,
                                                      int length)
                                               throws ProtocolException,
                                                      UnsupportedOperationException

Make an inventory message from the payload. Extension point for alternative serialization format support.

Throws:

ProtocolException

UnsupportedOperationException

makeTransaction

public abstract Transaction makeTransaction(byte[] payloadBytes,
                                            int offset,
                                            int length,
                                            byte[] hash)
                                     throws ProtocolException,
                                            UnsupportedOperationException

Make a transaction from the payload. Extension point for alternative serialization format support.

Throws:

UnsupportedOperationException - if this serializer/deserializer does not support deserialization. This can occur either because it's a dummy serializer (i.e. for messages with no network parameters), or because it does not support deserializing transactions.

ProtocolException

makeTransaction

public final Transaction makeTransaction(byte[] payloadBytes)
                                  throws ProtocolException,
                                         UnsupportedOperationException

Make a transaction from the payload. Extension point for alternative serialization format support.

Throws:

UnsupportedOperationException - if this serializer/deserializer does not support deserialization. This can occur either because it's a dummy serializer (i.e. for messages with no network parameters), or because it does not support deserializing transactions.

ProtocolException

makeTransaction

public final Transaction makeTransaction(byte[] payloadBytes,
                                         int offset)
                                  throws ProtocolException

Make a transaction from the payload. Extension point for alternative serialization format support.

Throws:

UnsupportedOperationException - if this serializer/deserializer does not support deserialization. This can occur either because it's a dummy serializer (i.e. for messages with no network parameters), or because it does not support deserializing transactions.

ProtocolException

seekPastMagicBytes

public abstract void seekPastMagicBytes(ByteBuffer in)
                                 throws BufferUnderflowException

Throws:

BufferUnderflowException

serialize

public abstract void serialize(String name,
                               byte[] message,
                               OutputStream out)
                        throws IOException,
                               UnsupportedOperationException

Writes message to to the output stream.

Throws:

UnsupportedOperationException - if this serializer/deserializer does not support serialization. This can occur either because it's a dummy serializer (i.e. for messages with no network parameters), or because it does not support serializing the given message.

IOException

serialize

public abstract void serialize(Message message,
                               OutputStream out)
                        throws IOException,
                               UnsupportedOperationException

Writes message to to the output stream.

Throws:

UnsupportedOperationException - if this serializer/deserializer does not support serialization. This can occur either because it's a dummy serializer (i.e. for messages with no network parameters), or because it does not support serializing the given message.

IOException