Exemple #1
0
        public static string GetTypeScriptName(ITypeMetadata metadata)
        {
            if (metadata == null)
                return "any";

            if (metadata.IsEnumerable)
            {
                var genericTypeArguments = metadata.GenericTypeArguments.ToList();

                if (genericTypeArguments.Count == 1)
                    return GetTypeScriptName(genericTypeArguments.FirstOrDefault()) + "[]";

                if (genericTypeArguments.Count == 2)
                {
                    var key = GetTypeScriptName(genericTypeArguments[0]);
                    var value = GetTypeScriptName(genericTypeArguments[1]);

                    return string.Concat("{ [key: ", key, "]: ", value, "; }");
                }

                return "any";
            }

            if (metadata.IsGeneric)
                return metadata.Name + string.Concat("<", string.Join(", ", metadata.GenericTypeArguments.Select(GetTypeScriptName)), ">");

            return ExtractTypeScriptName(metadata);
        }
Exemple #2
0
        private static string ExtractTypeScriptName(ITypeMetadata metadata)
        {
            var fullName = metadata.IsNullable ? metadata.FullName.TrimEnd('?') : metadata.FullName;

            switch (fullName)
            {
                case "System.Boolean":
                    return "boolean";
                case "System.String":
                case "System.Char":
                case "System.Guid":
                case "System.TimeSpan":
                    return "string";
                case "System.Byte":
                case "System.SByte":
                case "System.Int16":
                case "System.Int32":
                case "System.Int64":
                case "System.UInt16":
                case "System.UInt32":
                case "System.UInt64":
                case "System.Single":
                case "System.Double":
                case "System.Decimal":
                    return "number";
                case "System.DateTime":
                case "System.DateTimeOffset":
                    return "Date";
                case "System.Void":
                    return "void";
            }

            return metadata.IsNullable ? metadata.Name.TrimEnd('?') : metadata.Name;
        }
        /// <summary>
        /// Deserialize a user type instance from a POF stream by reading its
        /// state using the specified <see cref="IPofReader"/> object.
        /// </summary>
        /// <remarks>
        /// An implementation of <b>IPofSerializer</b> is required to follow
        /// the following steps in sequence for reading in an object of a
        /// user type:
        /// <list type="number">
        /// <item>
        /// <description>
        /// If the object is evolvable, the implementation must get the
        /// version by calling <see cref="IPofWriter.VersionId"/>.
        /// </description>
        /// </item>
        /// <item>
        /// <description>
        /// The implementation may read any combination of the
        /// properties of the user type by using "read" methods of the
        /// <b>IPofReader</b>, but it must do so in the order of the property
        /// indexes.
        /// </description>
        /// </item>
        /// <item>
        /// <description>
        /// After all desired properties of the user type have been read,
        /// the implementation must terminate the reading of the user type by
        /// calling <see cref="IPofReader.ReadRemainder"/>.
        /// </description>
        /// </item>
        /// </list>
        /// </remarks>
        /// <param name="reader">
        /// The <b>IPofReader</b> with which to read the object's state.
        /// </param>
        /// <returns>
        /// The deserialized user type instance.
        /// </returns>
        /// <exception cref="IOException">
        /// If an I/O error occurs.
        /// </exception>
        public virtual object Deserialize(IPofReader reader)
        {
            ITypeMetadata <object> tmd = m_tmd;
            object value = tmd.NewInstance();

            // set the version identifier
            bool       isEvolvable = value is IEvolvable;
            IEvolvable evolvable   = null;

            if (isEvolvable)
            {
                evolvable             = (IEvolvable)value;
                evolvable.DataVersion = reader.VersionId;
            }

            // POF Annotation processing
            for (IEnumerator enmr = tmd.GetAttributes(); enmr.MoveNext();)
            {
                IAttributeMetadata <object> attr = (IAttributeMetadata <object>)enmr.Current;
                attr.Set(value, attr.Codec.Decode(reader, attr.Index));
            }

            // read any future properties
            Binary remainder = reader.ReadRemainder();

            if (isEvolvable)
            {
                evolvable.FutureData = remainder;
            }

            return(value);
        }
        /// <summary>
        /// Compare the TypeMetadata with another TypeMetadata object to
        /// determine equality.
        /// </summary>
        /// <remarks>
        /// Two TypeMetadata objects are considered equal iff their
        /// <see cref="ITypeKey"/> values and
        /// <see cref="IAttributeMetadata{T}"/>s are equal.
        /// </remarks>
        /// <param name="that">
        /// ITypeMetadata instance to compare this instance to.
        /// </param>
        /// <returns>
        /// <c>true</c> iff this TypeMetadata and the passed object are
        /// equivalent.
        /// </returns>
        public virtual bool Equals(ITypeMetadata <T> that)
        {
            if (this == that)
            {
                return(true);
            }

            // check key and version
            if (!Equals(Key, that.Key))
            {
                return(false);
            }

            for (IEnumerator enmrThis = GetAttributes(), enmrThat = that.GetAttributes(); ;)
            {
                var attributeThis = enmrThis.MoveNext() ? enmrThis.Current : null;
                var attributeThat = enmrThat.MoveNext() ? enmrThat.Current : null;
                if (!Equals(attributeThis, attributeThat))
                {
                    return(false);
                }
                // we assume an attribute returned by the enmr will never be null
                if (attributeThis == null && attributeThat == null)
                {
                    break;
                }
            }
            return(true);
        }
