/// <summary> /// Initalizes the manager with the specified namespaces in the specified assembly /// </summary> /// <param name="assembly">Assembly in which is searched</param> /// <param name="namespaces">Namespace to be registered in the manager</param> public void Initialize(Assembly assembly, params string[] namespaces) { if (Namespaces == null) { Namespaces = new List <string>(); } Namespaces.AddRange(namespaces); var commands = assembly.GetTypes().Where( t => t.GetCustomAttribute <CommandAttribute>() != null && Namespaces.Contains(t.Namespace)).ToList(); foreach (var command in commands) { command.GetMethod( "Register", BindingFlags.Static | BindingFlags.Public | BindingFlags.FlattenHierarchy) .Invoke(null, new[] { command }); commandHandler[(string)command.GetCustomAttribute <CommandAttribute>().Tag] += (e) => InitializeCommand(command, e); } InitializeOneTimeCommand(Namespaces.ToArray(), assembly.GetTypes()); IsInitialized = true; }
public void LoadFile(string filename) { XmlDocument document = new XmlDocument(); document.Load(filename); XmlNode compositeNode = document.SelectSingleNode(CompositeXPath); string rootNamespace = GetNodeValue(compositeNode, "@rootNamespace"); RootNamespace = rootNamespace; XmlNodeList types = document.SelectNodes(TypesXPath); foreach (XmlNode typeNode in types) { string typeName = GetNodeValue(typeNode, "@name"); string className = GetNodeValue(typeNode, "@className"); string theNamespace = GetNodeValue(typeNode, "@namespace"); if (!Namespaces.Contains(theNamespace)) { Namespaces.Add(theNamespace); } CompositeType compositeType = new CompositeType(typeName, className, theNamespace); Type foundType = FindType(className, theNamespace); foreach (PropertyInfo pi in foundType.GetProperties()) { if (pi.CanRead && pi.CanWrite) { CompositeProperty property = new CompositeProperty(typeName, pi.Name, pi.PropertyType); compositeType.Properties.Add(property); } } XmlNodeList hiddenNodes = typeNode.SelectNodes(PropertiesXPath); foreach (XmlNode propertyNode in hiddenNodes) { string propertyName = GetNodeValue(propertyNode, "@name"); string alias = GetNodeValue(propertyNode, "@alias"); bool isReadOnly = GetBooleanNodeValue(propertyNode, "@isReadOnly"); bool isHidden = GetBooleanNodeValue(propertyNode, "@isHidden"); CompositeProperty property = compositeType.Properties.FindCompositeProperty(typeName, propertyName); if (property != null) { if (!String.IsNullOrEmpty(alias)) { property.Alias = alias; } property.IsReadOnly = isReadOnly; property.IsHidden = isHidden; } } } }
/// <summary> /// Adds to top new namespace into Namespaces property. /// </summary> /// <param name="ns"></param> /// <returns>true if added.</returns> public bool AddTopNamespace(string ns) { if (!String.IsNullOrWhiteSpace(ns) && !Namespaces.Contains(ns)) { Namespaces.Insert(0, ns); return(true); } return(false); }
private void AddAdditionalNamespaces(Type inputType) { if (!Assemblies.Contains(inputType.Assembly)) { Assemblies.Add(inputType.Assembly); } if (!Namespaces.Contains(inputType.Namespace)) { Namespaces.Add(inputType.Namespace); } }
private void AddAssemblies(IEnumerable <Assembly> asseblies, IEnumerable <string> namespaces) { foreach (var additional in asseblies) { if (!Assemblies.Contains(additional)) { Assemblies.Add(additional); } } foreach (var namespaceAdditional in namespaces) { if (!Namespaces.Contains(namespaceAdditional)) { Namespaces.Add(namespaceAdditional); } } }
protected override void ProcessRecord() { ServiceCollection services = new ServiceCollection(); services.AddDefaultCodeGen(); HashSet <string> paths = new HashSet <string>(StringComparer.InvariantCultureIgnoreCase); paths.Add(Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location)); paths.AddRange(AssemblyFolders); var getAssemblyTypes = new GetAssemblyTypes(paths); Type converterType = getAssemblyTypes.LoadTypeByName(Converter); if (!services.TryAddConverter(converterType)) { throw new Exception($"codegen: Error loading converter type: ${converterType}"); } var provider = services.BuildServiceProvider(); Regex regex = null; IConvertObject <Type> converter = provider.GetRequiredService(converterType) as IConvertObject <Type>; if (!string.IsNullOrEmpty(Pattern)) { regex = new Regex(Pattern, RegexOptions.Compiled | RegexOptions.Singleline | RegexOptions.IgnoreCase | RegexOptions.IgnorePatternWhitespace); } getAssemblyTypes.LoadAssemblyTypes(TargetAssembly, type => { if (!type.IsAnonymousType() && !type.IsInterface && type.IsPublic) { bool match = (Namespaces?.Count() ?? 0) == 0 || Namespaces.Contains(type.Namespace, StringComparer.InvariantCultureIgnoreCase); if (match) { match = match && (regex == null || regex.IsMatch(type.FullName)); } if (match) { var data = converter.Convert(type); WriteObject(data); } } }); }
private string ReadName() { int pos1 = CurrentIndex; if (IsNameLeadChar) { ReadChar(); } else { return(""); } while (IsNameChar) { ReadChar(); } int pos2 = -1; while (_c == '.' || _c == '/') // It is observed that a slash is used as the most left hand separator of components { pos2 = CurrentIndex; ReadChar(); if (IsNameLeadChar) { ReadChar(); } else { throw new Exception("Name char is missing."); } while (IsNameChar) { ReadChar(); } } return(pos2 > 0 && Namespaces.Contains(Substring(pos1, pos2)) ? Substring(pos2 + 1) : Substring(pos1)); }
public ParserValue Get(ParserValue obj, string token) { if (!Enabled) { return(ParserValue.Empty); } if (obj.IsNull) { if (token == "#") { obj = new StaticClass(token, ShortCut); } else if (TypeBinding.ContainsKey(token)) { Type type = (Type)TypeBinding[token]; obj = new StaticClass(token, type); } else if (CurrentScope.Contains(token)) { obj = CurrentScope.Get(token); } else if (Namespaces.Contains(token)) { obj = new ScopeClass(token, (ResourceScope)Namespaces[token]); } else { Fail("Can't find field or type: " + token); } return(obj); } ParserValue result = ParserValue.Empty; if (obj is StaticClass) { Type type = (obj as StaticClass).Type; if (GetStaticField(type, token, out result)) { return(result); } obj = CurrentScope.Get((obj as StaticClass).Name); } else if (obj is ScopeClass) { ResourceScope scope = (obj as ScopeClass).Scope; if (scope.Contains(token)) { return(scope.Get(token)); } string newScopeName = scope.Name + "." + token; if (Namespaces.Contains(newScopeName)) { return(new ScopeClass(newScopeName, (ResourceScope)Namespaces[newScopeName])); } else { obj = CurrentScope.Get(scope.Name); } } if (!GetField(obj, token, out result)) { Fail("Couldn't get field/property " + token + " for type " + obj.Type.ToString()); } return(result); }