public object readObject(TypeData expectedType) { if (expectedType.isValueType()) { return readValue(expectedType); } int objectId = readId(); // see if it's one we've already seen if (objectId < _objects.Count) { return _objects[objectId]; } // verify that objectId is as expected if (objectId != _objects.Count) { // TODO throw new System.Exception("Precondition failed: read bad id."); } // TODO: we need to pass the objectId to the TypeData so that they can call back to a // new method on this class for setting the typedata into the slot properly. // I tried to do this (Sep 10) but it causes f*****g unity to crash, crash, crash. // It could even log that I did it after the fact, and that line would log but then // unity would crash. // So: hooray for a shitty life. I already fixed this problem, but now it needs to // remain broken until I can fix it again... _objects.Add(null); object value = readValue(expectedType); _objects[objectId] = value; return value; }
// TODO: sort out argument order, etc, with superclass public GenericExportingReflectiveTypeData( ExportContext ctx, Type fullType, TypeData baseType, TypeData[] args) : base(fullType, ctx) { _baseType = baseType; _args = args; }
public override object readObject(ImportContext ctx, TypeData[] typeArgs = null) { object value = (_type == null) ? null : Activator.CreateInstance(_type); int fieldCount = ctx.readLength(); this.logInfo("Reading " + fieldCount + " fields..."); for (int ii = 0; ii < fieldCount; ii++) { int fieldId = ctx.readId(); FieldData field; if (fieldId < _fields.Count) { field = _fields[fieldId]; } else { // ASSERT the fieldId // TODO if (fieldId != _fields.Count) { this.logWarning("Unexpected field id!", "expected", _fields.Count, "got", fieldId); throw new Exception("Unexpected field id!"); } // new field string name = ctx.readString(); TypeData type = ctx.readType(); FieldInfo fieldInfo; if (_fieldInfo != null) { _fieldInfo.TryGetValue(name, out fieldInfo); if (_fieldInfo == null) { ctx.warn("Importing class no longer has field: " + name); } } else { fieldInfo = null; } // fieldInfo can now be null field = new FieldData(type, fieldInfo); _fields.Add(field); } field.readField(ctx, value); } return value; }
public override void writeObject(ExportContext ctx, object value, TypeData[] typeArgs = null) { // make a list of all the fields that have changed, then send only those // TODO: Improve this.. Perhaps it writes them all to a new stream, a byte[], so that // we can insert the length afterwards... ugh... List<FieldData> fields = null; foreach (FieldData field in _fields) { if (field.hasChanged(value)) { (fields ?? (fields = new List<FieldData>())).Add(field); } } if (fields == null) { ctx.writeLength(0); return; } ctx.writeLength(fields.Count); foreach (FieldData field in fields) { field.writeField(ctx, this, value); } }
public override void writeObject(ExportContext ctx, object value, TypeData[] typeArgs = null) { _baseType.writeObject(ctx, value, _args); }
protected void readEntries( ImportContext ctx, Action<object> addAction, int size, TypeData expectedElementType) { for (int ii = 0; ii < size; ii++) { addAction(ctx.readObject(expectedElementType)); } }
public override object readObject(ImportContext ctx, TypeData[] typeArgs = null) { return _baseType.readObject(ctx, _args); }
public FieldData(TypeData type, FieldInfo field) { _type = type; _field = field; }
public override void writeObject(ExportContext ctx, object value, TypeData[] typeArgs = null) { throw new Exception(); }
public override object readObject(ImportContext ctx, TypeData[] typeArguments = null) { return ctx.readString(); }
public abstract object readObject(ImportContext ctx, TypeData[] typeArguments = null);
public override void writeObject(ExportContext ctx, object value, TypeData[] typeArgs = null) { IList list = (IList)value; writeEntries(ctx, list, list.Count, typeArgs[0]); }
public override object readObject(ImportContext ctx, TypeData[] typeArgs = null) { int size = ctx.readLength(); TypeData elementType = typeArgs[0]; Type fullType = typeof(HashMultiset<>).MakeGenericType(elementType.getType()); object value = Activator.CreateInstance(fullType); if (size > 0) { MethodInfo method = fullType.GetMethod("Add", new Type[] { elementType.getType(), typeof(int) }); object[] argArray = new object[2]; for (int ii = 0; ii < size; ii++) { argArray[0] = ctx.readObject(elementType); argArray[1] = ctx.readLength(); method.Invoke(value, argArray); } } return value; }
public override void writeObject(ExportContext ctx, object value, TypeData[] typeArguments = null) { ctx.writeFloat((float)value); }
public override object readObject(ImportContext ctx, TypeData[] typeArgs = null) { int size = ctx.readLength(); TypeData elementType = typeArgs[0]; Type listType = getType().MakeGenericType(elementType.getType()); IList list = (IList)Activator.CreateInstance(listType); readEntries(ctx, o => list.Add(o), size, elementType); return list; }
public override void writeObject(ExportContext ctx, object value, TypeData[] typeArgs = null) { string s = Enum.GetName(_type, value); if (s == null) { throw new ArgumentException("Enum value has no name: " + _type + ": " + value); } ctx.writeString(s); }
public override object readObject(ImportContext ctx, TypeData[] typeArgs = null) { string s = ctx.readString(); if (_type != null) { try { return Enum.Parse(_type, s); } catch (ArgumentException) { ctx.warn("could not find enum constant '" + s + "' in type " + _type); } } return null; }
protected void writeEntries( ExportContext ctx, IEnumerable enumerable, int size, TypeData expectedElementType) { ctx.writeLength(size); foreach (object entry in enumerable) { ctx.writeObject(entry, expectedElementType); } }
public override object readObject(ImportContext ctx, TypeData[] typeArgs = null) { int size = ctx.readLength(); TypeData elementType = typeArgs[0]; Type setType = getType().MakeGenericType(elementType.getType()); object theSet = Activator.CreateInstance(setType); MethodInfo method = setType.GetMethod("Add"); object[] argArray = new object[1]; Action<object> addAction = obj => { argArray[0] = obj; method.Invoke(theSet, argArray); }; readEntries(ctx, addAction, size, elementType); return theSet; }
public override void writeObject(ExportContext ctx, object value, TypeData[] typeArgs = null) { // TODO: we should consider making a non-generic IMuliset interface for easy wildcarding TypeData elementType = typeArgs[0]; Type fullType = value.GetType(); int size = (int)fullType.GetProperty("ElementCount").GetValue(value, null); ctx.writeLength(size); if (size == 0) { return; } IEnumerable en = (IEnumerable)fullType.GetMethod("EntrySet").Invoke(value, null); PropertyInfo getKey = null, getVal = null; foreach (var entry in en) { if (getKey == null) { Type entryType = entry.GetType(); getKey = entryType.GetProperty("Key"); getVal = entryType.GetProperty("Value"); } this.logInfo("Writing value of multiset", "value", getKey.GetValue(entry, null)); ctx.writeObject(getKey.GetValue(entry, null), elementType); ctx.writeLength((int)getVal.GetValue(entry, null)); } }
public override void writeObject(ExportContext ctx, object value, TypeData[] typeArgs = null) { // TODO: with a newer version of .NET we could do this better IEnumerable en = (IEnumerable)value; int size = en.Cast<object>().Count(); // TODO writeEntries(ctx, en, size, typeArgs[0]); }
public override object readObject(ImportContext ctx, TypeData[] typeArguments = null) { // TODO: is this correct? return ctx.readObject(this); }
public override void writeObject(ExportContext ctx, object value, TypeData[] typeArguments = null) { ctx.writeString((string)value); }
public override void writeObject(ExportContext ctx, object value, TypeData[] typeArgs = null) { TypeData keyType = typeArgs[0]; TypeData valType = typeArgs[1]; Type fullType = value.GetType(); int size = (int)fullType.GetProperty("Count").GetValue(value, null); ctx.writeLength(size); if (size == 0) { return; } Type entryType = typeof(KeyValuePair<,>).MakeGenericType( keyType.getType(), valType.getType()); Type ienumerableType = typeof(IEnumerable<>).MakeGenericType(entryType); IEnumerator en = (IEnumerator) ienumerableType.GetMethod("GetEnumerator").Invoke(value, null); PropertyInfo getKey = entryType.GetProperty("Key"); PropertyInfo getVal = entryType.GetProperty("Value"); while (en.MoveNext()) { var entry = en.Current; ctx.writeObject(getKey.GetValue(entry, null), keyType); ctx.writeObject(getVal.GetValue(entry, null), valType); } }
public abstract void writeObject(ExportContext ctx, object value, TypeData[] typeArguments = null);
/** * Construct a ParameterizedTypeData during exporting. */ public ParameterizedTypeData(Type fullType, TypeData baseType, TypeData[] args = null) : base(fullType) { _baseType = baseType; _args = args; }
public override object readObject(ImportContext ctx, TypeData[] typeArgs = null) { int size = ctx.readLength(); TypeData keyType = typeArgs[0]; TypeData valType = typeArgs[1]; Type dicType = getType().MakeGenericType(keyType.getType(), valType.getType()); IDictionary dic = (IDictionary)Activator.CreateInstance(dicType); this.logInfo("Going to be reading in...", "dic", dic, "keyType", keyType.getType()); for (int ii = 0; ii < size; ii++) { dic.Add(ctx.readObject(keyType), ctx.readObject(valType)); } return dic; }
// TODO: isFinal... maybe if the base class if final and all the parameter types are final? /** * Construct a ParameterizedTypeData during importing. */ public ParameterizedTypeData(TypeData baseType, TypeData[] args = null) : this(baseType.getType().MakeGenericType(args.Select(arg => arg.getType()).ToArray()), baseType, args) { }
public override void writeObject(ExportContext ctx, object value, TypeData[] typeArguments = null) { // TODO: is this correct? ctx.writeObject(value, this); }
public override void writeObject(ExportContext ctx, object value, TypeData[] typeArguments = null) { ctx.writeDouble((double)value); }