Exemple #5
0
 private TypeImpl(ITypeMetadata metadata, Item parent)
 {
     _metadata = metadata;
     Parent = parent;
     _lazyName = new Lazy<string>(() => GetTypeScriptName(metadata));
     _lazyOriginalName = new Lazy<string>(() => GetOriginalName(metadata));
 }
Exemple #6
0
        public static string GetTypeScriptName(ITypeMetadata metadata)
        {
            if (metadata == null)
            {
                return("any");
            }

            if (metadata.IsEnumerable)
            {
                var typeArguments = metadata.TypeArguments.ToList();

                if (typeArguments.Count == 1)
                {
                    return(GetTypeScriptName(typeArguments.FirstOrDefault()) + "[]");
                }

                if (typeArguments.Count == 2)
                {
                    var key   = GetTypeScriptName(typeArguments[0]);
                    var value = GetTypeScriptName(typeArguments[1]);

                    return(string.Concat("{ [key: ", key, "]: ", value, "; }"));
                }

                return("any[]");
            }

            if (metadata.IsGeneric)
            {
                return(metadata.Name + string.Concat("<", string.Join(", ", metadata.TypeArguments.Select(GetTypeScriptName)), ">"));
            }

            return(ExtractTypeScriptName(metadata));
        }
 private TypeImpl(ITypeMetadata metadata, Object parent)
 {
     _metadata           = metadata;
     Parent              = parent;
     _lazyName           = new LazyString(() => Helpers.GetOriginalName(metadata));
     _lazyTypescriptName = new LazyString(() => Helpers.GetTypeScriptName(metadata));
 }
Exemple #8
0
 private TypeImpl(ITypeMetadata metadata, Item parent)
 {
     _metadata         = metadata;
     Parent            = parent;
     _lazyName         = new Lazy <string>(() => GetTypeScriptName(metadata));
     _lazyOriginalName = new Lazy <string>(() => GetOriginalName(metadata));
 }
		public InputModelFormatter(ITypeMetadata metadata)
		{
			var model = (IInputModel)Activator.CreateInstance(metadata.Type);

			if (model == null)
			{
				throw new InvalidTypeSettingException(metadata.Name, typeof(IInputModel), metadata.Type);
			}

			if (model.CommandType == null || string.IsNullOrEmpty(model.CommandType.Name))
			{
				throw new CommandTypeNotSpecifiedException(string.Format(
					"The input model {0} has not set it's CommandType property", metadata.Name));
			}

			_commandName = model.CommandType.Name;
			_modelName = metadata.Type.Name;
			_properties = metadata.Properties.Select(pi => new Property
			                                               	{
			                                               		Name = pi.Name,
			                                               		Type = pi.PropertyType.Name,
																Value = pi.PropertyType.GetDefaultValue(),
																Choices = pi.PropertyType.IsEnum ? Enum.GetNames(pi.PropertyType) : null,
																MultiChoice = pi.PropertyType.GetCustomAttributes(typeof(FlagsAttribute), false).Length > 0
			                                               	}).ToList();
		}
