public void EmitSimpleIntefaceMember(CodeTypeDeclaration type, bool get, bool set)
{
if (get && set)
{
type.DeclareProperty(Decorator.ClrType, Decorator.Definition.Name, _ => { }, _ => { });
}
else if (get)
{
type.DeclareProperty(Decorator.ClrType, Decorator.Definition.Name, _ => { }, null);
}
else if (set)
{
type.DeclareProperty(Decorator.ClrType, Decorator.Definition.Name, null, _ => { });
}
}
public override void EmitObjectMembers(CodeTypeDeclaration type)
{
type.DeclareProperty("Ascension.Networking.NetworkTransform", Decorator.Definition.Name,
get =>
{
get.Expr("return Storage.Values[this.OffsetStorage + {0}].Transform", Decorator.OffsetStorage);
});
}
public void EmitSimplePropertyMembers(CodeTypeDeclaration type, CodeSnippetExpression storage,
CodeTypeReference interfaceType, bool changed, string name)
{
CodeIndexerExpression index = new CodeIndexerExpression(storage.Field("Values"),
"this.OffsetStorage + {0}".Expr(Decorator.OffsetStorage));
// getter method
Action <CodeStatementCollection> getter = get =>
{
get.Add(
new CodeMethodReturnStatement(
new CodeFieldReferenceExpression(index, StorageField)
)
);
};
// setter method
Action <CodeStatementCollection> setter = set =>
{
PropertyStateSettings s = Decorator.Definition.StateAssetSettings;
if (s != null && VerifyModify)
{
EmitAllowedCheck(set);
}
// allows emission of a validator snippet
EmitSetPropertyValidator(set, type, storage, interfaceType, changed, name);
if (changed)
{
set.Add("{0} oldValue".Expr(Decorator.ClrType));
set.Add("oldValue".Expr().Assign(new CodeFieldReferenceExpression(index, StorageField)));
}
set.Add(new CodeAssignStatement(
new CodeFieldReferenceExpression(index, StorageField),
new CodeVariableReferenceExpression("value")
));
if (changed)
{
string diff = Decorator.Definition.PropertyType.StrictCompare ? "Diff_Strict" : "Diff";
set.If("Ascension.Networking.NetworkValue.{0}(oldValue, value)".Expr(diff),
body => { EmitPropertyChanged(body, storage); });
}
};
if (!AllowSetter)
{
setter = null;
}
CodeMemberProperty property = type.DeclareProperty(Decorator.ClrType, name, getter, setter);
property.PrivateImplementationType = interfaceType;
property.Attributes = Decorator.Attributes;
}
public override void EmitObjectMembers(CodeTypeDeclaration type)
{
type.DeclareProperty(Decorator.ClrType, Decorator.Definition.Name,
get =>
{
get.Expr("return ({0}) (Objects[this.OffsetObjects + {1}])", Decorator.ClrType,
Decorator.OffsetObjects);
});
}
private void DeclareProperty(CodeTypeDeclaration type, bool emitSetter)
{
Action <CodeStatementCollection> getter =
get =>
{
get.Expr("return ({0})(Objects[this.OffsetObjects + {1}])", Decorator.ClrType,
Decorator.OffsetObjects);
};
type.DeclareProperty(
Decorator.Object.EmitAsInterface ? Decorator.Object.NameInterface : Decorator.Object.Name,
Decorator.Definition.Name, getter, null);
}
protected virtual void EmitFactory()
{
CodeTypeReference factoryInterface = new CodeTypeReference("Ascension.Networking.IFactory");
MetaType.DeclareProperty("Ascension.Networking.TypeId", "TypeId", get => { get.Expr("return TypeId"); })
.PrivateImplementationType = factoryInterface;
MetaType.DeclareProperty("Ascension.Networking.UniqueId", "TypeKey",
get =>
{
get.Expr("return new Ascension.Networking.UniqueId({0})", Decorator.Definition.Guid.ToByteArray().Join(", "));
})
.PrivateImplementationType = factoryInterface;
MetaType.DeclareProperty("System.Type", "TypeObject",
get =>
{
get.Expr("return typeof({0})", Decorator.EmitAsInterface ? Decorator.NameInterface : Decorator.Name);
}).PrivateImplementationType = factoryInterface;
MetaType.DeclareMethod(typeof(object).FullName, "Create",
methoid => { methoid.Statements.Expr("return new {0}()", Decorator.Name); }).PrivateImplementationType =
factoryInterface;
}
