org.apache.qpid.transport.codec
Interface Encoder

All Known Implementing Classes:
AbstractEncoder, BBEncoder

public interface Encoder

Encoder interface. Each concrete implementor must specify how to encode given values.


Method Summary
 void writeArray(List<Object> array)
          An array is an ordered sequence of values of the same type.
 void writeBin128(byte[] bytes)
          The bin128 type consists of 16 consecutive octets of opaque binary data.
 void writeByteRanges(RangeSet ranges)
           
 void writeDatetime(long l)
          The datetime type encodes a date and time using the 64 bit POSIX time_t format.
 void writeDouble(double aDouble)
          The double type encodes a double precision 64-bit floating point number.
 void writeFloat(float aFloat)
          The float type encodes a single precision 32-bit floating point number.
 void writeInt16(short aShort)
          The int16 type is a signed integral value encoded using a 16-bit two's complement representation in network byte order.
 void writeInt32(int anInt)
          The int32 type is a signed integral value encoded using a 32-bit two's complement representation in network byte order.
 void writeInt64(long aLong)
          The int64 type is a signed integral value encoded using a 64-bit two's complement representation in network byte order.
 void writeInt8(byte aByte)
          The int8 type is a signed integral value encoded using an 8-bit two's complement representation.
 void writeList(List<Object> list)
          A list is an ordered sequence of (type, value) pairs.
 void writeMagicNumber()
          Encodes the AMQP magic number.
 void writeMap(Map<String,Object> map)
          A map is a set of distinct keys where each key has an associated (type,value) pair.
 void writeSequenceNo(int s)
          The sequence-no type encodes, in network byte order, a serial number as defined in RFC-1982.
 void writeSequenceSet(RangeSet ranges)
           
 void writeStr16(String s)
          The str16 type encodes up to 65535 octets worth of UTF-8 unicode.
 void writeStr8(String s)
          The str8 type encodes up to 255 octets worth of UTF-8 unicode.
 void writeStruct(int type, Struct struct)
          The struct32 type describes any coded struct with a 32-bit (4 octet) size.
 void writeStruct32(Struct struct)
          The struct32 type describes any coded struct with a 32-bit (4 octet) size.
 void writeUint16(int s)
          The uint16 type is a 16-bit unsigned integral value encoded in network byte order.
 void writeUint32(long i)
          The uint32 type is a 32-bit unsigned integral value encoded in network byte order.
 void writeUint64(long l)
          The uint64 type is a 64-bit unsigned integral value encoded in network byte order.
 void writeUint8(short b)
          The uint8 type is an 8-bit unsigned integral value.
 void writeUuid(UUID uuid)
          The uuid type encodes a universally unique id as defined by RFC-4122.
 void writeVbin16(byte[] bytes)
          The vbin16 type encodes up to 65535 octets of opaque binary data.
 void writeVbin32(byte[] bytes)
          The vbin32 type encodes up to 4294967295 octets of opaque binary data.
 void writeVbin8(byte[] bytes)
          The vbin8 type encodes up to 255 octets of opaque binary data.
 

Method Detail

writeUint8

void writeUint8(short b)
The uint8 type is an 8-bit unsigned integral value.

Parameters:
b - the unsigned integer to be encoded.

writeUint16

void writeUint16(int s)
The uint16 type is a 16-bit unsigned integral value encoded in network byte order.

Parameters:
s - the unsigned integer to be encoded.

writeUint32

void writeUint32(long i)
The uint32 type is a 32-bit unsigned integral value encoded in network byte order.

Parameters:
i - the unsigned integer to be encoded.

writeUint64

void writeUint64(long l)
The uint64 type is a 64-bit unsigned integral value encoded in network byte order.

Parameters:
b - the unsigned integer to be encoded.

writeDatetime

void writeDatetime(long l)
The datetime type encodes a date and time using the 64 bit POSIX time_t format.

Parameters:
l - the datetime (as long) to be encoded.

