Package org.apache.vinci.transport

Class XTalkTransporter

java.lang.Object

org.apache.vinci.transport.XTalkTransporter

All Implemented Interfaces:

FrameTransporter

public class XTalkTransporter
extends Object
implements FrameTransporter

Implements XTalk marshalling of Frames.

Field Summary

Fields

Modifier and Type	Field	Description
static byte	DOCUMENT_MARKER
static byte	ELEMENT_MARKER
static byte[]	HEADER
static byte	PI_MARKER
static byte	STRING_MARKER
static byte	VERSION_CODE

Constructor Summary

Constructors

Constructor	Description
XTalkTransporter()

Method Summary

Modifier and Type	Method	Description
void	attributesToBin(OutputStream os, Attributes attributes, byte[] workbuf)
static int	consumeCharacters(InputStream is, byte[] byteBuf, char[] charBuf, int bytesToRead)	Consume the string of bytesToRead utf-8 bytes.
void	consumeChildren(InputStream is, Frame f, int field_count, int marker, byte[] buffer, char[] cbuffer)
KeyValuePair	consumeRootChildren(InputStream is, Frame f, byte[] buffer, char[] cbuffer)
KeyValuePair	consumeRootElement(InputStream is, Frame f, byte[] buffer, char[] cbuffer)
static String	consumeString(InputStream is)	Consume a string from the input stream.
static String	consumeString(InputStream is, byte[] buffer, char[] cbuffer)
void	elementToBin(OutputStream os, Frame f, byte[] workbuf)
KeyValuePair	fromStream(InputStream is, Frame f)	Parse the data-stream according to the XTalk protocol.
KeyValuePair	fromStreamWork(InputStream is, Frame f)	Once we know that this is an XTalk document, perform XTalk parsing.
KeyValuePair	fromStreamWork(InputStream is, Frame f, byte[] buffer, char[] cbuffer)
protected void	ignorePI(InputStream is)
static void	readFully(byte[] b, int length, InputStream in)
static void	readFully(byte[] b, InputStream in)
static int	readInt(InputStream in)
static void	stringToBin(char[] str, int begin, int len, OutputStream os)
static void	stringToBin(char[] str, int begin, int len, OutputStream os, byte[] buffer)
static void	stringToBin(String str, OutputStream os)	Sends a string over, without the type byte.
static void	stringToBin(String str, OutputStream os, byte[] buffer)	Sends a string as utf8, using the temporary buffer if it is big enough to avoid allocating new memory.
void	toStream(OutputStream os, Frame f)	Populate the (empty) frame from the stream contents.
static void	writeInt(int write_me, OutputStream out)

Methods inherited from class java.lang.Object

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

Field Detail

DOCUMENT_MARKER

public static final byte DOCUMENT_MARKER

See Also:

Constant Field Values

ELEMENT_MARKER

public static final byte ELEMENT_MARKER

See Also:

Constant Field Values

PI_MARKER

public static final byte PI_MARKER

See Also:

Constant Field Values

STRING_MARKER

public static final byte STRING_MARKER

See Also:

Constant Field Values

VERSION_CODE

public static final byte VERSION_CODE

See Also:

Constant Field Values

HEADER

public static final byte[] HEADER

Constructor Detail

XTalkTransporter

public XTalkTransporter()

Method Detail

fromStream

public KeyValuePair fromStream(InputStream is,
                               Frame f)
                        throws IOException,
                               EOFException

Parse the data-stream according to the XTalk protocol.

Specified by:

fromStream in interface FrameTransporter

Parameters:

is - input stream

f - frame

Returns:

If the first tag belongs to the Vinci namespace, then this tag/value combination is returned. Otherwise returns null. Should there be a non-null return, then the value object of the KeyValuePair can be either FrameLeaf or Frame.

Throws:

IOException - -

EOFException - -

fromStreamWork

public KeyValuePair fromStreamWork(InputStream is,
                                   Frame f)
                            throws IOException

Once we know that this is an XTalk document, perform XTalk parsing.

Parameters:

is - input stream

f - frame

Returns:

the key value pair

Throws:

IOException - if the versions don't match, or have unexpected element marker

fromStreamWork

public KeyValuePair fromStreamWork(InputStream is,
                                   Frame f,
                                   byte[] buffer,
                                   char[] cbuffer)
                            throws IOException

Throws:

IOException

