Пример #1
0
        public static DBPropertyModel MapToDB(BasePropertyMetadata propertyMetadata)
        {
            DBPropertyModel propertyModel = new DBPropertyModel
            {
                Name         = propertyMetadata.Name,
                TypeMetadata = DBTypeMapper.EmitReferenceDatabase(propertyMetadata.TypeMetadata)
            };

            return(propertyModel);
        }
Пример #2
0
        public static BasePropertyMetadata MapToBase(DBPropertyModel propertyMetadata)
        {
            BasePropertyMetadata propertyModel = new BasePropertyMetadata
            {
                Name         = propertyMetadata.Name,
                TypeMetadata = DBTypeMapper.EmitReferenceDTG(propertyMetadata.TypeMetadata)
            };

            return(propertyModel);
        }
Пример #3
0
 public PropertyMetadata(BasePropertyMetadata propertyMetadata)
 {
     m_Name = propertyMetadata.Name;
     if (propertyMetadata.TypeMetadata != null)
     {
         if (TypeMetadata.m_typesMetadata.ContainsKey(propertyMetadata.TypeMetadata.TypeName))
         {
             m_TypeMetadata = TypeMetadata.m_typesMetadata[propertyMetadata.TypeMetadata.TypeName];
         }
         else
         {
             m_TypeMetadata = new TypeMetadata(propertyMetadata.TypeMetadata);
         }
     }
 }
Пример #4
0
        public PropertyMetadata MapUp(BasePropertyMetadata model)
        {
            PropertyMetadata propertyModel = new PropertyMetadata();

            propertyModel.Name = model.Name;
            Type         type         = model.GetType();
            PropertyInfo typeProperty = type.GetProperty("Type",
                                                         BindingFlags.Instance | BindingFlags.Public | BindingFlags.DeclaredOnly);
            BaseTypeMetadata typeModel = (BaseTypeMetadata)typeProperty?.GetValue(model);

            if (typeModel != null)
            {
                propertyModel.Type = TypeModelMapper.EmitType(typeModel);
            }

            return(propertyModel);
        }
Пример #5
0
        public BasePropertyMetadata MapUp()
        {
            BasePropertyMetadata PropertyMetadataDTO = new BasePropertyMetadata();

            PropertyMetadataDTO.Name = m_Name;
            if (m_TypeMetadata != null)
            {
                if (BaseTypeMetadata.TypeDictionary.ContainsKey(m_TypeMetadata.m_typeName))
                {
                    PropertyMetadataDTO.TypeMetadata = BaseTypeMetadata.TypeDictionary[m_TypeMetadata.m_typeName];
                }
                else
                {
                    PropertyMetadataDTO.TypeMetadata = m_TypeMetadata.MapUp();
                }
            }
            return(PropertyMetadataDTO);
        }
