private void GenerateDataObjectClass(string className, List<Parameter> parameters, string @namespace, bool isValueType, Type dataObjecDataType = null)
{
if (@namespace != null)
{
WriteLine("namespace {0}", @namespace);
WriteStartBraceIndent();
}
var structclass = (isValueType) ? "struct" : "class";
var baseDataObjects = GetBaseDataObjects(dataObjecDataType);
var baseDataObjectCount = (baseDataObjects == null) ? 0 : baseDataObjects.Count;
var baseDataObject = (baseDataObjectCount == 0) ? null : baseDataObjects[0];
if (baseDataObject != null)
{
WriteLine("public {0} {1} : {2}", structclass, className, GetStubsClassName(baseDataObject, true));
}
else
{
var @interface = (isValueType) ? "IDataObject" : "IObservableDataObject";
WriteLine("public {0} {1} : {2}", structclass, className, @interface);
}
WriteStartBraceIndent();
// Generate fields
if (!isValueType)
{
WriteLine("public class Reference : {0}, IDataObjectReference", className);
WriteStartBraceIndent();
WriteLine("public RemotingPeer Peer { get; private set; }");
WriteLine("public int RemoteId { get; private set; }");
WriteLine("public ReferenceManager ReferenceManager { get; private set; }");
NewLine();
WriteLine("public Reference(RemotingPeer peer, int remoteId, ReferenceManager referenceManager)");
WriteStartBraceIndent();
WriteLine("Peer = peer;");
WriteLine("RemoteId = remoteId;");
WriteLine("ReferenceManager = referenceManager;");
WriteCloseBraceIndent();
WriteCloseBraceIndent();
NewLine();
if (baseDataObject == null)
{
WriteLine("private event Action<Type, int> propertyChanged;");
WriteLine("event Action<Type,int> IObservableDataObject.PropertyChanged");
WriteStartBraceIndent();
WriteLine("add { propertyChanged += value; }");
WriteLine("remove { propertyChanged -= value; }");
WriteCloseBraceIndent();
NewLine();
WriteLine("protected void OnPropertyChanged(Type type, int propertyId)");
WriteStartBraceIndent();
WriteLine("if(propertyChanged != null)");
WriteLineIndent("propertyChanged(type, propertyId);");
WriteCloseBraceIndent();
NewLine();
}
WriteLine("private BitField changedProperties;");
NewLine();
foreach (var param in parameters)
{
var backingFieldName = "__" + param.Name;
var paramTypeName = GetTypeName(param.ParameterType);
if (param.IsImplementedProperty)
{
WriteLine("private {0} {1} {{ get; set; }}", paramTypeName, backingFieldName);
var typeSig = new TypeSignature(param.ParameterType);
var declaringTypeSig = new TypeSignature(dataObjecDataType);
GenerationContext.MemberClones.Add(new MemberClone
{
OriginMember = new PropertySignature(typeSig, declaringTypeSig, param.Name),
Name = backingFieldName,
AccessModifier = AccessModifiers.Private,
NoCustomAttributes = true
});
var setParams = new List<ParameterSignature> {new ParameterSignature(typeSig, "value")};
var getMethodSig = new MethodSignature(typeSig, declaringTypeSig, "get_"+backingFieldName, new List<ParameterSignature>());
var setMethodSig = new MethodSignature(new TypeSignature(typeof(void)), declaringTypeSig, "set_"+backingFieldName, setParams);
GenerationContext.MemberOptions.Add(getMethodSig, Weaver.MemberOptions.UseOriginInstructions);
GenerationContext.MemberOptions.Add(setMethodSig, Weaver.MemberOptions.UseOriginInstructions);
}
else
{
WriteLine("private {0} {1};", paramTypeName, backingFieldName);
}
WriteLine("public {0} {1}", paramTypeName, ToTitleCase(param.Name));
WriteStartBraceIndent();
WriteLine("get {{ return {0}; }}", backingFieldName);
WriteLine("set");
WriteStartBraceIndent();
WriteLine("if( value == {0})", backingFieldName);
WriteLineIndent("return;");
NewLine();
WriteLine("{0} = value;", backingFieldName);
NewLine();
WriteLine("changedProperties.SetBit({0});", param.Id);
NewLine();
WriteLine("OnPropertyChanged(typeof({0}), {1});", className, param.Id);
WriteCloseBraceIndent();
WriteCloseBraceIndent();
NewLine();
}
WriteLine("public bool IsReference{ get; set; }");
NewLine();
WriteLine("public unsafe void GetResetChanges(BitField* bitFields)");
WriteStartBraceIndent();
WriteLine("bitFields[0] = changedProperties;");
WriteLine("changedProperties.Reset();");
if (baseDataObject != null)
{
NewLine();
WriteLine("(({0}) (object) this).GetResetChanges(bitFields++);", GetStubsClassName(baseDataObject, true));
}
WriteCloseBraceIndent();
NewLine();
}
else
{
foreach (var param in parameters)
{
var paramTypeName = GetTypeName(param.ParameterType);
WriteLine("public {0} {1};", paramTypeName, ToTitleCase(param.Name));
if(IsDelegate(param.ParameterType))
GenerationContext.Delegates.Add(param.ParameterType);
NewLine();
}
}
WriteLine("public int BaseDataObjectCount {{ get {{ return {0}; }} }}", baseDataObjectCount);
NewLine();
// Generate write methods
GenerateDataObjectWriteBitField(parameters, baseDataObject);
GenerateDataObjectWrite(className, baseDataObjectCount > 0, isValueType);
NewLine();
// Generate read method
GenerateDataObjectRead(className, baseDataObjectCount > 0, isValueType, parameters);
WriteCloseBraceIndent();
if (@namespace != null)
WriteCloseBraceIndent();
}
public MemberWithReturnSignature(TypeSignature returnType, TypeSignature declaringType, string name)
: base(declaringType, name)
{
ReturnType = returnType;
}
protected MemberSignature(TypeSignature declaringType, string name)
{
DeclaringType = declaringType;
Name = name;
}
public TypeSignature(TypeSignature declaringType, string name)
: base(declaringType, name)
{
Namespace = null;
}
public TypeSignatureCollection(IList<TypeReference> types)
{
Types = new TypeSignature[types.Count()];
for (int i = 0; i < types.Count(); i++)
Types[i] = new TypeSignature(types[i]);
}
public PropertySignature(TypeSignature propertyType, TypeSignature declaringType, string name)
: base(declaringType, name)
{
PropertyType = propertyType;
}
public ParameterSignature(TypeSignature paramType, string name)
{
ParamType = paramType;
Name = name;
}
public MethodSignature(MethodInfo method)
: base(new TypeSignature(method.DeclaringType), method.Name)
{
ReturnType = new TypeSignature(method.ReturnType);
Parameters = new List<ParameterSignature>();
foreach (var param in method.GetParameters())
Parameters.Add(new ParameterSignature(param));
}
public FieldSignature(TypeSignature fieldType, TypeSignature declaringType, string name)
: base(declaringType, name)
{
FieldType = fieldType;
}
public MethodSignature(TypeSignature returnType, TypeSignature declaringType, string name, List<ParameterSignature> parameters )
: base(declaringType, name)
{
ReturnType = returnType;
Parameters = parameters;
}