writeUuid

void writeUuid(UUID uuid)
The uuid type encodes a universally unique id as defined by RFC-4122. The format and operations for this type can be found in section 4.1.2 of RFC-4122.

Parameters:
uuid - the uuid to be encoded.

writeSequenceNo

void writeSequenceNo(int s)
The sequence-no type encodes, in network byte order, a serial number as defined in RFC-1982.

Parameters:
s - the sequence number to be encoded.

writeSequenceSet

void writeSequenceSet(RangeSet ranges)

writeByteRanges

void writeByteRanges(RangeSet ranges)

writeStr8

void writeStr8(String s)
The str8 type encodes up to 255 octets worth of UTF-8 unicode. The number of octets of unicode is first encoded as an 8-bit unsigned integral value. This is followed by the actual UTF-8 unicode. Note that the encoded size refers to the number of octets of unicode, not necessarily the number of characters since the UTF-8 unicode may include multi-byte character sequences.

Parameters:
s - the string to be encoded.

writeStr16

void writeStr16(String s)
The str16 type encodes up to 65535 octets worth of UTF-8 unicode. The number of octets is first encoded as a 16-bit unsigned integral value in network byte order. This is followed by the actual UTF-8 unicode. Note that the encoded size refers to the number of octets of unicode, not necessarily the number of unicode characters since the UTF-8 unicode may include multi-byte character sequences.

Parameters:
s - the string to be encoded.

writeVbin8

void writeVbin8(byte[] bytes)
The vbin8 type encodes up to 255 octets of opaque binary data. The number of octets is first encoded as an 8-bit unsigned integral value. This is followed by the actual data.

Parameters:
bytes - the byte array to be encoded.

writeVbin16

void writeVbin16(byte[] bytes)
The vbin16 type encodes up to 65535 octets of opaque binary data. The number of octets is first encoded as a 16-bit unsigned integral value in network byte order. This is followed by the actual data.

Parameters:
bytes - the byte array to be encoded.

writeVbin32

void writeVbin32(byte[] bytes)
The vbin32 type encodes up to 4294967295 octets of opaque binary data. The number of octets is first encoded as a 32-bit unsigned integral value in network byte order. This is followed by the actual data.

Parameters:
bytes - the byte array to be encoded.

writeStruct32

void writeStruct32(Struct struct)
The struct32 type describes any coded struct with a 32-bit (4 octet) size. The type is restricted to be only coded structs with a 32-bit size, consequently the first six octets of any encoded value for this type MUST always contain the size, class-code, and struct-code in that order. The size is encoded as a 32-bit unsigned integral value in network byte order that is equal to the size of the encoded field-data, packing-flags, class-code, and struct-code. The class-code is a single octet that may be set to any valid class code. The struct-code is a single octet that may be set to any valid struct code within the given class-code. The first six octets are then followed by the packing flags and encoded field data. The presence and quantity of packingflags, as well as the specific fields are determined by the struct definition identified with the encoded class-code and struct-code.

Parameters:
struct - the struct to be encoded.

writeMap

void writeMap(Map<String,Object> map)
A map is a set of distinct keys where each key has an associated (type,value) pair. The triple of the key, type, and value, form an entry within a map. Each entry within a given map MUST have a distinct key. A map is encoded as a size in octets, a count of the number of entries, followed by the encoded entries themselves. An encoded map may contain up to (4294967295 - 4) octets worth of encoded entries. The size is encoded as a 32-bit unsigned integral value in network byte order equal to the number of octets worth of encoded entries plus 4. (The extra 4 octets is added for the entry count.) The size is then followed by the number of entries encoded as a 32-bit unsigned integral value in network byte order. Finally the entries are encoded sequentially. An entry is encoded as the key, followed by the type, and then the value. The key is always a string encoded as a str8. The type is a single octet that may contain any valid AMQP type code. The value is encoded according to the rules defined by the type code for that entry.

Parameters:
map - the map to be encoded.