Exemple #10
0
        public void DerivedClassTest()
        {
            ITypeMetadata derivedClass = _sut.AssemblyModel.Namespaces
                                         .Single(x => x.Name == "TPA.ApplicationArchitecture.Data")
                                         .Types.Single(x => x.Name == "DerivedClass");

            Assert.IsNotNull(derivedClass.BaseType);
        }
Exemple #11
0
        public void ClassWithAttributesTest()
        {
            ITypeMetadata attributeClass = _sut.AssemblyModel.Namespaces
                                           .Single(x => x.Name == "TPA.ApplicationArchitecture.Data")
                                           .Types.Single(x => x.Name == "ClassWithAttribute");

            Assert.AreEqual(1, attributeClass.Attributes.Count());
        }
Exemple #12
0
        public void StructureTest()
        {
            ITypeMetadata structure = _sut.AssemblyModel.Namespaces
                                      .Single(x => x.Name == "TPA.ApplicationArchitecture.Data")
                                      .Types.Single(x => x.Name == "Structure");

            Assert.AreEqual(TypeKindEnum.StructType, structure.TypeKind);
        }
Exemple #13
0
        public void StaticClassTest()
        {
            ITypeMetadata staticClass = _sut.AssemblyModel.Namespaces
                                        .Single(x => x.Name == "TPA.ApplicationArchitecture.Data").
                                        Types.Single(x => x.Name == "StaticClass");

            Assert.AreEqual(StaticEnum.Static,
                            staticClass.Methods.Single(x => x.Name == "StaticMethod1").Modifiers.Item3);
        }
Exemple #14
0
        public static string GetOriginalName(ITypeMetadata metadata)
        {
            var name = metadata.Name;
            var fullName = metadata.IsNullable ? metadata.FullName.TrimEnd('?') : metadata.FullName;

            if (primitiveTypes.ContainsKey(fullName))
                name = primitiveTypes[fullName] + (metadata.IsNullable ? "?" : string.Empty);

            return name;
        }
Exemple #15
0
        public void AbstractClassTest()
        {
            ITypeMetadata abstractClass = _sut.AssemblyModel.Namespaces
                                          .Single(x => x.Name == "TPA.ApplicationArchitecture.Data")
                                          .Types.Single(x => x.Name == "AbstractClass");

            Assert.AreEqual(AbstractEnum.Abstract, abstractClass.Modifiers.Item3);
            Assert.AreEqual(AbstractEnum.Abstract,
                            abstractClass.Methods.Single(x => x.Name == "AbstractMethod").Modifiers.Item2);
        }
Exemple #16
0
        public static string GetTypeScriptName(ITypeMetadata metadata)
        {
            if (metadata == null)
            {
                return("any");
            }

            if (metadata.IsEnumerable)
            {
                var typeArguments = metadata.TypeArguments.ToList();

                if (typeArguments.Count == 0)
                {
                    if (metadata.BaseClass != null && metadata.BaseClass.IsGeneric)
                    {
                        typeArguments = metadata.BaseClass.TypeArguments.ToList();
                    }
                    else
                    {
                        var genericInterface = metadata.Interfaces.FirstOrDefault(i => i.IsGeneric);
                        if (genericInterface != null)
                        {
                            typeArguments = genericInterface.TypeArguments.ToList();
                        }
                    }

                    if (typeArguments.Any(t => t.FullName == metadata.FullName))
                    {
                        return("any[]");
                    }
                }

                if (typeArguments.Count == 1)
                {
                    return(GetTypeScriptName(typeArguments.FirstOrDefault()) + "[]");
                }

                if (typeArguments.Count == 2)
                {
                    var key   = GetTypeScriptName(typeArguments[0]);
                    var value = GetTypeScriptName(typeArguments[1]);

                    return(string.Concat("{ [key: ", key, "]: ", value, "; }"));
                }

                return("any[]");
            }

            if (metadata.IsGeneric)
            {
                return(metadata.Name + string.Concat("<", string.Join(", ", metadata.TypeArguments.Select(GetTypeScriptName)), ">"));
            }

            return(ExtractTypeScriptName(metadata));
        }