ignorePI

protected void ignorePI(InputStream is)
                 throws IOException

Parameters:

is - the input stream

Throws:

IOException - passthru

consumeRootChildren

public KeyValuePair consumeRootChildren(InputStream is,
                                        Frame f,
                                        byte[] buffer,
                                        char[] cbuffer)
                                 throws IOException

Parameters:

is - the input stream

f - frame

buffer - -

cbuffer - -

Returns:

key value

Throws:

IOException - passthru

consumeRootElement

public KeyValuePair consumeRootElement(InputStream is,
                                       Frame f,
                                       byte[] buffer,
                                       char[] cbuffer)
                                throws IOException

Parameters:

is - the input stream

f - the Frame

buffer - -

cbuffer - -

Returns:

key value

Throws:

IOException - passthru

consumeChildren

public void consumeChildren(InputStream is,
                            Frame f,
                            int field_count,
                            int marker,
                            byte[] buffer,
                            char[] cbuffer)
                     throws IOException

Parameters:

is - input stream

f - frame

field_count - field count

marker - marker

buffer - -

cbuffer - -

Throws:

IOException - passthru

consumeString

public static String consumeString(InputStream is)
                            throws IOException

Consume a string from the input stream. TODO: Make a faster version that exploits work buffers to reduce allocations to a single string object.

Parameters:

is - input stream

Returns:

the string

Throws:

IOException - if key is longer than limit

consumeString

public static String consumeString(InputStream is,
                                   byte[] buffer,
                                   char[] cbuffer)
                            throws IOException

Throws:

IOException

consumeCharacters

public static int consumeCharacters(InputStream is,
                                    byte[] byteBuf,
                                    char[] charBuf,
                                    int bytesToRead)
                             throws IOException

Consume the string of bytesToRead utf-8 bytes. assumes buffers are big enough to hold bytesToRead bytes/chars

Parameters:

is - input stream

byteBuf - a byte buffer

charBuf - a character buffer

bytesToRead - the number of bytes to read

Returns:

the length of the converted characters

Throws:

IOException - passthru

toStream

public void toStream(OutputStream os,
                     Frame f)
              throws IOException

Description copied from interface: FrameTransporter

Populate the (empty) frame from the stream contents.

Specified by:

toStream in interface FrameTransporter

Parameters:

os - output stream

f - frame

Throws:

IOException - passthru

elementToBin

public void elementToBin(OutputStream os,
                         Frame f,
                         byte[] workbuf)
                  throws IOException

Parameters:

os - output stream

f - frame

workbuf - -

Throws:

IOException - passthru

stringToBin

public static void stringToBin(String str,
                               OutputStream os)
                        throws IOException

Sends a string over, without the type byte.

Parameters:

str - the string to send

os - the output stream

Throws:

IOException - passthru

stringToBin

public static void stringToBin(String str,
                               OutputStream os,
                               byte[] buffer)
                        throws IOException

Sends a string as utf8, using the temporary buffer if it is big enough to avoid allocating new memory.

Parameters:

str - the string to send

os - the output stream

buffer - a buffer

Throws:

IOException - passthru

stringToBin

public static void stringToBin(char[] str,
                               int begin,
                               int len,
                               OutputStream os)
                        throws IOException

Throws:

IOException

stringToBin

public static void stringToBin(char[] str,
                               int begin,
                               int len,
                               OutputStream os,
                               byte[] buffer)
                        throws IOException

Throws:

IOException

writeInt

public static void writeInt(int write_me,
                            OutputStream out)
                     throws IOException

Parameters:

write_me - the integer to write

out - the output stream

Throws:

IOException - passthru

readInt

public static int readInt(InputStream in)
                   throws IOException

Parameters:

in - the input stream

Returns:

the integer

Throws:

IOException - if any of the pieces read are negative

readFully

public static void readFully(byte[] b,
                             InputStream in)
                      throws IOException

Parameters:

b - the byte array to read into

in - the input stream

Throws:

IOException - passthru

readFully

public static void readFully(byte[] b,
                             int length,
                             InputStream in)
                      throws IOException

Throws:

IOException

attributesToBin

public void attributesToBin(OutputStream os,
                            Attributes attributes,
                            byte[] workbuf)
                     throws IOException

Parameters:

os - the output stream

attributes - attributes

workbuf - a working buffer

Throws:

IOException - passthru