Пример #6
0
        public BaseTypeMetadata MapUp()
        {
            BaseTypeMetadata TypeMetadataDTO = new BaseTypeMetadata();

            TypeMetadataDTO.TypeName      = m_typeName;
            TypeMetadataDTO.NamespaceName = m_NamespaceName;

            if (!BaseTypeMetadata.TypeDictionary.ContainsKey(this.m_typeName))
            {
                BaseTypeMetadata.TypeDictionary.Add(this.m_typeName, TypeMetadataDTO);
            }

            if (m_BaseType != null)
            {
                if (BaseTypeMetadata.TypeDictionary.ContainsKey(m_BaseType.m_typeName))
                {
                    TypeMetadataDTO.BaseType = BaseTypeMetadata.TypeDictionary[m_BaseType.m_typeName];
                }
                else
                {
                    TypeMetadataDTO.BaseType = m_BaseType.MapUp();
                }
            }

            if (m_GenericArguments != null)
            {
                List <BaseTypeMetadata> GenericArgumentsDTO = new List <BaseTypeMetadata>();
                foreach (TypeMetadata metadata in m_GenericArguments)
                {
                    BaseTypeMetadata baseTypeMetadata;
                    if (BaseTypeMetadata.TypeDictionary.ContainsKey(metadata.m_typeName))
                    {
                        baseTypeMetadata = BaseTypeMetadata.TypeDictionary[metadata.m_typeName];
                    }
                    else
                    {
                        baseTypeMetadata = metadata.MapUp();
                    }
                    GenericArgumentsDTO.Add(baseTypeMetadata);
                }
                TypeMetadataDTO.GenericArguments = GenericArgumentsDTO;
            }

            //TypeMetadataDTO.Modifiers = new Tuple<AccessLevel, SealedEnum, AbstractEnum>(m_Modifiers.Item1, m_Modifiers.Item2, m_Modifiers.Item3);

            if (m_ImplementedInterfaces != null)
            {
                List <BaseTypeMetadata> ImplementedInterfacesDTO = new List <BaseTypeMetadata>();
                foreach (TypeMetadata metadata in m_ImplementedInterfaces)
                {
                    BaseTypeMetadata baseTypeMetadata;
                    if (BaseTypeMetadata.TypeDictionary.ContainsKey(metadata.m_typeName))
                    {
                        baseTypeMetadata = BaseTypeMetadata.TypeDictionary[metadata.m_typeName];
                    }
                    else
                    {
                        baseTypeMetadata = metadata.MapUp();
                    }
                    ImplementedInterfacesDTO.Add(baseTypeMetadata);
                }
                TypeMetadataDTO.ImplementedInterfaces = ImplementedInterfacesDTO;
            }

            if (m_NestedTypes != null)
            {
                List <BaseTypeMetadata> NestedTypeDTO = new List <BaseTypeMetadata>();
                foreach (TypeMetadata metadata in m_NestedTypes)
                {
                    BaseTypeMetadata baseTypeMetadata;
                    if (BaseTypeMetadata.TypeDictionary.ContainsKey(metadata.m_typeName))
                    {
                        baseTypeMetadata = BaseTypeMetadata.TypeDictionary[metadata.m_typeName];
                    }
                    else
                    {
                        baseTypeMetadata = metadata.MapUp();
                    }
                    NestedTypeDTO.Add(baseTypeMetadata);
                }
                TypeMetadataDTO.NestedTypes = NestedTypeDTO;
            }
            if (m_Properties != null)
            {
                List <BasePropertyMetadata> PropertiesDTO = new List <BasePropertyMetadata>();
                foreach (PropertyMetadata metadata in m_Properties)
                {
                    BasePropertyMetadata propertyMetadata = metadata.MapUp();
                    PropertiesDTO.Add(propertyMetadata);
                }
                TypeMetadataDTO.Properties = PropertiesDTO;
            }

            if (m_DeclaringType != null)
            {
                if (BaseTypeMetadata.TypeDictionary.ContainsKey(m_DeclaringType.m_typeName))
                {
                    TypeMetadataDTO.DeclaringType = BaseTypeMetadata.TypeDictionary[m_DeclaringType.m_typeName];
                }
                else
                {
                    TypeMetadataDTO.DeclaringType = m_DeclaringType.MapUp();
                }
            }

            if (m_Methods != null)
            {
                List <BaseMethodMetadata> MethodMetadataDTO = new List <BaseMethodMetadata>();
                foreach (MethodMetadata metadata in m_Methods)
                {
                    BaseMethodMetadata methodMetadata = metadata.MapUp();
                    MethodMetadataDTO.Add(methodMetadata);
                }
                TypeMetadataDTO.Methods = MethodMetadataDTO;
            }
            if (m_Constructors != null)
            {
                List <BaseMethodMetadata> ConstructorsDTO = new List <BaseMethodMetadata>();
                foreach (MethodMetadata metadata in m_Methods)
                {
                    BaseMethodMetadata methodMetadata = metadata.MapUp();
                    ConstructorsDTO.Add(methodMetadata);
                }
                TypeMetadataDTO.Constructors = ConstructorsDTO;
            }
            if (!BaseTypeMetadata.TypeDictionary.ContainsKey(TypeMetadataDTO.TypeName))
            {
                BaseTypeMetadata.TypeDictionary.Add(TypeMetadataDTO.TypeName, TypeMetadataDTO);
            }
            TypeMetadataDTO.TypeKind = m_TypeKind;
            return(TypeMetadataDTO);
        }
Пример #7
0
 public XMLPropertyModel(BasePropertyMetadata propertyBase)
 {
     Name         = propertyBase.Name;
     TypeMetadata = XMLTypeModel.GetOrAdd(propertyBase.TypeMetadata);
 }