Exemple #17
0
        public void InterfaceTest()
        {
            ITypeMetadata interfaceClass = _sut.AssemblyModel.Namespaces
                                           .Single(x => x.Name == "TPA.ApplicationArchitecture.Data")
                                           .Types.Single(x => x.Name == "IExample");

            Assert.AreEqual(TypeKindEnum.InterfaceType, interfaceClass.TypeKind);
            Assert.AreEqual(AbstractEnum.Abstract, interfaceClass.Modifiers.Item3);
            Assert.AreEqual(AbstractEnum.Abstract,
                            interfaceClass.Methods.Single(x => x.Name == "MethodA").Modifiers.Item2);
        }
Exemple #18
0
        public static string GetOriginalName(ITypeMetadata metadata)
        {
            var name     = metadata.Name;
            var fullName = metadata.IsNullable ? metadata.FullName.TrimEnd('?') : metadata.FullName;

            if (primitiveTypes.ContainsKey(fullName))
            {
                name = primitiveTypes[fullName] + (metadata.IsNullable ? "?" : string.Empty);
            }

            return(name);
        }
Exemple #19
0
        /// <summary>
        /// Recupera os metadados do tipo.
        /// </summary>
        /// <param name="result"></param>
        /// <returns></returns>
        private ITypeMetadata GetTypeMetadata(ITypeMetadata result)
        {
            var typeMetadata = result as Local.TypeMetadata;

            if (typeMetadata != null && typeMetadata.BaseTypes.Any())
            {
                result = new AggregateTypeMetadata(new[] {
                    result
                }.Concat(typeMetadata.BaseTypes.Select(f => _schemas.Select(x => x.GetTypeMetadata(f.FullName)).FirstOrDefault(x => x != null)).Where(f => f != null)));
            }
            return(result);
        }
Exemple #20
0
		public ActionResult ViewPart(ITypeMetadata typeMetadata, IPartCollection containingCollection, string format)
		{
			ViewBag.Title = typeMetadata.Name;

            return View(new PartModel
			            	{
			            		TypeMetadata = typeMetadata,
			            		NextActionName = (containingCollection.DescriptiveName == "Commands") ? "ViewCommand" : "ViewPart",
                                AgentSytemName = containingCollection.AgentSystemName,
                                PartDescriptiveName = containingCollection.DescriptiveName,
                                PartType = typeMetadata.Type.Name
			            	});
		}
        public void TestImplyIndicies()
        {
            TypeMetadataBuilder <PoffedImpliedIndicies>             builder = new TypeMetadataBuilder <PoffedImpliedIndicies>();
            IVisitor <TypeMetadataBuilder <PoffedImpliedIndicies> > visitor = new AnnotationVisitor <TypeMetadataBuilder <PoffedImpliedIndicies>, PoffedImpliedIndicies>(true);

            builder.SetTypeId(1002);
            builder.Accept(visitor, typeof(PoffedImpliedIndicies));

            ITypeMetadata <PoffedImpliedIndicies> tmd = builder.Build();

            Assert.AreEqual(1002, tmd.Key.TypeId);
            Assert.AreEqual(2, tmd.GetAttribute("lastName").Index);
            Assert.AreEqual(1, tmd.GetAttribute("firstName").Index);
            Assert.AreEqual(0, tmd.GetAttribute("age").Index);
        }
Exemple #22
0
        public static bool TryAddEnumItem(
            this List <SearcherItem> items,
            SearcherItem itemToAdd,
            ITypeMetadata meta,
            string parentName = ""
            )
        {
            if (meta.IsEnum)
            {
                items.AddAtPath(itemToAdd, parentName + "/" + k_Enums);
                return(true);
            }

            return(false);
        }
