private object DoLen(object target, object[] args)
{
if (args.Length == 0)
{
return(0);
}
Array a = args[0] as Array;
string s = args[0] as string;
DataReader reader = args[0] as DataReader;
IStreamTypeParser parser = args[0] as IStreamTypeParser;
if (s != null)
{
return(s.Length);
}
else if (a != null)
{
return(a.Length);
}
else if (reader != null)
{
return(reader.DataLeft);
}
else if (parser != null)
{
DataWriter writer = new DataWriter();
parser.ToStream(writer, CreateState(target), _logger);
return(writer.BytesWritten);
}
return(0);
}
/// <summary>
/// Read a sequence choice, relies on validation rules on the parsing to ensure parsing
/// </summary>
/// <remarks>The reader must be seekable</remarks>
/// <param name="reader"></param>
/// <param name="types"></param>
/// <returns></returns>
protected IStreamTypeParser RSC(DataReader reader, params Type[] types)
{
if (!reader.GetStream().CanSeek)
{
throw new ArgumentException(Properties.Resources.BaseParser_RSCStreamCannotSeek, "reader");
}
foreach (Type t in types)
{
long currPos = reader.GetStream().Position;
long currentRead = reader.ByteCount;
try
{
IStreamTypeParser ret = (IStreamTypeParser)Activator.CreateInstance(t);
ret.FromStream(reader, CS(), _logger);
return(ret);
}
catch (Exception)
{
}
reader.GetStream().Position = currPos;
reader.ByteCount = currentRead;
}
throw new ArgumentException(String.Format(Properties.Resources.BaseParser_NoValidSequenceChoice, this.GetType().Name));
}
/// <summary>
/// Read sequence choice, no fallback
/// </summary>
/// <param name="value">The value of the selected field</param>
/// <param name="args">The arguments, should be laid out as 'expr', type, ... </param>
/// <returns>The parsed sequence, null if not found a match</returns>
protected IStreamTypeParser RSC(DataReader reader, object value, params object[] args)
{
for (int i = 0; i < args.Length; i += 2)
{
if (value != null ? Check(args[i].ToString(), value) : Check(args[i].ToString()))
{
IStreamTypeParser ret = (IStreamTypeParser)Activator.CreateInstance((Type)args[i + 1]);
ret.FromStream(reader, CS(), _logger);
return(ret);
}
}
throw new ArgumentException(String.Format(Properties.Resources.BaseParser_NoValidSequenceChoice, this.GetType().Name));
}
public void ToWriter(DataFrames.DataWriter writer, DataFrames.DataKey root, Utils.Logger logger)
{
StateDictionary state = new StateDictionary();
try
{
IStreamTypeParser parser = ObjectConverter.FromNode <T>(root, _derivedTypes);
parser.ToStream(writer, state, logger);
}
catch (ThreadAbortException)
{
throw;
}
catch (Exception ex)
{
logger.LogError(CANAPE.Parser.Properties.Resources.GenericStreamParser_WriteException, ex.Message, typeof(T).Name);
throw;
}
}
private byte[] ToBytes(object target, object o, bool littleEndian, Encoding encoding)
{
if (o is byte)
{
return(new byte[1] {
(byte)o
});
}
else if (o is sbyte)
{
return((byte[])(object)(new sbyte[1] {
(sbyte)o
}));
}
else if (o.GetType().IsPrimitive)
{
MemoryStream stm = new MemoryStream();
DataWriter writer = new DataWriter(stm);
writer.WritePrimitive(o, o.GetType(), littleEndian);
return(stm.ToArray());
}
else if (o is byte[])
{
return((byte[])o);
}
else if (o is Array)
{
MemoryStream stm = new MemoryStream();
foreach (object x in ((Array)o))
{
byte[] ba = ToBytes(target, x, littleEndian, encoding);
stm.Write(ba, 0, ba.Length);
}
return(stm.ToArray());
}
else if (o is IStreamTypeParser)
{
MemoryStream stm = new MemoryStream();
DataWriter writer = new DataWriter(stm);
IStreamTypeParser parser = (IStreamTypeParser)o;
parser.ToStream(writer, CreateState(target), _logger);
return(stm.ToArray());
}
else if (o is string)
{
if (encoding != null)
{
return(encoding.GetBytes((string)o));
}
else
{
return(BinaryEncoding.Instance.GetBytes((string)o));
}
}
return(new byte[0]);
}
