com.crankuptheamps.client.CompositeMessageParser Maven / Gradle / Ivy
Go to download
Show more of this group Show more artifacts with this name
Show all versions of amps-client Show documentation
Show all versions of amps-client Show documentation
AMPS Java client by 60East Technologies, Inc.
////////////////////////////////////////////////////////////////////////////
//
// Copyright (c) 2010-2021 60East Technologies Inc., All Rights Reserved.
//
// This computer software is owned by 60East Technologies Inc. and is
// protected by U.S. copyright laws and other laws and by international
// treaties. This computer software is furnished by 60East Technologies
// Inc. pursuant to a written license agreement and may be used, copied,
// transmitted, and stored only in accordance with the terms of such
// license agreement and with the inclusion of the above copyright notice.
// This computer software or any other copies thereof may not be provided
// or otherwise made available to any other person.
//
// U.S. Government Restricted Rights. This computer software: (a) was
// developed at private expense and is in all respects the proprietary
// information of 60East Technologies Inc.; (b) was not developed with
// government funds; (c) is a trade secret of 60East Technologies Inc.
// for all purposes of the Freedom of Information Act; and (d) is a
// commercial item and thus, pursuant to Section 12.212 of the Federal
// Acquisition Regulations (FAR) and DFAR Supplement Section 227.7202,
// Government's use, duplication or disclosure of the computer software
// is subject to the restrictions set forth by 60East Technologies Inc..
//
////////////////////////////////////////////////////////////////////////////
package com.crankuptheamps.client;
import java.nio.charset.Charset;
import java.nio.charset.CharsetDecoder;
import com.crankuptheamps.client.fields.Field;
/**
* Used to retrieve individual message parts from AMPS composite messages,
* which are messages where the data contains a number of parts and each part
* is a complete message of a specific message type.
* For example, a composite message type of "composite-json-binary" may be
* declared on the server that combines a set of JSON headers with
* an opaque binary payload. CompositeMessageParser makes it easy to retrieve
* the parts of a composite message from the composite message payload.
*
*/
public class CompositeMessageParser
{
/**
* Creates a new CompositeMessageParser, with 0 valid parts.
*/
public CompositeMessageParser()
{
_metadata = new int[MAX_PARTS * 2];
_validCount = 0;
}
/**
* Creates a new CompositeMessageParser and parses the provided message body.
* @param body_ The composite body (returned from Message.getDataRaw()).
*/
public CompositeMessageParser(Field body_)
{
_metadata = new int[MAX_PARTS * 2];
parse(body_);
}
/**
* Creates a new CompositeMessageParser and parses a message's body.
* @param message_ The message containing a composite body.
*/
public CompositeMessageParser(Message message_)
{
_metadata = new int[MAX_PARTS * 2];
parse(message_.getDataRaw());
}
/**
* Parses a composite message.
* @param message_ The message with a composite body.
* @return The number of message parts found in message_
*/
public final int parse(Message message_)
{
return parse(message_.getDataRaw());
}
/**
* Parses a composite message's body.
* @param body_ The composite body (returned from Message.getDataRaw()).
* @return The number of message parts found in body_
*/
public final int parse(Field body_)
{
_validCount = 0;
// Skip through the body buffer, and write offsets to our internal _offset array.
int position = body_.position;
int end = position + body_.length;
byte[] buf = body_.buffer;
int metaIndex = 0;
while(position+4 <= end)
{
// extract part length
int partlength = (buf[position++]&0xFF) << 24;
partlength |= (buf[position++]&0xFF) << 16;
partlength |= (buf[position++]&0xFF) << 8;
partlength |= (buf[position++]&0xFF);
_metadata[metaIndex++] = position;
_metadata[metaIndex++] = partlength;
position += partlength;
}
_data = buf;
_validCount = metaIndex/2;
return _validCount;
}
/**
* Returns a part from a composite message body.
* @param index_ The part index to retrieve (0-based index)
* @return The data of this body part, decoded as UTF-8.
*/
public String getString(int index_)
{
return getString(index_,UTF8);
}
/**
* Returns a part from a composite message body.
* @param index_ The part index to retrieve (0-based index)
* @param charset The Charset to decode this body with.
* @return The data of this body part.
*/
public String getString(int index_,Charset charset)
{
if(index_ < _validCount)
{
return new String(_data,_metadata[index_*2],_metadata[(index_*2)+1],charset);
}
throw new RuntimeException("index out of bounds.");
}
/**
* Returns a part from a composite message body.
* @param index_ The part index to retrieve (0-based index)
* @param field_ The Field to update with the buffer, index, and length of this part.
* @return The field passed as field_.
*/
public Field getPart(int index_,Field field_)
{
if(index_ < _validCount)
{
field_.buffer = _data;
field_.position = _metadata[index_*2];
field_.length = _metadata[(index_*2)+1];
return field_;
}
throw new RuntimeException("index out of bounds.");
}
//Private Methods
private static int MAX_PARTS = 1024;
private static Charset UTF8 = Charset.forName("UTF-8");
private int[] _metadata = null;
private byte[] _data = null;
private int _validCount;
}