Exemple #23
0
        public static IEnumerable <MemberInfoValue> GetMembers(this ITypeMetadata metadata, BindingFlags flags)
        {
            var privateAndPublicFlags = BindingFlags.Public | BindingFlags.NonPublic;

            if ((flags & privateAndPublicFlags) == privateAndPublicFlags)
            {
                return(metadata.PublicMembers.Concat(metadata.NonPublicMembers));
            }
            if ((flags & BindingFlags.NonPublic) != 0)
            {
                return(metadata.NonPublicMembers);
            }
            //if ((flags & BindingFlags.Public) != 0)
            return(metadata.PublicMembers);
        }
Exemple #24
0
        public void ImplementedInterfaceTest()
        {
            ITypeMetadata interfaceClass = _sut.AssemblyModel.Namespaces
                                           .Single(x => x.Name == "TPA.ApplicationArchitecture.Data")
                                           .Types.Single(x => x.Name == "IExample");
            ITypeMetadata implementedInterfaceClass = _sut.AssemblyModel.Namespaces
                                                      .Single(x => x.Name == "TPA.ApplicationArchitecture.Data")
                                                      .Types.Single(x => x.Name == "ImplementationOfIExample");

            Assert.AreEqual("IExample", implementedInterfaceClass.ImplementedInterfaces.Single().Name);
            foreach (IMethodMetadata method in interfaceClass.Methods)
            {
                Assert.IsNotNull(implementedInterfaceClass.Methods.SingleOrDefault(x => x.Name == method.Name));
            }
        }
        List <SearcherItem> SearcherItemsForType(int recursiveDepth, ITypeMetadata currentType, string currentPath,
                                                 int parentsHashCode, BindingFlags flags)
        {
            List <SearcherItem> searcherItems = null;

            foreach (var member in currentType.GetMembers(flags))
            {
                var childItem = SearcherItemForType(recursiveDepth, currentPath, parentsHashCode, member);

                searcherItems = searcherItems ?? new List <SearcherItem>();
                searcherItems.Add(childItem);
            }

            return(searcherItems);
        }
        public void TestVisit()
        {
            TypeMetadataBuilder <Poffed>             builder = new TypeMetadataBuilder <Poffed>();
            IVisitor <TypeMetadataBuilder <Poffed> > visitor = new AnnotationVisitor <TypeMetadataBuilder <Poffed>, Poffed>();

            builder.SetTypeId(1001);
            builder.Accept(visitor, typeof(Poffed));

            ITypeMetadata <Poffed> tmd = builder.Build();

            Assert.AreEqual(1001, tmd.Key.TypeId);
            Assert.AreEqual(0, tmd.GetAttribute("lastName").Index);
            Assert.AreEqual(1, tmd.GetAttribute("age").Index);
            Assert.AreEqual(2, tmd.GetAttribute("firstName").Index);
        }
        public void TestAccessorAnnotations()
        {
            TypeMetadataBuilder <PoffedMethodInspection>             builder = new TypeMetadataBuilder <PoffedMethodInspection>();
            IVisitor <TypeMetadataBuilder <PoffedMethodInspection> > visitor = new AnnotationVisitor <TypeMetadataBuilder <PoffedMethodInspection>, PoffedMethodInspection>(true);

            builder.SetTypeId(1005);
            builder.Accept(visitor, typeof(PoffedMethodInspection));

            ITypeMetadata <PoffedMethodInspection> tmd = builder.Build();

            Assert.AreEqual(1005, tmd.Key.TypeId);
            Assert.AreEqual(0, tmd.GetAttribute("adult").Index);
            Assert.AreEqual(1, tmd.GetAttribute("age").Index);
            Assert.AreEqual(2, tmd.GetAttribute("firstName").Index);
            Assert.AreEqual(3, tmd.GetAttribute("lastName").Index);
        }
        internal static bool TryAddClassItem(
            this List <SearcherItem> items,
            SearcherItem itemToAdd,
            ITypeMetadata meta,
            string parentName = ""
            )
        {
            if ((meta.IsClass || meta.IsValueType) && !meta.IsEnum)
            {
                var path = BuildPath(parentName + "/" + k_Class, meta);
                items.AddAtPath(itemToAdd, path);
                return(true);
            }

            return(false);
        }
        PropertySearcherItem SearcherItemForType(int depth, string path, int parentHash, MemberInfoValue member)
        {
            TypeHandle    memberType = member.UnderlyingType;
            ITypeMetadata memberTypeMetadataCSharp = m_Resolver.Resolve(memberType);
            string        memberName = member.Name;
            int           hashCode   = GenerateSearcherItemHashCode(parentHash, memberName);

            List <SearcherItem> childItems = null;

            if (depth > 0)
            {
                childItems = SearcherItemsForType(depth - 1, memberTypeMetadataCSharp, path + " " + memberName, hashCode, m_RecursiveFlags);
            }

            return(CreateSearcherItem(path, member, hashCode, childItems));
        }
        public static bool TryAddGraphItem(
            this List <SearcherItem> items,
            SearcherItem itemToAdd,
            ITypeMetadata meta,
            string parentName = ""
            )
        {
            if (meta is GraphBasedMetadata)
            {
                var path = BuildPath(parentName + "/" + k_Graphs, meta);
                items.AddAtPath(itemToAdd, path);
                return(true);
            }

            return(false);
        }
