private void addPrimitiveParameterValue(IPrimitiveValue value)
{
bool isOk = ((value != null) && (
(value is IntegerValue) ||
(value is RealValue) ||
(value is BooleanValue) ||
(value is CharacterStringValue)));
if (isOk)
{
if (value is IntegerValue)
{
this.jwriter.writeValue(((IntegerValue)value).getIntegerValue());
}
if (value is RealValue)
{
this.jwriter.writeValue(((RealValue)value).getRealValue());
}
if (value is BooleanValue)
{
this.jwriter.writeValue(((BooleanValue)value).getBooleanValue());
}
if (value is CharacterStringValue)
{
this.jwriter.writeValue(((CharacterStringValue)value).getCharacterStringValue());
}
}
else
{
throw new ArgumentException("Argument 'value' must be not " +
"null and an object of type\n" +
"IntegerValue or BooleanValue or " +
"RealValue or CharacterStringValue.");
}
}
private IPrimitiveValue parsePrimitiveValue(IJsonReader <TokenType> jreader)
{
TokenType type = jreader.getCurrentTokenType();
object value = jreader.getCurrentValue();
bool isOk = (((type == TokenType.String) ||
(type == TokenType.Boolean) ||
(type == TokenType.Integer) ||
(type == TokenType.Float)) &&
(value != null) &&
((value is String) ||
(value is Boolean) ||
(value is ValueType)));
IPrimitiveValue pvalue = null;
if (isOk)
{
if (type == TokenType.String)
{
pvalue = CharacterStringValue.create((String)value);
}
if (type == TokenType.Integer)
{
pvalue = IntegerValue.create((ValueType)value);
}
if (type == TokenType.Float)
{
pvalue = RealValue.create((ValueType)value);
}
if (type == TokenType.Boolean)
{
pvalue = BooleanValue.create((Boolean)value);
}
}
else
{
throw new ArgumentException("Argument 'type' must be a TokenType with " +
"option of String or Boolean " +
"or Integer or Float\n" +
"Argument 'value' must be not null and " +
"of type String or Boolean or ValueType.");
}
return(pvalue);
}
/// <summary>
/// Read a primitive type
/// </summary>
/// <param name="t">The primitive type to read</param>
/// <param name="littleEndian">Whether should read in little endian (if applicable)</param>
/// <exception cref="ArgumentException">Throw if cannot determine type to read</exception>
/// <returns>The primitive type</returns>
public object ReadPrimitive(Type t, bool littleEndian)
{
object ret = null;
if (t == typeof(byte))
{
ret = ReadByte();
}
else if (t == typeof(sbyte))
{
ret = ReadSByte();
}
else if (t == typeof(short))
{
ret = ReadInt16(littleEndian);
}
else if (t == typeof(ushort))
{
ret = ReadUInt16(littleEndian);
}
else if (t == typeof(int))
{
ret = ReadInt32(littleEndian);
}
else if (t == typeof(uint))
{
ret = ReadUInt32(littleEndian);
}
else if (t == typeof(long))
{
ret = ReadInt64(littleEndian);
}
else if (t == typeof(ulong))
{
ret = ReadUInt64(littleEndian);
}
else if (t == typeof(float))
{
ret = ReadFloat(littleEndian);
}
else if (t == typeof(double))
{
ret = ReadDouble(littleEndian);
}
else if (t == typeof(Int24))
{
ret = ReadInt24(littleEndian);
}
else if (t == typeof(UInt24))
{
ret = ReadUInt24(littleEndian);
}
else if (typeof(IPrimitiveValue).IsAssignableFrom(t))
{
IPrimitiveValue ser = (IPrimitiveValue)Activator.CreateInstance(t);
ser.FromReader(this, littleEndian);
ret = ser;
}
else
{
throw new ArgumentException(String.Format(CANAPE.Properties.Resources.DataReader_InvalidPrimitiveType, t));
}
return(ret);
}
private static object GetObject(DataNode root, Type baseType, Dictionary <Guid, Type> derivedTypes, object parent)
{
object ret = null;
if (typeof(DataNode).IsAssignableFrom(baseType))
{
ret = root.CloneNode();
}
else if (baseType == typeof(byte[]))
{
ret = root.ToArray();
}
else if (baseType == typeof(char[]))
{
ret = root.ToDataString().ToCharArray();
}
else if (baseType == typeof(string))
{
ret = root.ToDataString();
}
else if (typeof(IPrimitiveValue).IsAssignableFrom(baseType))
{
IPrimitiveValue prim = (IPrimitiveValue)Activator.CreateInstance(baseType);
DataValue value = root as DataValue;
if (value == null)
{
throw new ArgumentException(Properties.Resources.ObjectConverter_GetObjectPrimitive);
}
prim.Value = value.Value;
ret = prim;
}
else if (baseType == typeof(DateTime))
{
DateTimeDataValue value = root as DateTimeDataValue;
if (value == null)
{
throw new ArgumentException(Properties.Resources.ObjectConverter_GetObjectDateTime);
}
ret = value.Value;
}
else if (baseType == typeof(BigInteger))
{
BigIntegerDataValue value = root as BigIntegerDataValue;
if (value != null)
{
ret = value.Value;
}
else
{
ret = new BigInteger(root.ToArray());
}
}
else if (baseType.IsPrimitive)
{
DataValue value = root as DataValue;
if (value == null)
{
throw new ArgumentException(Properties.Resources.ObjectConverter_GetObjectPrimitive);
}
ret = Convert.ChangeType(value.Value, baseType);
}
else if (baseType.IsArray)
{
DataKey key = root as DataKey;
if (key == null)
{
throw new ArgumentException(Properties.Resources.ObjectConverter_GetObjectArray);
}
ret = GetArray(key, baseType.GetElementType(), derivedTypes, parent);
}
else if (baseType.IsEnum)
{
DataValue value = root as DataValue;
if (value != null)
{
Type valueType = value.Value.GetType();
if (valueType == typeof(string))
{
ret = Enum.Parse(baseType, value.Value.ToString());
}
else if (valueType == typeof(PortableEnum))
{
ret = Enum.ToObject(baseType, Convert.ChangeType(value.Value.Value, baseType.GetEnumUnderlyingType()));
}
else if (valueType.IsPrimitive)
{
ret = Enum.ToObject(baseType, Convert.ChangeType(value.Value, baseType.GetEnumUnderlyingType()));
}
else
{
throw new ArgumentException(Properties.Resources.ObjectConverter_GetObjectEnum);
}
}
}
else if (baseType == typeof(IPAddress))
{
ret = new IPAddress(root.ToArray());
}
else
{
try
{
Type createType = GetTypeFromNode(baseType, root, derivedTypes);
if (createType.IsAbstract)
{
throw new ArgumentException(String.Format(Properties.Resources.ObjectConverter_GetObjectAbstract, createType));
}
ret = Activator.CreateInstance(createType);
}
catch (MissingMethodException ex)
{
throw new ArgumentException(String.Format(Properties.Resources.ObjectConverter_GetObjectCouldntCreate, baseType), ex);
}
INodeInitializer converter = ret as INodeInitializer;
if (converter != null)
{
converter.FromNode(root);
}
else
{
DataKey key = root as DataKey;
if (key == null)
{
throw new ArgumentException(Properties.Resources.ObjectConverter_GetObjectComplex);
}
PopulateObject(key, ret, derivedTypes);
}
}
SetParent(ret, parent);
return(ret);
}
/// <summary>
/// Write a primitive value in little endian
/// </summary>
/// <param name="ser">The primitive value</param>
public void Write(IPrimitiveValue ser)
{
ser.ToWriter(this, true);
}
/// <summary>
/// Write a primitive value
/// </summary>
/// <param name="ser">The primitive value</param>
/// <param name="littleEndian">True for little endian</param>
public void Write(IPrimitiveValue ser, bool littleEndian)
{
ser.ToWriter(this, littleEndian);
}
