/*
*
* 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.
*
*/
using System;
using System.Text;
using Qpid.Buffer;
namespace Qpid.Framing
{
public class EncodingUtils
{
private static readonly Encoding DEFAULT_ENCODER = Encoding.ASCII;
public static ushort EncodedShortStringLength(string s)
{
if (s == null)
{
return 1;
}
else
{
return (ushort)(1 + s.Length);
}
}
public static uint EncodedLongStringLength(string s)
{
if (s == null)
{
return 4;
}
else
{
return (uint)(4 + s.Length);
}
}
public static int EncodedLongstrLength(byte[] bytes)
{
if (bytes == null)
{
return 4;
}
else
{
return 4 + bytes.Length;
}
}
public static uint EncodedFieldTableLength(FieldTable table)
{
if (table == null)
{
// size is encoded as 4 octets
return 4;
}
else
{
// size of the table plus 4 octets for the size
return table.EncodedSize + 4;
}
}
public static void WriteShortStringBytes(ByteBuffer buffer, string s)
{
if (s != null)
{
//try
//{
//final byte[] encodedString = s.getBytes(STRING_ENCODING);
byte[] encodedString;
lock (DEFAULT_ENCODER)
{
encodedString = DEFAULT_ENCODER.GetBytes(s);
}
// TODO: check length fits in an unsigned byte
buffer.put((byte) encodedString.Length);
buffer.put(encodedString);
}
else
{
// really writing out unsigned byte
buffer.put((byte) 0);
}
}
public static void WriteLongStringBytes(ByteBuffer buffer, string s)
{
if (!(s == null || s.Length <= 0xFFFE))
{
throw new ArgumentException("String too long");
}
if (s != null)
{
buffer.put((uint)s.Length);
byte[] encodedString = null;
lock (DEFAULT_ENCODER)
{
encodedString = DEFAULT_ENCODER.GetBytes(s);
}
buffer.put(encodedString);
}
else
{
buffer.put((uint) 0);
}
}
public static void WriteFieldTableBytes(ByteBuffer buffer, FieldTable table)
{
if (table != null)
{
table.WriteToBuffer(buffer);
}
else
{
buffer.put((uint) 0);
}
}
public static void WriteBooleans(ByteBuffer buffer, bool[] values)
{
byte packedValue = 0;
for (int i = 0; i < values.Length; i++)
{
if (values[i])
{
packedValue = (byte) (packedValue | (1 << i));
}
}
buffer.put(packedValue);
}
public static void WriteLongstr(ByteBuffer buffer, byte[] data)
{
if (data != null)
{
buffer.put((uint) data.Length);
buffer.put(data);
}
else
{
buffer.put((uint) 0);
}
}
public static bool[] ReadBooleans(ByteBuffer buffer)
{
byte packedValue = buffer.get();
bool[] result = new bool[8];
for (int i = 0; i < 8; i++)
{
result[i] = ((packedValue & (1 << i)) != 0);
}
return result;
}
///
/// Reads the field table uaing the data in the specified buffer
///
/// The buffer to read from.
/// a populated field table
/// if the buffer does not contain a decodable field table
public static FieldTable ReadFieldTable(ByteBuffer buffer)
{
uint length = buffer.GetUnsignedInt();
if (length == 0)
{
return null;
}
else
{
return new FieldTable(buffer, length);
}
}
///
/// Read a short string from the buffer
///
/// The buffer to read from.
/// a string
/// if the buffer does not contain a decodable short string
public static string ReadShortString(ByteBuffer buffer)
{
byte length = buffer.get();
if (length == 0)
{
return null;
}
else
{
byte[] data = new byte[length];
buffer.get(data);
lock (DEFAULT_ENCODER)
{
return DEFAULT_ENCODER.GetString(data);
// return buffer.GetString(length, DEFAULT_ENCODER);
}
}
}
public static string ReadLongString(ByteBuffer buffer)
{
uint length = buffer.getUnsignedInt();
if (length == 0)
{
return null;
}
else
{
byte[] data = new byte[length];
buffer.get(data);
lock (DEFAULT_ENCODER)
{
return DEFAULT_ENCODER.GetString(data);
//return buffer.GetString(length, DEFAULT_ENCODER);
}
}
}
public static byte[] ReadLongstr(ByteBuffer buffer)
{
uint length = buffer.getUnsignedInt();
if (length == 0)
{
return null;
}
else
{
byte[] result = new byte[length];
buffer.get(result);
return result;
}
}
}
}