Exemple #31
0
        public void GenericClassTest()
        {
            ITypeMetadata genericClass = _sut.AssemblyModel.Namespaces
                                         .Single(x => x.Name == "TPA.ApplicationArchitecture.Data")
                                         .Types.Single(x => x.Name.Contains("GenericClass"));

            Assert.AreEqual(1, genericClass.GenericArguments.Count());
            Assert.AreEqual("T", genericClass.GenericArguments.Single().Name);
            Assert.AreEqual("T", genericClass.Properties.Single(x => x.Name == "GenericProperty")
                            .MyType.Name);
            Assert.AreEqual(1, genericClass.Methods.Single(x => x.Name == "GenericMethod").Parameters.Count());
            Assert.AreEqual("T", genericClass.Methods.Single(x => x.Name == "GenericMethod")
                            .Parameters.Single().MyType.Name);
            Assert.AreEqual("T",
                            genericClass.Methods.Single(x => x.Name == "GenericMethod").ReturnType.Name);
            //TypeMetaData lacks Fields info
        }
Exemple #32
0
        /// <summary>
        /// Recupera os metadados do tipo com o nome informado.
        /// </summary>
        /// <param name="fullName">Nome completo do tipo.</param>
        /// <returns>Instancia dos metadados do tipo.</returns>
        public ITypeMetadata GetTypeMetadata(string fullName)
        {
            ITypeMetadata result = null;

            lock (_objLock)
            {
                if (!_typeMetadatasFromFullName.TryGetValue(fullName, out result) && _typeMetadataLoaderFromFullName != null)
                {
                    result = _typeMetadataLoaderFromFullName(fullName);
                    if (result != null)
                    {
                        InternalAddTypeMetadata(result);
                    }
                }
            }
            return(result);
        }
