public void CodeT <T>(ref T obj)
{
object o = obj;
if (typeof(T) == typeof(Array) || obj == null)
{
Code(ref o);
}
else
{
TypeCoder.Write(this, obj.GetType(), ref o);
}
}
public void CodeFields(Type type, ITypedMap obj)
{
TypeOfString fieldTypeMap = FieldTypeMap.Get(type, obj);
foreach (string fieldName in obj.FieldNames)
{
XElement element = null;
XAttribute attribute = null;
object value = obj[fieldName];
Type fieldType;
string fieldTypeName = null;
if (!fieldTypeMap.TryGetValue(fieldName, out fieldType))
{
TypeInfo typeInfo;
fieldType = value.GetType();
if (TryGetTypeInfo(fieldType, out typeInfo))
{
fieldTypeName = typeInfo.XmlName;
}
else
{
fieldTypeName = fieldType.AssemblyQualifiedName;
}
attribute = new XAttribute("type", fieldTypeName);
}
else
{
fieldTypeName = fieldType.Name;
}
if (fieldTypeName != fieldName || TypeCoder.IsDirectlyCodeable(fieldType))
{
element = new XElement(fieldName);
if (attribute != null)
{
element.Add(attribute);
}
m_elementStack.Push(m_element);
m_element = element;
}
TypeCoder.Write(this, fieldType, ref value);
if (fieldTypeName != fieldName || TypeCoder.IsDirectlyCodeable(fieldType))
{
m_element = m_elementStack.Pop();
AddValue(element);
}
}
}
public void Code(Type t, ref ICountableDictSet dictSet)
{
long count = CodeCountLong(ref dictSet, v => v.LongCount);
if (count < 1L)
{
return;
}
var keyType = dictSet.KeyType;
foreach (var obj in dictSet.Objects)
{
var key = obj;
TypeCoder.Write(this, keyType, ref key);
}
}
public void Code(Type t, ref IDictionary dict)
{
int count = CodeCount(ref dict, v => v.Count);
if (count < 1)
{
return;
}
Type[] subTypeArray = t.GetGenericArguments();
foreach (object k in dict.Keys)
{
var key = k;
TypeCoder.Write(this, subTypeArray[0], ref key);
var val = dict[key];
TypeCoder.Write(this, subTypeArray[1], ref val);
}
}
public void CodeFields(Type type, ITypedMap obj)
{
TypeOfString fieldTypeMap = FieldTypeMap.Get(type, obj);
m_writer.Write(obj.FieldCount);
foreach (string fieldName in obj.FieldNames)
{
m_writer.Write(fieldName);
object value = obj[fieldName];
bool directlyCodeable = true;
Type fieldType = null;
if ((m_debugMode & CoderDebugMode.ReportFields) != 0)
{
Report.Line(" {0}", fieldName);
}
// A field is directly codeable, if its type information can
// be computed by the writer and the reader without
// inspecting the actual field value.
if (!fieldTypeMap.TryGetValue(fieldName, out fieldType) ||
(value != null && fieldType != value.GetType()) ||
!TypeCoder.IsDirectlyCodeable(fieldType))
{
directlyCodeable = false;
}
// We store the directly codeable flag, so that a stored file
// can be read, even if the class has been modified, and the
// value of directly codeable has been changed.
m_writer.Write(directlyCodeable);
if (directlyCodeable)
{
TypeCoder.Write(this, fieldType, ref value);
}
else
{
Code(ref value);
}
}
}
public void Code(Type t, ref ICountableDict dict)
{
long count = CodeCountLong(ref dict, v => v.LongCount);
if (count < 1L)
{
return;
}
var keyType = dict.KeyType;
var valueType = dict.ValueType;
foreach (var pair in dict.ObjectPairs)
{
var key = pair.E0;
TypeCoder.Write(this, keyType, ref key);
var val = pair.E1;
TypeCoder.Write(this, valueType, ref val);
}
}
public void Code(Type t, ref IDictionary dict)
{
int count = CodeCount(ref dict, d => d.Count);
if (count < 1)
{
return;
}
XElement element;
Type[] subTypeArray = t.GetGenericArguments();
var keys = dict.Keys;
foreach (object k in keys)
{
var item = new XElement("item");
m_elementStack.Push(m_element);
m_element = item;
object key = k;
element = new XElement("key");
m_elementStack.Push(m_element);
m_element = element;
TypeCoder.Write(this, subTypeArray[0], ref key);
m_element = m_elementStack.Pop();
AddValue(element);
object val = dict[key];
element = new XElement("val");
m_elementStack.Push(m_element);
m_element = element;
TypeCoder.Write(this, subTypeArray[1], ref val);
m_element = m_elementStack.Pop();
AddValue(element);
m_element = m_elementStack.Pop();
AddValue(item);
}
}
public void Code(Type t, ref object o)
{
TypeCoder.Write(this, t, ref o);
}