private object ReadField(IDataReader reader, D2OFieldDefinition field, D2OFieldType typeId,
int vectorDimension = 0)
{
switch (typeId)
{
case D2OFieldType.Int:
return(ReadFieldInt(reader));
case D2OFieldType.Bool:
return(ReadFieldBool(reader));
case D2OFieldType.String:
return(ReadFieldUTF(reader));
case D2OFieldType.Double:
return(ReadFieldDouble(reader));
case D2OFieldType.I18N:
return(ReadFieldI18n(reader));
case D2OFieldType.UInt:
return(ReadFieldUInt(reader));
case D2OFieldType.List:
return(ReadFieldVector(reader, field, vectorDimension));
default:
return(ReadFieldObject(reader));
}
}
private object ReadFieldVector(IDataReader reader, D2OFieldDefinition field, int vectorDimension)
{
int count = reader.ReadInt();
Type vectorType = field.FieldType;
for (int i = 0; i < vectorDimension; i++)
{
vectorType = vectorType.GetGenericArguments()[0];
}
if (!objectCreators.ContainsKey(vectorType))
{
Func <object[], object> creator = CreateObjectBuilder(vectorType, new FieldInfo[0]);
objectCreators.Add(vectorType, creator);
}
var result = objectCreators[vectorType](new object[0]) as IList;
for (int i = 0; i < count; i++)
{
vectorDimension++;
// i didn't found a way to have thez correct dimension so i just add "- 1"
result.Add(ReadField(reader, field, field.VectorTypes[vectorDimension - 1].Item1, vectorDimension));
vectorDimension--;
}
return(result);
}
private void WriteFieldVector(IDataWriter writer, D2OFieldDefinition field, IList list, int vectorDimension)
{
if (list == null)
{
writer.WriteInt(0);
return;
}
writer.WriteInt(list.Count);
for (int i = 0; i < list.Count; i++)
{
WriteField(writer, field.VectorTypes[vectorDimension].Item1, field, list[i], vectorDimension + 1);
}
}
private void WriteField(IDataWriter writer, D2OFieldType fieldType, D2OFieldDefinition field, dynamic obj, int vectorDimension = 0)
{
switch (fieldType)
{
case D2OFieldType.Int:
WriteFieldInt(writer, (int)obj);
break;
case D2OFieldType.Bool:
WriteFieldBool(writer, obj);
break;
case D2OFieldType.String:
WriteFieldUTF(writer, obj);
break;
case D2OFieldType.Double:
WriteFieldDouble(writer, obj);
break;
case D2OFieldType.I18N:
WriteFieldI18n(writer, (int)obj);
break;
case D2OFieldType.UInt:
WriteFieldUInt(writer, (uint)obj);
break;
case D2OFieldType.List:
WriteFieldVector(writer, field, obj, vectorDimension);
break;
default:
WriteFieldObject(writer, obj);
break;
}
}
private void ReadClassesTable()
{
var tempVectorTypes = new Dictionary <D2OFieldDefinition, List <Tuple <D2OFieldType, string> > >();
m_classcount = m_reader.ReadInt();
m_classes = new Dictionary <int, D2OClassDefinition>(m_classcount);
for (int i = 0; i < m_classcount; i++)
{
int classId = m_reader.ReadInt();
string classMembername = m_reader.ReadUTF();
string classPackagename = m_reader.ReadUTF();
Type classType = FindType(classMembername);
int fieldscount = m_reader.ReadInt();
var fields = new List <D2OFieldDefinition>(fieldscount);
for (int l = 0; l < fieldscount; l++)
{
string fieldname = m_reader.ReadUTF();
var fieldtype = (D2OFieldType)m_reader.ReadInt();
var field = classType.GetField(fieldname);
if (field == null)
{
throw new Exception(string.Format("Missing field '{0}' ({1}) in class '{2}'", fieldname, fieldtype, classType.Name));
}
var fieldDefinition = new D2OFieldDefinition(fieldname, fieldtype, field, m_reader.Position, new Tuple <D2OFieldType, Type> [0]);
var vectorTypes = new List <Tuple <D2OFieldType, object> >();
if (fieldtype == D2OFieldType.List)
{
addVectorType:
string name = m_reader.ReadUTF();
var id = (D2OFieldType)m_reader.ReadInt();
if (!tempVectorTypes.ContainsKey(fieldDefinition))
{
tempVectorTypes.Add(fieldDefinition, new List <Tuple <D2OFieldType, string> >());
}
tempVectorTypes[fieldDefinition].Add(Tuple.Create(id, name));
if (id == D2OFieldType.List)
{
goto addVectorType;
}
}
fields.Add(fieldDefinition);
}
m_classes.Add(classId,
new D2OClassDefinition(classId, classMembername, classPackagename, classType, fields,
m_reader.Position));
}
// find vector types
foreach (var keyPair in tempVectorTypes)
{
keyPair.Key.VectorTypes = keyPair.Value.Select(tuple => Tuple.Create(tuple.Item1, FindNETType(tuple.Item2))).ToArray();
}
}