Exemple #33
0
        /// <summary>
        /// Recupera os metadados do tipo com base no código informado.
        /// </summary>
        /// <param name="typeCode">Código do tipo.</param>
        /// <returns></returns>
        public ITypeMetadata GetTypeMetadata(int typeCode)
        {
            ITypeMetadata result = null;

            lock (_objLock)
            {
                if (!_typeMetadatasFromTypeCode.TryGetValue(typeCode, out result) && _typeMetadataLoaderFromTypeCode != null)
                {
                    result = _typeMetadataLoaderFromTypeCode(typeCode);
                    if (result != null)
                    {
                        InternalAddTypeMetadata(result);
                    }
                }
            }
            return(result);
        }
        public void TestCustomCodec()
        {
            TypeMetadataBuilder <PoffedCustomCodec>             builder = new TypeMetadataBuilder <PoffedCustomCodec>();
            IVisitor <TypeMetadataBuilder <PoffedCustomCodec> > visitor = new AnnotationVisitor <TypeMetadataBuilder <PoffedCustomCodec>, PoffedCustomCodec>(true);

            builder.SetTypeId(1004);
            builder.Accept(visitor, typeof(PoffedCustomCodec));

            ITypeMetadata <PoffedCustomCodec> tmd = builder.Build();

            Assert.AreEqual(1004, tmd.Key.TypeId);
            Assert.AreEqual(0, tmd.GetAttribute("age").Index);
            Assert.AreEqual(1, tmd.GetAttribute("aliases").Index);
            Assert.AreEqual(2, tmd.GetAttribute("firstName").Index);
            Assert.AreEqual(3, tmd.GetAttribute("lastName").Index);
            Assert.IsInstanceOf(typeof(LinkedListCodec <string>), tmd.GetAttribute("aliases").Codec);
        }
Exemple #35
0
        public void TestClassMetadata()
        {
            MethodInfo method = typeof(ClassMetadataDescribable).GetMethod("GetName");

            var builder = new ClassMetadataBuilder <ClassMetadataDescribable>();
            ITypeMetadata <ClassMetadataDescribable> tmd = builder.SetClass(typeof(ClassMetadataDescribable))
                                                           .SetHash("TestDomain".GetHashCode())
                                                           .SetTypeId(1234)
                                                           .AddAttribute(builder.NewAttribute()
                                                                         .SetIndex(0)
                                                                         .SetName("name")
                                                                         .SetCodec(Codecs.DEFAULT_CODEC)
                                                                         .SetInvocationStrategy(new InvocationStrategies.MethodInvcationStrategy <ClassMetadataDescribable>(method))
                                                                         .SetVersion(0).Build()).Build();

            ITypeMetadata <ClassMetadataDescribable> tmd2 = builder.SetClass(typeof(ClassMetadataDescribable))
                                                            .SetHash("TestDomain".GetHashCode())
                                                            .SetTypeId(1234)
                                                            .AddAttribute(builder.NewAttribute()
                                                                          .SetIndex(0)
                                                                          .SetName("name")
                                                                          .SetCodec(Codecs.DEFAULT_CODEC)
                                                                          .SetInvocationStrategy(new InvocationStrategies.MethodInvcationStrategy <ClassMetadataDescribable>(method))
                                                                          .SetVersion(0).Build()).Build();

            Assert.AreEqual(1234, tmd.GetKey().GetTypeId());
            Assert.IsTrue(tmd.GetKey().GetHash() != 0);
            Assert.IsNotNull(tmd.GetAttribute("name"));
            Assert.AreEqual("name", tmd.GetAttribute("name").GetName());
            Assert.AreEqual(0, tmd.GetAttribute("name").GetIndex());
            Assert.AreEqual(0, tmd.GetAttribute("name").GetVersion());
            Assert.AreEqual(tmd, tmd2);
            Assert.AreEqual(tmd.GetHashCode(), tmd2.GetHashCode());

            ClassMetadataDescribable cmdd = new ClassMetadataDescribable("augusta");

            Assert.AreEqual("augusta", tmd.GetAttribute("name").Get(cmdd));
            tmd.GetAttribute("name").Set(cmdd, "ada");
            Assert.AreEqual("ada", tmd.GetAttribute("name").Get(cmdd));
            Assert.IsInstanceOf(typeof(Codecs.DefaultCodec), tmd.GetAttribute("name").GetCodec());
            Assert.IsTrue(tmd.GetAttributes().MoveNext());
            Assert.IsInstanceOf(typeof(ClassMetadataDescribable), tmd.NewInstance());

            object a = (object)"dasd";
        }
        /// <summary>
        /// Recupera o nome o tipo de uma metadado de um tipo.
        /// </summary>
        /// <param name="typeMetadata"></param>
        /// <returns></returns>
        public static Colosoft.Reflection.TypeName GetTypeName(this ITypeMetadata typeMetadata)
        {
            if (typeMetadata == null)
            {
                return(null);
            }
            string fullName = null;

            if (!string.IsNullOrEmpty(typeMetadata.Assembly))
            {
                fullName = string.Format("{0}.{1}, {2}", typeMetadata.Namespace, typeMetadata.Name, typeMetadata.Assembly);
            }
            else
            {
                fullName = string.Format("{0}.{1}", typeMetadata.Namespace, typeMetadata.Name);
            }
            return(new Reflection.TypeName(fullName));
        }
		public static IMetadataFormatter GetFormatter(ITypeMetadata metadata)
		{
			if (typeof(ICommand).IsAssignableFrom(metadata.Type))
			{
				return new CommandMetadataFormatter(metadata);
			}
			else if (typeof(IReadModel).IsAssignableFrom(metadata.Type))
			{
				return new ReadModelFormatter(metadata);
			}
			else if (typeof(IQuery).IsAssignableFrom(metadata.Type))
			{
				return new QueryFormatter(metadata);
			}
			else if (typeof(IInputModel).IsAssignableFrom(metadata.Type))
			{
				return new InputModelFormatter(metadata);
			}

			return new DefaultFormatter(metadata);
		}
