/// <summary>
/// Reads map
/// </summary>
/// <param name="abstractHessianInput">HessianInput to read from</param>
/// <returns>Read object or null</returns>
public override object ReadMap(AbstractHessianInput abstractHessianInput)
{
var ds = new DataSet();
int refer = abstractHessianInput.AddRef(ds);
while (!abstractHessianInput.IsEnd())
{
var dt = new DataTable();
if (abstractHessianInput.ReadMapStart() == CHessian2Constants.BC_MAP)
{
abstractHessianInput.ReadType();
}
dt.TableName = abstractHessianInput.ReadString();
while (!abstractHessianInput.IsEnd())
{
var columnName = abstractHessianInput.ReadString();
var typeFullName = abstractHessianInput.ReadString();
var type = Type.GetType(typeFullName);
dt.Columns.Add(new DataColumn(columnName, type));
}
abstractHessianInput.ReadEnd();
if (abstractHessianInput.ReadMapStart() == CHessian2Constants.BC_MAP)
{
abstractHessianInput.ReadType();
}
while (!abstractHessianInput.IsEnd())
{
ArrayList objects = new ArrayList();
if (abstractHessianInput.ReadMapStart() == CHessian2Constants.BC_MAP)
{
abstractHessianInput.ReadType();
}
while (!abstractHessianInput.IsEnd())
{
var obj = abstractHessianInput.ReadObject();
objects.Add(obj);
}
abstractHessianInput.ReadEnd();
var row = dt.NewRow();
row.ItemArray = objects.ToArray();
dt.Rows.Add(row);
}
abstractHessianInput.ReadEnd();
ds.Tables.Add(dt);
}
abstractHessianInput.ReadEnd();
return(ds);
}
private Object ReadGenericList(AbstractHessianInput abstractHessianInput)
{
Type[] args = m_type.GetGenericArguments();
Type itemType = args[0];
Type listType = null;
if (m_type.Namespace.StartsWith("System") || m_type.IsInterface)
{
listType = typeof(System.Collections.Generic.List <>).MakeGenericType(itemType);
}
else
{
listType = m_type;
}
object list = Activator.CreateInstance(listType);
abstractHessianInput.AddRef(list);
while (!abstractHessianInput.IsEnd())
{
object item = abstractHessianInput.ReadObject(itemType);
listType.InvokeMember("Add", BindingFlags.InvokeMethod, null, list, new object[] { item });
}
abstractHessianInput.ReadEnd();
return(list);
}
/// <summary>
/// Reads map from input
/// </summary>
/// <param name="abstractHessianInput">Input stream</param>
/// <returns>Read map or null</returns>
public override object ReadMap(AbstractHessianInput abstractHessianInput)
{
IDictionary dictionary = null;
if ((m_type == null) || (m_type.IsInterface && typeof(IDictionary).IsAssignableFrom(m_type)))
{
dictionary = new Hashtable();
}
else if (m_type.Equals(typeof(Hashtable)))
{
dictionary = new Hashtable();
}
else
{
dictionary = (IDictionary)Activator.CreateInstance(m_type);
//dictionary = new Hashtable();
}
abstractHessianInput.AddRef(dictionary);
while (!abstractHessianInput.IsEnd())
{
dictionary.Add(abstractHessianInput.ReadObject(), abstractHessianInput.ReadObject());
}
abstractHessianInput.ReadEnd();
return(dictionary);
}
private Object ReadUntypedList(AbstractHessianInput abstractHessianInput)
{
IList listResult = new ArrayList();
abstractHessianInput.AddRef(listResult);
while (!abstractHessianInput.IsEnd())
{
listResult.Add(abstractHessianInput.ReadObject());
}
abstractHessianInput.ReadEnd();
return(listResult);
}
/// <summary>
/// Reads arrays
/// </summary>
/// <param name="abstractHessianInput">Hessian Input instance</param>
/// <param name="intLength">Array length</param>
/// <exception cref="CHessianException"/>
/// <returns>Read object</returns>
public override Object ReadList(AbstractHessianInput abstractHessianInput, int intLength)
{
switch (m_intCode)
{
case INTEGER_ARRAY:
{
if (intLength >= 0)
{
int[] arrData = new int[intLength];
abstractHessianInput.AddRef(arrData);
for (int i = 0; i < arrData.Length; i++)
{
arrData[i] = abstractHessianInput.ReadInt();
}
abstractHessianInput.ReadEnd();
return(arrData);
}
else
{
ArrayList arrayList = new ArrayList();
while (!abstractHessianInput.IsEnd())
{
arrayList.Add(abstractHessianInput.ReadInt());
}
abstractHessianInput.ReadEnd();
int[] arrData = new int[arrayList.Count];
for (int i = 0; i < arrData.Length; i++)
{
arrData[i] = (int)arrayList[i];
}
abstractHessianInput.AddRef(arrData);
return(arrData);
}
}
case SBYTE_ARRAY:
{
if (intLength >= 0)
{
sbyte[] arrData = new sbyte[intLength];
abstractHessianInput.AddRef(arrData);
for (int i = 0; i < arrData.Length; i++)
{
arrData[i] = (sbyte)abstractHessianInput.ReadInt();
}
abstractHessianInput.ReadEnd();
return(arrData);
}
else
{
ArrayList arrayList = new ArrayList();
while (!abstractHessianInput.IsEnd())
{
arrayList.Add(abstractHessianInput.ReadInt());
}
abstractHessianInput.ReadEnd();
sbyte[] arrData = new sbyte[arrayList.Count];
for (int i = 0; i < arrData.Length; i++)
{
arrData[i] = (sbyte)arrayList[i];
}
abstractHessianInput.AddRef(arrData);
return(arrData);
}
}
case STRING_ARRAY:
{
if (intLength >= 0)
{
string[] arrData = new String[intLength];
abstractHessianInput.AddRef(arrData);
for (int i = 0; i < arrData.Length; i++)
{
arrData[i] = abstractHessianInput.ReadString();
}
abstractHessianInput.ReadEnd();
return(arrData);
}
else
{
ArrayList arrayList = new ArrayList();
while (!abstractHessianInput.IsEnd())
{
arrayList.Add(abstractHessianInput.ReadString());
}
abstractHessianInput.ReadEnd();
string[] arrData = new String[arrayList.Count];
abstractHessianInput.AddRef(arrData);
for (int i = 0; i < arrData.Length; i++)
{
arrData[i] = (string)arrayList[i];
}
return(arrData);
}
}
case BOOLEAN_ARRAY:
{
if (intLength >= 0)
{
bool[] arrData = new bool[intLength];
abstractHessianInput.AddRef(arrData);
for (int i = 0; i < arrData.Length; i++)
{
arrData[i] = abstractHessianInput.ReadBoolean();
}
abstractHessianInput.ReadEnd();
return(arrData);
}
else
{
ArrayList arrayList = new ArrayList();
while (!abstractHessianInput.IsEnd())
{
arrayList.Add(abstractHessianInput.ReadBoolean());
}
abstractHessianInput.ReadEnd();
bool[] arrData = new bool[arrayList.Count];
abstractHessianInput.AddRef(arrData);
for (int i = 0; i < arrData.Length; i++)
{
arrData[i] = (bool)arrayList[i];
}
return(arrData);
}
}
case SHORT_ARRAY:
{
if (intLength >= 0)
{
short[] arrData = new short[intLength];
abstractHessianInput.AddRef(arrData);
for (int i = 0; i < arrData.Length; i++)
{
arrData[i] = (short)abstractHessianInput.ReadInt();
}
abstractHessianInput.ReadEnd();
return(arrData);
}
else
{
ArrayList arrayList = new ArrayList();
while (!abstractHessianInput.IsEnd())
{
arrayList.Add((short)abstractHessianInput.ReadInt());
}
abstractHessianInput.ReadEnd();
short[] arrData = new short[arrayList.Count];
for (int i = 0; i < arrData.Length; i++)
{
arrData[i] = (short)arrayList[i];
}
abstractHessianInput.AddRef(arrData);
return(arrData);
}
}
case LONG_ARRAY:
{
if (intLength >= 0)
{
long[] arrData = new long[intLength];
abstractHessianInput.AddRef(arrData);
for (int i = 0; i < arrData.Length; i++)
{
arrData[i] = abstractHessianInput.ReadLong();
}
abstractHessianInput.ReadEnd();
return(arrData);
}
else
{
ArrayList arrayList = new ArrayList();
while (!abstractHessianInput.IsEnd())
{
arrayList.Add(abstractHessianInput.ReadLong());
}
abstractHessianInput.ReadEnd();
long[] arrData = new long[arrayList.Count];
for (int i = 0; i < arrData.Length; i++)
{
arrData[i] = (long)arrayList[i];
}
abstractHessianInput.AddRef(arrData);
return(arrData);
}
}
case FLOAT_ARRAY:
{
if (intLength >= 0)
{
float[] arrData = new float[intLength];
abstractHessianInput.AddRef(arrData);
for (int i = 0; i < arrData.Length; i++)
{
arrData[i] = (float)(abstractHessianInput.ReadDouble());
}
abstractHessianInput.ReadEnd();
return(arrData);
}
else
{
ArrayList arrayList = new ArrayList();
while (!abstractHessianInput.IsEnd())
{
arrayList.Add(abstractHessianInput.ReadDouble());
}
abstractHessianInput.ReadEnd();
float[] arrData = new float[arrayList.Count];
for (int i = 0; i < arrData.Length; i++)
{
arrData[i] = (float)arrayList[i];
}
abstractHessianInput.AddRef(arrData);
return(arrData);
}
}
case DOUBLE_ARRAY:
{
if (intLength >= 0)
{
double[] arrData = new double[intLength];
abstractHessianInput.AddRef(arrData);
for (int i = 0; i < arrData.Length; i++)
{
arrData[i] = abstractHessianInput.ReadDouble();
}
abstractHessianInput.ReadEnd();
return(arrData);
}
else
{
ArrayList arrayList = new ArrayList();
while (!abstractHessianInput.IsEnd())
{
arrayList.Add(abstractHessianInput.ReadDouble());
}
abstractHessianInput.ReadEnd();
double[] data = new double[arrayList.Count];
abstractHessianInput.AddRef(data);
for (int i = 0; i < data.Length; i++)
{
data[i] = (double)arrayList[i];
}
return(data);
}
}
case OBJECT_ARRAY:
{
if (intLength >= 0)
{
object[] arrData = new Object[intLength];
abstractHessianInput.AddRef(arrData);
for (int i = 0; i < arrData.Length; i++)
{
arrData[i] = abstractHessianInput.ReadObject();
}
abstractHessianInput.ReadEnd();
return(arrData);
}
else
{
ArrayList arrayList = new ArrayList();
abstractHessianInput.AddRef(arrayList); // XXX: potential issues here
while (!abstractHessianInput.IsEnd())
{
arrayList.Add(abstractHessianInput.ReadObject());
}
abstractHessianInput.ReadEnd();
object[] arrData = new Object[arrayList.Count];
for (int i = 0; i < arrData.Length; i++)
{
arrData[i] = arrayList[i];
}
return(arrData);
}
}
default:
throw new CHessianException("not supperted type for deserialization");
}
}
public override object ReadMap(AbstractHessianInput abstractHessianInput)
{
Hashtable fieldValueMap = new Hashtable();
string _message = null;
Exception _innerException = null;
while (!abstractHessianInput.IsEnd())
{
object objKey = abstractHessianInput.ReadObject();
if (objKey != null)
{
var deserFields = GetDeserializableFields();
var field = (MemberInfo)deserFields[objKey];
// try to convert a Java Exception in a .NET exception
if (objKey.ToString() == "_message" || objKey.ToString() == "detailMessage")
{
if (field != null)
{
_message = abstractHessianInput.ReadObject(ReflectionUtils.GetMemberUnderlyingType(field)) as string;
}
else
{
_message = abstractHessianInput.ReadObject().ToString();
}
}
else if (objKey.ToString() == "_innerException" || objKey.ToString() == "cause")
{
try
{
if (field != null)
{
_innerException = abstractHessianInput.ReadObject(ReflectionUtils.GetMemberUnderlyingType(field)) as Exception;
}
else
{
_innerException = abstractHessianInput.ReadObject(typeof(Exception)) as Exception;
}
}
catch (Exception e)
{
// als Cause ist bei Java gerne mal eine zirkuläre Referenz auf die Exception selbst
// angegeben. Das klappt nicht, weil die Referenz noch nicht registriert ist,
// weil der Typ noch nicht klar ist (s.u.)
}
}
else
{
if (field != null)
{
object objFieldValue = abstractHessianInput.ReadObject(ReflectionUtils.GetMemberUnderlyingType(field));
fieldValueMap.Add(field, objFieldValue);
}
else
{
// ignore (z. B. Exception Stacktrace "stackTrace" von Java)
abstractHessianInput.ReadObject();
}
//field.SetValue(result, objFieldValue);
}
}
}
abstractHessianInput.ReadEnd();
object result = null;
try
{
#if COMPACT_FRAMEWORK
//CF TODO: tbd
#else
try
{
result = Activator.CreateInstance(this.m_type, new object[2] {
_message, _innerException
});
}
catch (Exception)
{
try
{
result = Activator.CreateInstance(this.m_type, new object[1] {
_innerException
});
}
catch (Exception)
{
try
{
result = Activator.CreateInstance(this.m_type, new object[1] {
_message
});
}
catch (Exception)
{
result = Activator.CreateInstance(this.m_type);
}
}
}
#endif
}
catch (Exception)
{
result = new Exception(_message, _innerException);
}
foreach (DictionaryEntry entry in fieldValueMap)
{
MemberInfo fieldInfo = (MemberInfo)entry.Key;
object value = entry.Value;
try { ReflectionUtils.SetMemberValue(fieldInfo, result, value); } catch (Exception) { }
}
// besser spät als gar nicht.
int refer = abstractHessianInput.AddRef(result);
return(result);
}
