public Metadata Apply(JObject input) { var metadata = input["metadata"].ToObject <JObject>(); var metadataType = MetadataTypeExtension.GetRawValue(metadata["metadataType"].ToObject <int>()); var fields = metadata["fields"].ToObject <List <FieldDTO> >(); var fieldList = fields.Select(f => new Field(f.Key, f.Value)).ToList(); Metadata metadataInfo = null; switch (metadataType) { case MetadataType.ACCOUNT: var address = Address.CreateFromHex(metadata["metadataId"].ToObject <string>()); metadataInfo = new AddressMetadata(fieldList, address); break; case MetadataType.NAMESPACE: var namespaceId = new NamespaceId(metadata["metadataId"].ToObject <UInt64DTO>().ToUInt64()); metadataInfo = new NamespaceMetadata(fieldList, namespaceId); break; case MetadataType.MOSAIC: var mosaicId = new MosaicId(metadata["metadataId"].ToObject <UInt64DTO>().ToUInt64()); metadataInfo = new MosaicMetadata(fieldList, mosaicId); break; case MetadataType.NONE: break; default: throw new ArgumentOutOfRangeException(); } return(metadataInfo); }
private IEnumerable <OneWayRelation> GetRelations(NamespaceMetadata value) { foreach (var item in value.Types) { yield return(new OneWayRelation($"Namespace: {value.Id}", item.Id)); } }
private static NamespaceBase ToBase(NamespaceMetadata metadata) { return(new NamespaceBase() { name = metadata.m_NamespaceName, types = metadata.m_Types?.Select(ToBase) }); }
public void TypesNamesTest() { NamespaceMetadata namespace1 = refl.AssemblyModel.Namespaces.ToList().ElementAt(0); NamespaceMetadata namespace2 = refl.AssemblyModel.Namespaces.ToList().ElementAt(1); Assert.AreEqual("Model", namespace1.Types.ToList().ElementAt(0).Name); Assert.AreEqual("ClassWithAttribute", namespace2.Types.ToList().ElementAt(1).Name); }
public VMNamespaceMetadata(NamespaceMetadata namespaceMetadata) { this.namespaceMetadata = namespaceMetadata; if (CanLoadChildren()) { Children.Add(null); } }
private static NamespaceDTG NamespaceDtg(NamespaceMetadata namespaceModel) { return(new NamespaceDTG() { Name = namespaceModel.Name, MetadataName = namespaceModel.MetadataName, Types = namespaceModel.Types?.Select(LoadType).ToList() }); }
public NamespaceViewModel(NamespaceMetadata namespaceMetadata, [Import(typeof(Logger))] Logger logger) { this.logger = logger; this.namespaceMetadata = namespaceMetadata; if (CanLoadChildren()) { Children.Add(null); } }
public void NamespaceTest() { Reflector reflector = new Reflector(); reflector.Reflect(path); NamespaceMetadata _namespace = reflector.AssemblyModel.m_Namespaces.ToList()[0]; Assert.AreEqual(_namespace.m_Types.Count(), 5); }
public void CopyCtorTest() { AssemblyMetadata tmpass = new AssemblyMetadata(Assembly.GetExecutingAssembly()); INamespaceMetadata tmp = tmpass.Namespaces.First(); NamespaceMetadata sut = new NamespaceMetadata(tmp); Assert.IsTrue(tmp.Name.Equals(sut.Name)); Assert.AreEqual(tmp.SavedHash, sut.SavedHash); Assert.AreEqual(tmp.Types.Count(), sut.Types.Count()); }
public void AmountOfPropertiesInTypesInNamespacesTest() { NamespaceMetadata namespaceMetadata2 = refl.AssemblyModel.Namespaces.ToList().ElementAt(1); TypeMetadata typeMetadata1 = namespaceMetadata2.Types.ToList().ElementAt(3); TypeMetadata typeMetadata2 = namespaceMetadata2.Types.ToList().ElementAt(1); Assert.AreEqual(4, typeMetadata2.Methods.ToList().Count); Assert.AreEqual(29, typeMetadata1.Methods.ToList().Count); }
public NamespaceMetadataBase MapToSerialize(NamespaceMetadata metadata, Type namespaceMetadataType) { object namespaceMetadata = Activator.CreateInstance(namespaceMetadataType); PropertyInfo nameProperty = namespaceMetadataType.GetProperty("NamespaceName"); PropertyInfo namespaceMetadatasProperty = namespaceMetadataType.GetProperty("Types", BindingFlags.Instance | BindingFlags.Public | BindingFlags.DeclaredOnly); nameProperty?.SetValue(namespaceMetadata, metadata.NamespaceName); namespaceMetadatasProperty?.SetValue(namespaceMetadata, ConvertionUtilities.ConvertList(namespaceMetadatasProperty.PropertyType.GetGenericArguments()[0], metadata.Types.Select(t => new TypeMetadataMapper().MapToSerialize(t, namespaceMetadatasProperty.PropertyType.GetGenericArguments()[0])).ToList())); return((NamespaceMetadataBase)namespaceMetadata); }
public void CountMethodTest() { NamespaceMetadata n1 = refl.AssemblyModel.Namespaces.ToList().ElementAt(0); NamespaceMetadata n2 = refl.AssemblyModel.Namespaces.ToList().ElementAt(1); TypeMetadata typeMetadata1 = n1.Types.ToList().ElementAt(0); TypeMetadata typeMetadata2 = n2.Types.ToList().ElementAt(1); Assert.AreEqual(6, typeMetadata1.Methods.ToList().Count); Assert.AreEqual(4, typeMetadata2.Methods.ToList().Count); }
public void NameMethodTest() { NamespaceMetadata n1 = refl.AssemblyModel.Namespaces.ToList().ElementAt(0); NamespaceMetadata n2 = refl.AssemblyModel.Namespaces.ToList().ElementAt(1); TypeMetadata typeMetadata1 = n1.Types.ToList().ElementAt(0); TypeMetadata typeMetadata2 = n2.Types.ToList().ElementAt(1); Assert.AreEqual("get_Linq2SQL", typeMetadata1.Methods.ToList().ElementAt(0).Name); Assert.AreEqual("Equals", typeMetadata2.Methods.ToList().ElementAt(1).Name); }
public void NumberofParameterOfMethodTest() { NamespaceMetadata n1 = refl.AssemblyModel.Namespaces.ToList().ElementAt(0); NamespaceMetadata n2 = refl.AssemblyModel.Namespaces.ToList().ElementAt(1); TypeMetadata typeMetadata1 = n1.Types.ToList().ElementAt(0); TypeMetadata typeMetadata2 = n2.Types.ToList().ElementAt(1); Assert.AreEqual(1, typeMetadata1.Methods.ToList().ElementAt(3).Parameters.Count()); Assert.AreEqual(1, typeMetadata2.Methods.ToList().ElementAt(1).Parameters.Count()); }
public static NamespaceBaseDTO ToBaseDTO(this NamespaceMetadata metadata) { if (metadata == null) { return(null); } return(new NamespaceBaseDTO { NamespaceName = metadata.NamespaceName, Types = CollectionToBaseDTO(metadata.Types, i => i.ToBaseDTO()) }); }
public BaseNamespace MapDown(NamespaceMetadata model, Type namespaceModelType) { object namespaceModel = Activator.CreateInstance(namespaceModelType); PropertyInfo nameProperty = namespaceModelType.GetProperty("Name"); PropertyInfo namespaceModelsProperty = namespaceModelType.GetProperty("Types", BindingFlags.Instance | BindingFlags.Public | BindingFlags.DeclaredOnly); nameProperty?.SetValue(namespaceModel, model.Name); namespaceModelsProperty?.SetValue(namespaceModel, Converter.ConvertList(namespaceModelsProperty.PropertyType.GetGenericArguments()[0], model.Types.Select(t => new MapperType().MapDown(t, namespaceModelsProperty.PropertyType.GetGenericArguments()[0])).ToList())); return((BaseNamespace)namespaceModel); }
public void CorrectTypesInNamespaceMetadata() { AssemblyMetadata assemblyMetadata = new AssemblyMetadata(testAssembly); NamespaceMetadata namespaceMetadata = assemblyMetadata.m_Namespaces.ToList <NamespaceMetadata>()[1]; List <string> typeNames = new List <string>(from _type in namespaceMetadata.m_Types select _type.m_typeName); Assert.IsTrue(typeNames.Contains("AbstractEnum")); Assert.IsTrue(typeNames.Contains("AccessLevelEnum")); Assert.IsTrue(typeNames.Contains("SealedEnum")); Assert.IsTrue(typeNames.Contains("StaticEnum")); Assert.IsTrue(typeNames.Contains("VirtualEnum")); }
public NamespaceModel MapDown(NamespaceMetadata model, Type NamespaceMetadataType) { object NamespaceMetadata = Activator.CreateInstance(NamespaceMetadataType); PropertyInfo nameProperty = NamespaceMetadataType.GetProperty("Name"); PropertyInfo NamespaceMetadatasProperty = NamespaceMetadataType.GetProperty("Types", BindingFlags.Instance | BindingFlags.Public | BindingFlags.DeclaredOnly); nameProperty?.SetValue(NamespaceMetadata, model.Name); NamespaceMetadatasProperty?.SetValue(NamespaceMetadata, HelperClass.ConvertList(NamespaceMetadatasProperty.PropertyType.GetGenericArguments()[0], model.Types.Select(t => new TypeModelMapper().MapDown(t, NamespaceMetadatasProperty.PropertyType.GetGenericArguments()[0])).ToList())); return((NamespaceModel)NamespaceMetadata); }
public NamespaceMetadata MapUp(BaseNamespace model) { NamespaceMetadata namespaceModel = new NamespaceMetadata(); namespaceModel.Name = model.Name; Type type = model.GetType(); PropertyInfo typesProperty = type.GetProperty("Types", BindingFlags.Instance | BindingFlags.Public | BindingFlags.DeclaredOnly); List <BaseType> types = (List <BaseType>)Helper.ConvertList(typeof(BaseType), (IList)typesProperty?.GetValue(model)); if (types != null) { namespaceModel.Types = types.Select(n => TypeMapper.EmitType(n)).ToList(); } return(namespaceModel); }
public NamespaceMetadata MapUp(NamespaceModel model) { NamespaceMetadata NamespaceMetadata = new NamespaceMetadata(); NamespaceMetadata.Name = model.Name; Type type = model.GetType(); PropertyInfo typesProperty = type.GetProperty("Types", BindingFlags.Instance | BindingFlags.Public | BindingFlags.DeclaredOnly); List <TypeModel> types = (List <TypeModel>)HelperClass.ConvertList(typeof(TypeModel), (IList)typesProperty?.GetValue(model)); if (types != null) { NamespaceMetadata.Types = types.Select(n => TypeModelMapper.EmitType(n)).ToList(); } return(NamespaceMetadata); }
public NamespaceMetadata MapToDeserialize(NamespaceMetadataBase metadata) { NamespaceMetadata namespaceMetadata = new NamespaceMetadata { NamespaceName = metadata.NamespaceName }; Type type = metadata.GetType(); PropertyInfo typesProperty = type.GetProperty("Types", BindingFlags.Instance | BindingFlags.Public | BindingFlags.DeclaredOnly); List <TypeMetadataBase> types = (List <TypeMetadataBase>)ConvertionUtilities.ConvertList(typeof(TypeMetadataBase), (IList)typesProperty?.GetValue(metadata)); if (types != null) { namespaceMetadata.Types = types.Select(n => TypeMetadataMapper.EmitTypeForDeserialization(n)).ToList(); } return(namespaceMetadata); }
public void TypesInMetadata() { AssemblyMetadata assemblyMeta = new AssemblyMetadata(assembly); List <NamespaceMetadata> namespaceMetadata = assemblyMeta.Namespaces.ToList <NamespaceMetadata>(); NamespaceMetadata name = namespaceMetadata[0]; List <string> list = new List <string>(from Type in name.Types select Type.Name); Assert.IsTrue(list.Contains("Model")); Assert.IsTrue(list.Contains("ServiceA")); Assert.IsTrue(list.Contains("ServiceB")); Assert.IsTrue(list.Contains("ServiceC")); Assert.IsTrue(list.Contains("ViewModel")); }
public static DTGNamespaceMetadata MapToDTGModel(NamespaceMetadata namespaceMetadata) { var m_NamespaceName = namespaceMetadata.NamespaceName; //May be even more beneficial to create all types from all namespaces beforehand foreach (var type in namespaceMetadata.Types) { HelperDictonaries.TypeDictonaryForDTG[type] = TypeMapper.MapToDTGModel(type); } var m_Types = from type in namespaceMetadata.Types orderby type.TypeName select TypeMapper.FillTypeDTG(HelperDictonaries.TypeDictonaryForDTG[type], type); DTGNamespaceMetadata namespaceModel = new DTGNamespaceMetadata { NamespaceName = m_NamespaceName, Types = m_Types }; return(namespaceModel); }
internal NamespaceMetadata LoadNamespaceMetadata(string name, IEnumerable <Type> types, AssemblyMetadataStore metaStore) { if (string.IsNullOrWhiteSpace(name)) { throw new ArgumentException($"{nameof(name)} is null/empty/whitespace"); } NamespaceMetadata namespaceMetadata = new NamespaceMetadata() { Id = name, Name = name }; _logger.Trace("Adding Namespace to dictionary: " + namespaceMetadata.Name); metaStore.NamespacesDictionary.Add(namespaceMetadata.Name, namespaceMetadata); namespaceMetadata.Types = (from type in types orderby type.Name select LoadTypeMetadataDto(type, metaStore)).ToList(); return(namespaceMetadata); }
public NamesapceTreeViewItem(NamespaceMetadata namespaceMetadata) { _namespaceMetadata = namespaceMetadata; Name = "Namesapce " + _namespaceMetadata.NamespaceName; }
private TreeItem MapItem(NamespaceMetadata value) { return(new TreeItem($"Namespace: {value.Id}", value.Types.Any())); }
public NamespaceMetadataView(ILogger log, NamespaceMetadata namespaceMetadata) : base(log) { _namespaceMetadata = namespaceMetadata; }
public NamespaceTreeViewItem(NamespaceMetadata namespaceMetadata) { this.namespaceMetadata = namespaceMetadata; Name = namespaceMetadata.NamespaceName; }
internal ReflectorTestClass() : base(TestAssemblyName) { Namespaces = this.m_AssemblyModel.m_Namespaces.ToDictionary <NamespaceMetadata, string>(x => x.m_NamespaceName); MyNamespace = Namespaces.ContainsKey(m_NamespaceName) ? Namespaces["TPA.ApplicationArchitecture.Data"] : null; }
public void TypesInNamespacesCountTest() { NamespaceMetadata namespace1 = refl.AssemblyModel.Namespaces.ToList().ElementAt(2); Assert.AreEqual(2, namespace1.Types.ToList().Count); }