示例#1
0
        /// <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);
        }
示例#2
0
        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);
        }
示例#3
0
        /// <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);
            }
        }
示例#4
0
        /// <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);
        }
示例#5
0
        /// <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);
        }
示例#6
0
        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)));
            }
        }