Many resources are needed to download a project. Please understand that we have to compensate our server costs. Thank you in advance. Project price only 1 $
You can buy this project and download/modify it how often you want.
/*
*
* 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.qpid.transport.codec;
import java.nio.ByteBuffer;
import java.util.List;
import java.util.Map;
import java.util.UUID;
import org.apache.qpid.transport.RangeSet;
import org.apache.qpid.transport.Struct;
/**
* Encoder interface.
* Each concrete implementor must specify how to encode given values.
*
* @author Rafael H. Schloming
*/
public interface Encoder
{
/**
* The uint8 type is an 8-bit unsigned integral value.
*
* @param b the unsigned integer to be encoded.
*/
void writeUint8(short b);
/**
*The uint16 type is a 16-bit unsigned integral value encoded in network byte order.
*
* @param s the unsigned integer to be encoded.
*/
void writeUint16(int s);
/**
*The uint32 type is a 32-bit unsigned integral value encoded in network byte order.
*
* @param i the unsigned integer to be encoded.
*/
void writeUint32(long i);
/**
* The uint64 type is a 64-bit unsigned integral value encoded in network byte order.
*
* @param l the unsigned integer to be encoded.
*/
void writeUint64(long l);
/**
* The datetime type encodes a date and time using the 64 bit POSIX time_t format.
*
* @param l the datetime (as long) to be encoded.
*/
void writeDatetime(long l);
/**
* 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.
*
* @param uuid the uuid to be encoded.
*/
void writeUuid(UUID uuid);
/**
*The sequence-no type encodes, in network byte order, a serial number as defined in RFC-1982.
*
* @param s the sequence number to be encoded.
*/
void writeSequenceNo(int s);
void writeSequenceSet(RangeSet ranges); // XXX
void writeByteRanges(RangeSet ranges); // XXX
/**
* 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.
*
* @param s the string to be encoded.
*/
void writeStr8(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.
*
* @param s the string to be encoded.
*/
void writeStr16(String s);
/**
* 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.
*
* @param bytes the byte array to be encoded.
*/
void writeVbin8(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.
*
* @param bytes the byte array to be encoded.
*/
void writeVbin16(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.
*
* @param bytes the byte array to be encoded.
*/
void writeVbin32(byte[] bytes);
/**
* 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.
*
* @param struct the struct to be encoded.
*/
void writeStruct32(Struct struct);
/**
* 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.
*
* @param map the map to be encoded.
*/
void writeMap(Map map);
/**
* 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.
*
* @param list the list to be encoded.
*/
void writeList(List
