public void Goto(String address)
{
Current = Navigator.Evaluate(Current, address);
if (Current.Root != Result)
Result = null;
}
public static void CompleteChildren(IHdumNode node)
{
foreach (var child in node.Children)
{
child.Complete();
}
}
public static void DetectListItems(IHdumNode node)
{
Int32 count = node.Members.Keys.Count(identifier => identifier.StartsWith("#"));
for (var i=0; i<count; i++)
{
(node as IHdumCollection).RegisterItem("#" + i);
}
}
IHdumNode TryGet(IHdumNode caller, IEnumerable<IHdumNode> parameters)
{
var key = parameters.First().As<IHdumContent<String>>().Content;
if (caller.HasMember(key))
return caller[key];
else
return parameters.ElementAtOrDefault(1);
}
public static void CompleteMembers(IHdumNode node)
{
foreach (var memberData in node.NodeType.MembersData.Values)
{
if (memberData.IsRuntime)
continue;
node[node.Namespace.NamesPrefix + memberData.Identifier] = memberData.Completer(node, memberData);
}
}
public ModelNodeMember(String identifier, IHdumNode node, IDictionary<String, ImageSource> icons, IEnumerable<ModelNodeMember> subMembers)
{
Identifier = identifier;
Node = node;
if (Node != null)
Icon = icons[Node.NodeType.Name];
else
Icon = null;
SubMembers = subMembers;
}
public static void DetectChildren(IHdumNode node)
{
var baseNode = node.As<BaseHdumNode>();
foreach (var memberKvp in baseNode.Members)
{
if (memberKvp.Value == null)
continue;
if (memberKvp.Value.Parent == node && !baseNode.Children.Contains(memberKvp.Value))
baseNode._Children.Add(memberKvp.Value);
}
}
public void Complete()
{
if (IsComplete)
return;
NodeType.CompletionAction(this);
_SelfReference = this[Namespace.NamesPrefix + Namespace.MemberNames.NameofThis];
_NameNode = this[Namespace.NamesPrefix + Namespace.MemberNames.NameofName].AsTypeOrNull<IHdumName>();
IsComplete = true;
}
IHdumNode IsLast(IHdumNode caller, IEnumerable<IHdumNode> parameters)
{
if (caller.Parent is IHdumCollection)
{
var parent = caller.Parent as IHdumCollection;
if (!parent.Contains(caller))
return null;
return caller.Namespace.TypeofBoolean.CreateContent(caller == parent.Last());
}
return null;
}
public static IHdumType BasicMemberClassifier(IHdumNode node, String identifier)
{
var type = node.NodeType;
if (identifier.StartsWith(node.Namespace.NamesPrefix))
identifier = identifier.Substring(node.Namespace.NamesPrefix.Length);
if (type.MembersData.ContainsKey(identifier))
return type.MembersData[identifier].MemberType;
throw new HdumUnexpectedMemberException(node, identifier);
}
public static void DetectMapItems(IHdumNode node)
{
var prefix = node.Namespace.NamesPrefix;
IEnumerable<String> toRegister = node.Members.Keys.Where(
identifier => !(identifier.StartsWith(prefix) ||
(node.HasMember(prefix + identifier) && node[prefix + identifier] == node[identifier])
));
foreach (var identifier in toRegister)
{
(node as IHdumCollection).RegisterItem(identifier);
}
}
IHdumNode Where(IHdumNode caller, IEnumerable<IHdumNode> parameters)
{
var haystack = caller.As<IHdumCollection>();
String methodName = parameters.First().As<IHdumContent<String>>().Content;
IEnumerable<IHdumNode> methodParameters = parameters.Skip(1);
var result = haystack.NodeType.CreateNode(null, haystack.NodeType.Name);
foreach (var item in haystack)
{
if (item[methodName].As<IHdumBoundMethod>().Call(methodParameters).As<IHdumContent<Boolean>>().Content)
result.AddMember(item);
}
return result;
}
public static IHdumNode BasicMemberGetter(IHdumNode node, String identifier)
{
if (node.Members.ContainsKey(identifier))
return node.Members[identifier];
var typeMembers = node.NodeType.MembersData;
if (identifier.StartsWith(node.Namespace.NamesPrefix))
identifier = identifier.Substring(node.Namespace.NamesPrefix.Length);
if (typeMembers.ContainsKey(identifier))
{
var memberData = typeMembers[identifier];
if (memberData.IsRuntime)
return memberData.Completer(node, memberData);
}
throw new HdumMemberNotFoundException(node, identifier);
}
public static IHdumType CollectionMemberClassifier(IHdumNode node, String identifier)
{
var type = node.NodeType;
var mdata = type.MembersData;
if (identifier.StartsWith(node.Namespace.NamesPrefix))
return BasicMemberClassifier(node, identifier);
if (node.Members.ContainsKey(identifier) &&
(!mdata.ContainsKey(identifier) || node[identifier] != node[node.Namespace.NamesPrefix + identifier]))
return node.As<IHdumCollection>().ItemType;
if (mdata.ContainsKey(identifier))
return mdata[identifier].MemberType;
return node.As<IHdumCollection>().ItemType;
}
public static HdumMemberCompleter DefaultAndReflect(IHdumNode defNode)
{
return (node, data) =>
{
String prefixedIdentifier = node.Namespace.NamesPrefix + data.Identifier;
Boolean hasPrefixed = node.HasMember(prefixedIdentifier);
Boolean hasUnprefixed = node.HasMember(data.Identifier);
if (!hasPrefixed && !hasUnprefixed)
{
node[prefixedIdentifier] = defNode;
node[data.Identifier] = defNode;
}
if (hasPrefixed && !hasUnprefixed)
node[data.Identifier] = node[prefixedIdentifier];
if (!hasPrefixed && hasUnprefixed)
node[prefixedIdentifier] = node[data.Identifier];
return node[prefixedIdentifier];
};
}
public static Boolean BasicMemberChecker(IHdumNode node, String identifier)
{
if (identifier == null)
return false;
if (node.Members.ContainsKey(identifier))
return true;
var typeMembers = node.NodeType.MembersData;
if (identifier.StartsWith(node.Namespace.NamesPrefix))
identifier = identifier.Substring(node.Namespace.NamesPrefix.Length);
if (typeMembers.ContainsKey(identifier))
{
var memberData = typeMembers[identifier];
if (memberData.IsRuntime)
return true;
}
return false;
}
public static void CheckTypes(IHdumNode node)
{
foreach (var memberKvp in node.Members)
{
String identifier = memberKvp.Key;
String rawIdentifier = identifier;
if (identifier.StartsWith(node.Namespace.NamesPrefix))
rawIdentifier = identifier.Substring(node.Namespace.NamesPrefix.Length);
IHdumNode member = memberKvp.Value;
if (member == null)
{
if (node.NodeType.MembersData[rawIdentifier].IsNullable)
continue;
else
throw new HdumMissingMemberException(node, memberKvp.Key, "The given HDUM node member {0} cannot be null.");
}
IHdumType expectedType = node.NodeType.MemberClassifier(node, identifier);
if (!member.NodeType.Identities.Contains(expectedType))
throw new HdumMemberInvalidTypeException(node, identifier, expectedType);
}
}
protected HdumCollection(IHdumNode parent, IHdumType type)
: base(parent, type) { }
protected HdumCollection(IHdumNode parent, IHdumType type, String name)
: base(parent, type, name) { }
protected BaseHdumNode(IHdumNode parent, IHdumType type)
: this(parent, type, null) { }
protected BaseHdumNode(IHdumNode parent, IHdumType type, String name)
{
_Members = new OrderedDictionary<String, IHdumNode>();
_Children = new List<IHdumNode>();
_SelfReference = this;
_Parent = parent;
_Root = parent != null ? parent.Root : this;
_NodeType = type;
_Namespace = type.Namespace;
var names = _Namespace.MemberNames;
var prefix = _Namespace.NamesPrefix;
this[prefix + names.NameofThis] = _SelfReference;
this[prefix + names.NameofParent] = _Parent;
this[prefix + names.NameofRoot] = _Root;
this[prefix + names.NameofType] = _NodeType;
_NameNode = name != null ? _Namespace.TypeofName.CreateNode(this, name).As<IHdumName>() : null;
this[prefix + names.NameofName] = _NameNode;
}
public void SetMember(String identifier, IHdumNode member) { NodeType.MemberSetter(SelfReference, identifier, member); }
public HdumNodeProgramTypeException(IHdumNode node, Type type, String message, Exception inner)
: base(node, String.Format(message, node.GetType().Name, type.Name), inner) { ExpectedType = type; }
public static void BasicContentSetter(IHdumNode node, Object content)
{
var baseNode = node.As<BaseHdumNode>();
baseNode.DenyOnComplete("member setting");
baseNode._Content = content;
}
public HdumContentException(IHdumNode node)
: base(node, "A problem related to the given HDUM node's content has occurred.") { }
public static Object BasicContentGetter(IHdumNode node)
{
return node.As<BaseHdumNode>()._Content;
}
protected HdumEntity(IHdumNode parent, IHdumType type, String name)
: base(parent, type, name) { }
protected HdumEntity(IHdumNode parent, IHdumType type)
: base(parent, type) { }
public HdumContentException(IHdumNode node, String message)
: base(node, message) { }
public HdumContentException(IHdumNode node, String message, Exception inner)
: base(node, message, inner) { }