Exemple #38
0
		public QueryFormatter(ITypeMetadata partMetadata)
		{
			_partMetadata = partMetadata;
			_agentMetadata = partMetadata.Type.Assembly.GetAgentMetadata();
		}
Exemple #39
0
 public static Type FromMetadata(ITypeMetadata metadata, Item parent)
 {
     return metadata == null ? null : new TypeImpl(metadata, parent);
 }
Exemple #40
0
		public ReadModelFormatter(ITypeMetadata partMetadata)
		{
			_partMetadata = partMetadata;
		}
 void IRelationalMappingConvention.ApplyToType(ITypeMetadata type)
 {
     ApplyToType((TypeMetadataBuilder)type);
 }
Exemple #42
0
        public ActionResult ViewCommand(IInputModel inputModel, ITypeMetadata typeMetadata, string format)
        {
            var partCollection = typeMetadata.GetContainingPartCollection();

            ViewBag.Title = typeMetadata.Type.Name;

            ViewBag.Navigation = new FooterLinkModel
                                     {
                                         AgentSytemName = partCollection.AgentSystemName,
                                         PartDescriptiveName = partCollection.DescriptiveName,
                                         PartType = typeMetadata.Type.Name
                                     };

            ActionResult result = View("ViewCommand", inputModel);

            return result;
        }
Exemple #43
0
		public DefaultFormatter(ITypeMetadata metadata)
		{
			_metadata = metadata;
		}
 //-----------------------------------------------------------------------------------------------------------------------------------------------------
 public EfEntityConfigurationWriter(ITypeMetadata metadata, MethodWriterBase method, Operand<DbModelBuilder> model)
 {
     _model = model;
     _method = method;
     _metadata = metadata;
 }
Exemple #45
0
        public static bool IsPrimitive(ITypeMetadata metadata)
        {
            var fullName = metadata.FullName;

            if (metadata.IsNullable)
            {
                fullName = fullName.TrimEnd('?');
            }
            else if (metadata.IsEnumerable)
            {
                var innerType = metadata.TypeArguments.FirstOrDefault();
                if (innerType != null)
                {
                    fullName = innerType.IsNullable ? innerType.FullName.TrimEnd('?') : innerType.FullName;
                }
                else
                {
                    return false;
                }
            }

            return metadata.IsEnum || primitiveTypes.ContainsKey(fullName);
        }
 //-----------------------------------------------------------------------------------------------------------------------------------------------------
 public void EnsureRelationalMapping(ITypeMetadata type)
 {
     var metadata = (TypeMetadataBuilder)type;
     metadata.EnsureRelationalMapping(_relationalMappingConvention);
 }
		public CommandMetadataFormatter(ITypeMetadata typeMetadata)
		{
			_typeMetadata = typeMetadata;
		}