writeList

void writeList(List<Object> list)
A list is an ordered sequence of (type, value) pairs. The (type, value) pair forms an item within the list. The list may contain items of many distinct types. A list is encoded as a size in octets, followed by a count of the number of items, followed by the items themselves encoded in their defined order. An encoded list may contain up to (4294967295 - 4) octets worth of encoded items. The size is encoded as a 32-bit unsigned integral value in network byte order equal to the number of octets worth of encoded items plus 4. (The extra4 octets is added for the item count.) The size is then followed by the number of items encoded as a 32-bit unsigned integral value in network byte order. Finally the items are encoded sequentially in their defined order. An item is encoded as the type followed by the value. The type is a single octet that may contain any valid AMQP type code. The value is encoded according to the rules defined by the type code for that item.

Parameters:
list - the list to be encoded.

writeArray

void writeArray(List<Object> array)
An array is an ordered sequence of values of the same type. The array is encoded in as a size in octets, followed by a type code, then a count of the number values in the array, and finally the values encoded in their defined order. An encoded array may contain up to (4294967295 - 5) octets worth of encoded values. The size is encoded as a 32-bit unsigned integral value in network byte order equal to the number of octets worth of encoded values plus 5. (The extra 5 octets consist of 4 octets for the count of the number of values, and one octet to hold the type code for the items inthe array.) The size is then followed by a single octet that may contain any valid AMQP type code. The type code is then followed by the number of values encoded as a 32-bit unsigned integral value in network byte order. Finally the values are encoded sequentially in their defined order according to the rules defined by the type code for the array.

Parameters:
array - the array to be encoded.

writeStruct

void writeStruct(int type,
                 Struct struct)
The struct32 type describes any coded struct with a 32-bit (4 octet) size. The type is restricted to be only coded structs with a 32-bit size, consequently the first six octets of any encoded value for this type MUST always contain the size, class-code, and struct-code in that order. The size is encoded as a 32-bit unsigned integral value in network byte order that is equal to the size of the encoded field-data, packing-flags, class-code, and struct-code. The class-code is a single octet that may be set to any valid class code. The struct-code is a single octet that may be set to any valid struct code within the given class-code. The first six octets are then followed by the packing flags and encoded field data. The presence and quantity of packingflags, as well as the specific fields are determined by the struct definition identified with the encoded class-code and struct-code.

Parameters:
type - the type of the struct.
struct - the struct to be encoded.

writeFloat

void writeFloat(float aFloat)
The float type encodes a single precision 32-bit floating point number. The format and operations are defined by the IEEE 754 standard for 32-bit single precision floating point numbers.

Parameters:
aFloat - the float to be encoded.

writeDouble

void writeDouble(double aDouble)
The double type encodes a double precision 64-bit floating point number. The format and operations are defined by the IEEE 754 standard for 64-bit double precision floating point numbers.

Parameters:
aDouble - the double to be encoded.

writeInt8

void writeInt8(byte aByte)
The int8 type is a signed integral value encoded using an 8-bit two's complement representation.

Parameters:
aByte - the integer to be encoded.

writeInt16

void writeInt16(short aShort)
The int16 type is a signed integral value encoded using a 16-bit two's complement representation in network byte order.

Parameters:
aShort - the integer to be encoded.

writeInt32

void writeInt32(int anInt)
The int32 type is a signed integral value encoded using a 32-bit two's complement representation in network byte order.

Parameters:
anInt - the integer to be encoded.

writeInt64

void writeInt64(long aLong)
The int64 type is a signed integral value encoded using a 64-bit two's complement representation in network byte order.

Parameters:
aLong - the integer to be encoded.

writeBin128

void writeBin128(byte[] bytes)
The bin128 type consists of 16 consecutive octets of opaque binary data.

Parameters:
bytes - the bytes array to be encoded.

writeMagicNumber

void writeMagicNumber()
Encodes the AMQP magic number.



Licensed to the Apache Software Foundation