/// <summary>
/// Opens a new namespace for current script.
/// </summary>
private void declareOpenNamespace(UseNode node)
{
if (!Namespaces.ContainsKey(node.Namespace))
{
Namespaces.Add(node.Namespace, true);
}
}
public void AddNamespace(SDNamespace sdNamespace)
{
if (!Namespaces.ContainsKey(sdNamespace.Identifier))
{
Namespaces.Add(sdNamespace.Identifier, sdNamespace);
}
}
private void RrecursiveParse(XPathNavigator navigator)
{
var namespaces = navigator.GetNamespacesInScope(XmlNamespaceScope.Local);
foreach (var map in namespaces)
{
if (String.IsNullOrEmpty(map.Key))
{
DefaultNamespaces.Add(map.Value);
}
else if (!Namespaces.ContainsKey(map.Key))
{
Namespaces.Add(map.Key, map.Value);
}
}
// process child element nodes
if (navigator.HasChildren &&
(ParseChildren || navigator.NodeType == XPathNodeType.Root) &&
navigator.MoveToFirstChild())
{
do
{
RrecursiveParse(navigator);
}while (navigator.MoveToNext(XPathNodeType.Element));
// move back to the original parent node
navigator.MoveToParent();
}
}
public void RemoveNamespace(String ns)
{
if (Namespaces.ContainsKey(ns))
{
Namespaces.Remove(ns);
}
}
public void AddNamespace(String ns)
{
if (!Namespaces.ContainsKey(ns))
{
Namespaces.Add(ns, null);
}
}
public Globals GetNamespace(string ns)
{
if (Namespaces.ContainsKey(ns))
return Namespaces[ns];
if (Parent != null)
return Parent.GetNamespace(ns);
return null;
}
public bool ContainsNamespace(string ns)
{
if (Namespaces.ContainsKey(ns))
return true;
if (Parent != null)
return Parent.ContainsNamespace(ns);
return false;
}
/// <summary>
/// This method is used to return a reference to the namespace with the specified name
/// </summary>
/// <param name="FullName">
/// A <see cref="System.String"/>
/// </param>
/// <returns>
/// A <see cref="NamespaceProperties"/>
/// </returns>
internal NamespaceProperties GetNamespaceReference(string FullName)
{
if (Namespaces.ContainsKey(FullName))
{
return(Namespaces[FullName]);
}
return(null);
}
/// <summary>
/// Adds a namespace to this project. "@" represents the root namespace.
/// </summary>
public void AddNamespace(string name)
{
if (Namespaces.ContainsKey(name))
{
throw new Exception("A namespace already exists with this name.");
}
Namespaces.Add(name, new List <ClassModule>());
}
public Globals GetNamespace(string ns)
{
if (Namespaces.ContainsKey(ns))
{
return(Namespaces[ns]);
}
if (Parent != null)
{
return(Parent.GetNamespace(ns));
}
return(null);
}
public void GetNamespaces(string code, string project)
{
if (Namespaces == null)
{
Namespaces = new Dictionary <string, Dictionary <int, string> >();
}
if (Namespaces.ContainsKey(code))
{
return;
}
Namespaces.Add(code, WikiApiFunctions.GetNamespaces(code, project));
}
public bool ContainsNamespace(string ns)
{
if (Namespaces.ContainsKey(ns))
{
return(true);
}
if (Parent != null)
{
return(Parent.ContainsNamespace(ns));
}
return(false);
}
// Left mostly to when used as a namespace
public override BaseTypeInfo ResolvePropertyPath(Globals globals, params string[] path)
{
if (Classes.ContainsKey(path[0]))
return Classes[path[0]];
else if (Namespaces.ContainsKey(path[0]))
return Namespaces[path[0]];
foreach (FunctionInfo f in Functions)
{
if (f.Name.Equals(path[0]))
return f;
}
return null;
}
public void AddRDFNamespace(string prefixAndNamespace, string uri)
{
if (!string.IsNullOrEmpty(prefixAndNamespace) && !string.IsNullOrEmpty(uri))
{
if (!Namespaces.ContainsKey(prefixAndNamespace))
{
Namespaces.Add(prefixAndNamespace, uri);
}
else
{
Namespaces[prefixAndNamespace] = uri;
}
}
}
/// <summary>
/// Checks if a local name in <paramref name="LocalName"/> represents a subnamespace from the point of view of the namespace
/// in <paramref name="Namespace"/>.
/// </summary>
/// <param name="Namespace">Namespace.</param>
/// <param name="LocalName">Local name.</param>
/// <returns>If the local name represents a subnamespace.</returns>
public static bool IsSubNamespace(string Namespace, string LocalName)
{
lock (synchObject)
{
if (!isInitialized)
{
throw NotInitializedException();
}
if (!namespacesPerNamespace.TryGetValue(Namespace, out SortedDictionary <string, bool> Namespaces))
{
return(false);
}
return(Namespaces.ContainsKey(Namespace + "." + LocalName));
}
}
private void AddNamespace(StringBuilder key, ITypeDefinition cls)
{
lock (Namespaces)
{
if (InstanceExists(key.ToString()))
{
return;
}
if (!Namespaces.ContainsKey(cls.Namespace))
{
Namespaces.Add(cls.Namespace, new NamespaceProperties(cls.Namespace));
}
Namespaces[cls.Namespace].AddInstance(cls);
}
}
internal void AddRDFNamespaces(Dictionary <string, string> namespaces)
{
foreach (KeyValuePair <string, string> pair in namespaces)
{
string prefixAndNamespace = pair.Key;
string uri = pair.Value;
if (!string.IsNullOrEmpty(prefixAndNamespace) && !string.IsNullOrEmpty(uri))
{
if (!Namespaces.ContainsKey(prefixAndNamespace))
{
Namespaces.Add(prefixAndNamespace, uri);
}
else
{
Namespaces[prefixAndNamespace] = uri;
}
}
}
}
private string GetDefaultKey(int index)
{
int charStart = 97;
int charEnd = 122;
int charKey = charStart + index;
bool isAutomaticLetter = DefaultScheme == DefaultPrefixScheme.AutomaticLetter;
bool isPrefixAndLetter = DefaultScheme == DefaultPrefixScheme.PrefixAndLetter;
string key = DefaultPrefix;
do
{
// if run out of letters
bool isCharEnd = charKey > charEnd;
if (!isCharEnd && isAutomaticLetter)
{
//letter at index
key = ((char)charKey).ToString();
}
else if (!isCharEnd && isPrefixAndLetter)
{
//default and letter at index
key = DefaultPrefix + ((char)charKey).ToString();
}
else if (index > 0)
{
key = DefaultPrefix + index.ToString();
}
index++;
charKey++;
}while (Namespaces.ContainsKey(key));
return(key);
}
/// <summary>
/// Initializes the inventory engine, registering types and interfaces available in <paramref name="Assemblies"/>.
/// </summary>
public static void Initialize(params Assembly[] Assemblies)
{
SortedDictionary <string, Type> Types;
SortedDictionary <string, Type> LastTypes = null;
IEnumerable <Type> AssemblyTypes;
Assembly A;
string InterfaceName;
string TypeName;
string Namespace;
string ParentNamespace;
string LastNamespace = string.Empty;
int i;
if (isInitialized)
{
throw new Exception("Script engine is already initialized.");
}
CheckIncluded(ref Assemblies, typeof(Types).GetTypeInfo().Assembly);
CheckIncluded(ref Assemblies, typeof(int).GetTypeInfo().Assembly);
if (Array.IndexOf <Assembly>(Assemblies, A = typeof(Types).GetTypeInfo().Assembly) < 0)
{
int c = Assemblies.Length;
Array.Resize <Assembly>(ref Assemblies, c + 1);
Assemblies[c] = A;
}
foreach (Assembly Assembly in Assemblies)
{
try
{
AssemblyTypes = Assembly.ExportedTypes;
}
catch (ReflectionTypeLoadException ex)
{
foreach (Exception ex2 in ex.LoaderExceptions)
{
Log.Critical(ex2);
}
continue;
}
catch (Exception ex)
{
Log.Critical(ex, Assembly.FullName);
continue;
}
foreach (Type Type in AssemblyTypes)
{
TypeName = Type.FullName;
i = TypeName.LastIndexOf('`');
if (i > 0 && int.TryParse(TypeName.Substring(i + 1), out int j))
{
TypeName = TypeName.Substring(0, i);
}
types[TypeName] = Type;
foreach (Type Interface in Type.GetTypeInfo().ImplementedInterfaces)
{
InterfaceName = Interface.FullName;
if (InterfaceName == null)
{
continue; // Generic interface.
}
if (!typesPerInterface.TryGetValue(InterfaceName, out Types))
{
Types = new SortedDictionary <string, Type>();
typesPerInterface[InterfaceName] = Types;
}
Types[TypeName] = Type;
}
Namespace = Type.Namespace;
if (Namespace != null)
{
if (Namespace == LastNamespace)
{
Types = LastTypes;
}
else
{
if (!typesPerNamespace.TryGetValue(Namespace, out Types))
{
Types = new SortedDictionary <string, Type>();
typesPerNamespace[Namespace] = Types;
i = Namespace.LastIndexOf('.');
while (i > 0)
{
ParentNamespace = Namespace.Substring(0, i);
if (!namespacesPerNamespace.TryGetValue(ParentNamespace, out SortedDictionary <string, bool> Namespaces))
{
Namespaces = new SortedDictionary <string, bool>();
namespacesPerNamespace[ParentNamespace] = Namespaces;
}
else
{
if (Namespaces.ContainsKey(Namespace))
{
break;
}
}
Namespaces[Namespace] = true;
Namespace = ParentNamespace;
i = Namespace.LastIndexOf('.');
}
if (i < 0)
{
rootNamespaces[Namespace] = true;
}
}
LastNamespace = Namespace;
LastTypes = Types;
}
Types[TypeName] = Type;
}
}
}
isInitialized = true;
}
