public void TestStringAsDouble()
{
String s = "hello";
Variant v = new Variant(s);
v.AsDouble();
}
/// <exception cref="VariantException"></exception>
public static string VariantToExpressionString(Variant val)
{
// convert given variant to string which can be interpret as an expression.
// this function does not convert objects ( returns empty string )
if (val.IsVoid())
{
return("void");
}
else
{
if (val.IsInteger())
{
return(val.AsString());
}
else
{
if (val.IsReal())
{
string s = Variant.RealToHexString(val.AsDouble());
return(s + " /* " + val.AsString() + " */");
}
else
{
if (val.IsString())
{
string s = LexBase.EscapeC(val.AsString());
return("\"" + s + "\"");
}
else
{
if (val.IsOctet())
{
string s = Variant.OctetToListString(val.AsOctet());
return("<%" + s + "%>");
}
else
{
return(string.Empty);
}
}
}
}
}
}
/// <exception cref="VariantException"></exception>
public static object[] VariantArrayToJavaObjectArray(Variant[] @params, Type[] types)
{
if (types.Length == 0)
{
return(null);
}
// 元々引数不要
if (@params.Length < types.Length)
{
return(null);
}
// パラメータが少ない
int count = types.Length;
object[] ret = new object[count];
for (int i = 0; i < count; i++)
{
Type type = types[i];
Variant param = @params[i];
if (type.GetTypeInfo().IsPrimitive)
{
// プリミティブタイプの场合
if (type == typeof(int))
{
ret[i] = Extensions.ValueOf(param.AsInteger());
}
else if (type == typeof(double))
{
ret[i] = (param.AsDouble());
}
else if (type == typeof(bool))
{
ret[i] = Extensions.ValueOf(param.AsInteger() != 0);
}
else if (type == typeof(float))
{
ret[i] = ((float)param.AsDouble());
}
else if (type == typeof(long))
{
ret[i] = Extensions.ValueOf(param.AsInteger());
}
else if (type == typeof(char))
{
ret[i] = ((char)param.AsInteger());
}
else if (type == typeof(byte))
{
ret[i] = (unchecked ((byte)param.AsInteger()));
}
else if (type == typeof(short))
{
ret[i] = ((short)param.AsInteger());
}
else
{
// may be Void.TYPE
ret[i] = null;
}
}
else if (type == typeof(string))
{
ret[i] = param.AsString();
}
else if (type == typeof(ByteBuffer))
{
ret[i] = param.AsOctet();
}
else if (type == typeof(Variant))
{
ret[i] = param;
}
else if (type == typeof(VariantClosure))
{
ret[i] = param.AsObjectClosure();
}
else if (type == typeof(Dispatch2))
{
ret[i] = param.AsObject();
}
else if (type == param.ToJavaObject().GetType())
{
ret[i] = param.ToJavaObject();
}
else
{
// その他 のクラス
ret[i] = null;
}
}
return(ret);
}
/// <exception cref="VariantException"></exception>
public static object VariantToJavaObject(Variant param, Type type)
{
if (type.GetTypeInfo().IsPrimitive)
{
// プリミティブタイプの场合
if (type == typeof(int))
{
return(Extensions.ValueOf(param.AsInteger()));
}
if (type == typeof(double))
{
return(param.AsDouble());
}
if (type == typeof(bool))
{
return(Extensions.ValueOf(param.AsInteger() != 0));
}
if (type == typeof(float))
{
return((float)param.AsDouble());
}
if (type == typeof(long))
{
return(Extensions.ValueOf(param.AsInteger()));
}
if (type == typeof(char))
{
return((char)param.AsInteger());
}
if (type == typeof(byte))
{
return(unchecked ((byte)param.AsInteger()));
}
if (type == typeof(short))
{
return((short)param.AsInteger());
}
// may be Void.TYPE
return(null);
}
if (type == typeof(string))
{
return(param.AsString());
}
if (type == typeof(ByteBuffer))
{
return(param.AsOctet());
}
if (type == typeof(Variant))
{
return(param);
}
if (type == typeof(VariantClosure))
{
return(param.AsObjectClosure());
}
if (type == typeof(Dispatch2))
{
return(param.AsObject());
}
if (type == param.ToJavaObject().GetType())
{
return(param.ToJavaObject());
}
// その他 のクラス
return(null);
}
private void WriteVariant(Variant value)
{
switch (value.Kind)
{
case VariantKind.Null:
_writer.Write((byte)EncodingKind.Null);
break;
case VariantKind.Boolean:
_writer.Write((byte)(value.AsBoolean() ? EncodingKind.Boolean_True : EncodingKind.Boolean_False));
break;
case VariantKind.Byte:
_writer.Write((byte)EncodingKind.UInt8);
_writer.Write(value.AsByte());
break;
case VariantKind.SByte:
_writer.Write((byte)EncodingKind.Int8);
_writer.Write(value.AsSByte());
break;
case VariantKind.Int16:
_writer.Write((byte)EncodingKind.Int16);
_writer.Write(value.AsInt16());
break;
case VariantKind.UInt16:
_writer.Write((byte)EncodingKind.UInt16);
_writer.Write(value.AsUInt16());
break;
case VariantKind.Int32:
{
var v = value.AsInt32();
if (v >= 0 && v <= 10)
{
_writer.Write((byte)((int)EncodingKind.Int32_0 + v));
}
else if (v >= 0 && v < byte.MaxValue)
{
_writer.Write((byte)EncodingKind.Int32_1Byte);
_writer.Write((byte)v);
}
else if (v >= 0 && v < ushort.MaxValue)
{
_writer.Write((byte)EncodingKind.Int32_2Bytes);
_writer.Write((ushort)v);
}
else
{
_writer.Write((byte)EncodingKind.Int32);
_writer.Write(v);
}
}
break;
case VariantKind.UInt32:
{
var v = value.AsUInt32();
if (v >= 0 && v <= 10)
{
_writer.Write((byte)((int)EncodingKind.UInt32_0 + v));
}
else if (v >= 0 && v < byte.MaxValue)
{
_writer.Write((byte)EncodingKind.UInt32_1Byte);
_writer.Write((byte)v);
}
else if (v >= 0 && v < ushort.MaxValue)
{
_writer.Write((byte)EncodingKind.UInt32_2Bytes);
_writer.Write((ushort)v);
}
else
{
_writer.Write((byte)EncodingKind.UInt32);
_writer.Write(v);
}
}
break;
case VariantKind.Int64:
_writer.Write((byte)EncodingKind.Int64);
_writer.Write(value.AsInt64());
break;
case VariantKind.UInt64:
_writer.Write((byte)EncodingKind.UInt64);
_writer.Write(value.AsUInt64());
break;
case VariantKind.Decimal:
_writer.Write((byte)EncodingKind.Decimal);
_writer.Write(value.AsDecimal());
break;
case VariantKind.Float4:
_writer.Write((byte)EncodingKind.Float4);
_writer.Write(value.AsSingle());
break;
case VariantKind.Float8:
_writer.Write((byte)EncodingKind.Float8);
_writer.Write(value.AsDouble());
break;
case VariantKind.Char:
_writer.Write((byte)EncodingKind.Char);
_writer.Write((ushort)value.AsChar()); // written as ushort because BinaryWriter fails on chars that are unicode surrogates
break;
case VariantKind.String:
WriteStringValue(value.AsString());
break;
case VariantKind.BoxedEnum:
var e = value.AsBoxedEnum();
WriteBoxedEnum(e, e.GetType());
break;
case VariantKind.DateTime:
_writer.Write((byte)EncodingKind.DateTime);
_writer.Write(value.AsDateTime().ToBinary());
break;
case VariantKind.Type:
WriteType(value.AsType());
break;
case VariantKind.Array:
WriteArray(value.AsArray());
break;
case VariantKind.Object:
WriteObject(value.AsObject());
break;
}
}
