/// <summary>
/// Fills in the given type declaration based on the given metadata
/// </summary>
/// <param name="entityType">The entity type's metadata</param>
/// <param name="entityTypeClass">The type declaration</param>
protected override void DeclareEntityType(EntityType entityType, CodeTypeDeclaration entityTypeClass)
{
entityTypeClass.IsPartial = true;
entityTypeClass.IsClass = true;
if (entityType.IsAbstract)
{
entityTypeClass.SetAbstract();
}
if (entityType.BaseType != null)
{
entityTypeClass.BaseTypes.Add(entityType.BaseType.FullName);
}
// Add public constructor for this type
var constructor = entityTypeClass.AddConstructor();
// Declare all members that are declared
foreach (MemberProperty memberProperty in entityType.Properties)
{
this.DeclareMemberProperty(memberProperty, entityTypeClass);
this.DeclareOptionalPropertyInitializer(memberProperty, constructor);
}
// Declare all members that are declared
foreach (NavigationProperty navigationProperty in entityType.NavigationProperties)
{
this.DeclareNavigationProperty(navigationProperty, entityTypeClass);
this.DeclareOptionalPropertyInitializer(navigationProperty, constructor);
}
this.GenerateAttributes(entityType, entityTypeClass);
}
public static void AddConstructorMethod(this CodeTypeDeclaration type, RpcTypeDescriptor complex_type, IEnumerable <Tuple <CodeTypeReference, string> > parameters)
{
if (!parameters.Any())
{
return;
}
CodeMemberMethod method = type.AddConstructor(MemberAttributes.Public | MemberAttributes.Final);
method.AddAssignmentStatements(new CodeThisReferenceExpression(), parameters);
}
/// <summary>
/// Fills in the given type declaration based on the given metadata
/// </summary>
/// <param name="complexType">The complex type's metadata</param>
/// <param name="complexTypeClass">The type declaration</param>
protected override void DeclareComplexType(ComplexType complexType, CodeTypeDeclaration complexTypeClass)
{
complexTypeClass.IsPartial = true;
complexTypeClass.IsClass = true;
// Add public constructor for this type
var constructor = complexTypeClass.AddConstructor();
foreach (MemberProperty memberProperty in complexType.Properties)
{
this.DeclareMemberProperty(memberProperty, complexTypeClass);
this.DeclareOptionalPropertyInitializer(memberProperty, constructor);
}
}
/// <summary>
/// Builds a code representation of an <see cref="ComplexType"/>.
/// </summary>
/// <param name="type">The <see cref="ComplexType"/> from which to generate code.</param>
/// <returns>A <see cref="CodeTypeDeclaration"/> which represents the <see cref="ComplexType"/>.</returns>
protected virtual CodeTypeDeclaration BuildType(ComplexType type)
{
var codeClass = new CodeTypeDeclaration(type.Name);
codeClass.AddConstructor();
ApplyTypeAccessModifier(codeClass, type.Annotations.OfType <TypeAccessModifierAnnotation>().SingleOrDefault());
if (type.Annotations.Any(a => a is SerializableAnnotation))
{
codeClass.AddCustomAttribute(typeof(SerializableAttribute));
}
if (type.Annotations.Any(a => a is CodeAttributeAnnotation))
{
this.AddCodeAttributeAnnotationAsCustomAttribute(codeClass, type.Annotations.OfType <CodeAttributeAnnotation>());
}
this.AddProperties(codeClass, type);
return(codeClass);
}
/// <summary>
/// Builds a code representation of an <see cref="EntityType"/>.
/// </summary>
/// <param name="type">The <see cref="EntityType"/> from which to generate code.</param>
/// <returns>A <see cref="CodeTypeDeclaration"/> which represents the <see cref="EntityType"/>.</returns>
protected virtual CodeTypeDeclaration BuildType(EntityType type)
{
var codeClass = new CodeTypeDeclaration(type.Name);
var defaultConstructor = codeClass.AddConstructor();
ApplyTypeAccessModifier(codeClass, type.Annotations.OfType <TypeAccessModifierAnnotation>().SingleOrDefault());
if (type.Annotations.Any(a => a is SerializableAnnotation))
{
codeClass.AddCustomAttribute(typeof(SerializableAttribute));
}
if (type.Annotations.Any(a => a is CodeAttributeAnnotation))
{
this.AddCodeAttributeAnnotationAsCustomAttribute(codeClass, type.Annotations.OfType <CodeAttributeAnnotation>());
}
var genericTypeAnnotation = type.Annotations.OfType <GenericTypeAnnotation>().FirstOrDefault();
if (genericTypeAnnotation != null)
{
foreach (var typeParameter in genericTypeAnnotation.TypeParameters)
{
codeClass.TypeParameters.Add(new CodeTypeParameter(typeParameter));
}
}
if (type.BaseType != null)
{
var baseType = new CodeTypeReference(type.BaseType.FullName);
var baseGenericTypeAnnotation = type.BaseType.Annotations.OfType <GenericTypeAnnotation>().SingleOrDefault();
var genericArgumentsAnnotation = type.Annotations.OfType <GenericArgumentsAnnotation>().SingleOrDefault();
if (genericArgumentsAnnotation != null)
{
foreach (var typeParameter in baseGenericTypeAnnotation.TypeParameters)
{
var typeRef = Code.TypeRef(typeParameter);
var argument = genericArgumentsAnnotation.GenericArguments.SingleOrDefault(g => g.TypeParameterName == typeParameter);
if (argument != null)
{
typeRef = codeTypeReferenceResolver.Resolve(argument.DataType);
}
else
{
if (genericTypeAnnotation == null || !genericTypeAnnotation.TypeParameters.Contains(typeParameter))
{
throw new TaupoArgumentException(
string.Format(
CultureInfo.InvariantCulture,
"Entity type {0} cannot derive from entity type {1} because it does not specify a {2} or {3} to fill in {1}'s generic parameter {4}.",
type.Name,
type.BaseType.Name,
typeof(GenericTypeAnnotation).Name,
typeof(GenericArgumentsAnnotation).Name,
typeParameter));
}
}
baseType.TypeArguments.Add(typeRef);
}
}
else
{
if (baseGenericTypeAnnotation != null)
{
throw new TaupoArgumentException(
string.Format(
CultureInfo.InvariantCulture,
"Entity type {0} cannot derive from entity type {1} because it does not specify a {2} or {3} to fill in {1}'s generic parameter {4}.",
type.Name,
type.BaseType.Name,
typeof(GenericTypeAnnotation).Name,
typeof(GenericArgumentsAnnotation).Name,
baseGenericTypeAnnotation.TypeParameters.First()));
}
}
codeClass.InheritsFrom(baseType);
}
if (type.IsAbstract)
{
codeClass.SetAbstract();
}
this.AddProperties(codeClass, type);
this.AddNavigationProperties(codeClass, type, defaultConstructor);
return(codeClass);
}
private void GenerateClient(string name, CodeNamespace ns, int complex_type_count)
{
CodeTypeDeclaration type = ns.AddType(name);
type.IsClass = true;
type.TypeAttributes = TypeAttributes.Public | TypeAttributes.Sealed;
type.BaseTypes.Add(typeof(RpcAlpcClientBase));
CodeConstructor constructor = type.AddConstructor(MemberAttributes.Public | MemberAttributes.Final);
constructor.BaseConstructorArgs.Add(CodeGenUtils.GetPrimitive(_server.InterfaceId.ToString()));
constructor.BaseConstructorArgs.Add(CodeGenUtils.GetPrimitive(_server.InterfaceVersion.Major));
constructor.BaseConstructorArgs.Add(CodeGenUtils.GetPrimitive(_server.InterfaceVersion.Minor));
foreach (var proc in _server.Procedures)
{
string proc_name = proc.Name;
if (!_proc_names.Add(proc_name))
{
proc_name = $"{proc_name}_{proc.ProcNum}";
if (!_proc_names.Add(proc_name))
{
throw new ArgumentException($"Duplicate name {proc.Name}");
}
}
var method = type.AddMethod(proc_name, MemberAttributes.Public | MemberAttributes.Final);
RpcTypeDescriptor return_type = GetTypeDescriptor(proc.ReturnValue.Type);
if (return_type == null)
{
method.ThrowNotImplemented("Return type unsupported.");
continue;
}
var offset_to_name =
proc.Params.Select(p => Tuple.Create(p.Offset, p.Name)).ToList();
method.ReturnType = return_type.CodeType;
method.CreateMarshalObject(MARSHAL_NAME);
foreach (var p in proc.Params)
{
if (p == proc.Handle)
{
continue;
}
RpcTypeDescriptor p_type = GetTypeDescriptor(p.Type);
List <RpcMarshalArgument> extra_marshal_args = new List <RpcMarshalArgument>();
if (p_type.VarianceDescriptor.IsValid)
{
extra_marshal_args.Add(p_type.VarianceDescriptor.CalculateCorrelationArgument(p.Offset, offset_to_name));
}
var p_obj = method.AddParam(p_type.GetParameterType(), p.Name);
p_obj.Direction = p.GetDirection();
if (!p.IsIn)
{
continue;
}
if (p_type.Pointer)
{
if (p_type.PointerType == RpcPointerType.Reference)
{
method.AddNullCheck(MARSHAL_NAME, p.Name);
}
else
{
method.AddWriteReferent(MARSHAL_NAME, p.Name);
}
}
else if (!p_type.ValueType)
{
method.AddNullCheck(MARSHAL_NAME, p.Name);
}
method.AddMarshalCall(p_type, MARSHAL_NAME, p.Name, extra_marshal_args.ToArray());
// If it's a constructed type then ensure any deferred writes are flushed.
if (p_type.Constructed)
{
method.AddFlushDeferredWrites(MARSHAL_NAME);
}
}
method.SendReceive(MARSHAL_NAME, UNMARSHAL_NAME, proc.ProcNum);
foreach (var p in proc.Params.Where(x => x.IsOut))
{
if (p == proc.Handle)
{
continue;
}
RpcTypeDescriptor p_type = GetTypeDescriptor(p.Type);
if (p_type.Pointer)
{
method.AddPointerUnmarshalCall(p_type, UNMARSHAL_NAME, p.Name);
}
else
{
method.AddUnmarshalCall(p_type, UNMARSHAL_NAME, p.Name);
}
if (p_type.Constructed)
{
method.AddPopluateDeferredPointers(UNMARSHAL_NAME);
}
}
method.AddUnmarshalReturn(return_type, UNMARSHAL_NAME);
}
if (complex_type_count > 0 && HasFlag(RpcClientBuilderFlags.GenerateConstructorProperties))
{
var constructor_type = new CodeTypeReference(CodeGenUtils.MakeIdentifier(CONSTRUCTOR_STRUCT_NAME));
var prop = type.AddProperty("New", constructor_type, MemberAttributes.Public | MemberAttributes.Final,
new CodeMethodReturnStatement(new CodeObjectCreateExpression(constructor_type)));
constructor_type = new CodeTypeReference(CodeGenUtils.MakeIdentifier(ARRAY_CONSTRUCTOR_STRUCT_NAME));
type.AddProperty("NewArray", constructor_type, MemberAttributes.Public | MemberAttributes.Final,
new CodeMethodReturnStatement(new CodeObjectCreateExpression(constructor_type)));
}
}
