public void RemoveComponent(ISchemeComponent component)
{
if (!Components.Contains(component))
{
return;
}
//do something about duplicated Id code
if (component is Argument)
{ //fix arguments order
var argument = component as Argument;
var argsGreater = from x in Arguments
where x.Order > argument.Order
select x;
foreach (var arg in argsGreater)
{
arg.Order -= 1;
}
_numArgs -= 1;
}
if (component is Condition)
{
var condition = component as Condition;
var condsGreater = from x in Conditions
where x.ID > condition.ID
select x;
foreach (var cond in condsGreater)
{
cond.ID -= 1;
}
_numConds -= 1;
}
Components.Remove(component);
}
//why not just Rules.Add()?
//FUG
public Rule AddRule(RuleType type, OntologyNode.Attribute attr, ISchemeComponent reference, OntologyNode.Attribute inputAttr)//, string value)
{
Rule rule = new Rule(attr, reference, inputAttr);
_rules.Add(attr.Name, rule);
return(rule);
}
public void RemoveUpper(ISchemeComponent component)
{
if (Arg1 == component)
{
Arg1 = null;
}
else if (Arg2 == component)
{
Arg2 = null;
}
}
public static void RemoveSchemeConnection(Connector src, Connector dst)
{
ISchemeComponent dstComponent = dst.ParentNode.Tag as ISchemeComponent;
if (dst.Tag is OntologyNode.Attribute)
{
dstComponent.Free(dst.Tag as OntologyNode.Attribute);
}
else
{ ///
}
}
private void NV_NodeRemoving(object sender, System.Windows.RoutedEventArgs e)
{
var node = e.Source as network.Node;
ISchemeComponent comp = ((network.Node)e.Source).Tag as ISchemeComponent;
var oneighbors = node.OutgoingNeighbors;
foreach (var neighbor in oneighbors)
{
(neighbor.Tag as ISchemeComponent).RemoveUpper(comp);
}
CurrentScheme.RemoveComponent(comp);
Console.WriteLine("NV_NodeRemoving!");
}
/// <summary>
///
/// </summary>
/// <param name="type"></param>
/// <param name="attr"></param>
/// <param name="reference"></param>
/// <param name="inputAttr">may be null if 'reference' is a functor</param>
public Rule(OntologyNode.Attribute attr, ISchemeComponent reference, OntologyNode.Attribute inputAttr)
{
if (reference is Argument)
{
Type = RuleType.ATTR;
}
else if (reference is Functor)
{
Type = RuleType.FUNC;
}
else
{
Type = RuleType.DEF;
}
Attribute = attr;
Reference = reference;
InputAttribute = inputAttr;
Default = "";
}
public void RemoveUpper(ISchemeComponent upper)
{
var rulesCopy = new Dictionary <string, Rule>(Rules);
//rulesCopy.AddRange(Rules);
foreach (var rule in rulesCopy)
{
if (rule.Value.Reference == upper)
{
var defaultValue = rule.Value.Default;
Rules.Remove(rule.Key);
if (defaultValue != null)
{
Rules[rule.Key] = new Rule(rule.Value.Attribute, defaultValue);
}
}
}
if (upper == EditObject)
{
EditObject = null;
}
}
public void RemoveUpper(ISchemeComponent upper)
{
}
public static FactSchemeBank FromXml(XElement root, List <OntologyNode> ontology, Vocabularies.Vocabulary themes)
{
FactSchemeBank bank = new FactSchemeBank();
foreach (XElement xscheme in root.Elements())
{
Scheme scheme = new Scheme(xscheme.Attribute(FatonConstants.XML_SCHEME_NAME).Value);
scheme.Segment = xscheme.Attribute(FatonConstants.XML_SCHEME_SEGMENT)?.Value;
if (scheme.Segment == null)
{
scheme.Segment = "";
}
var arguments = from x in xscheme.Elements()
where x.Name.LocalName == FatonConstants.XML_ARGUMENT_TAG
select x;
var results = from x in xscheme.Elements()
where x.Name.LocalName == FatonConstants.XML_RESULT_TAG
select x;
var conditionComplexes = from x in xscheme.Elements()
where x.Name.LocalName == FatonConstants.XML_CONDITIONCOMPLEX_TAG
select x;
var functors = from x in xscheme.Elements()
where x.Name.LocalName == "Functor"
select x;
foreach (XElement xarg in arguments)
{
Argument arg = null;
if (xarg.Attribute(FatonConstants.XML_ARGUMENT_OBJECTTYPE).Value.Equals(ArgumentType.TERMIN.ToString()))
{
Termin term;
string termName = xarg.Attribute("ClassName").Value;
if (termName.StartsWith("#"))
{
term = DiglexFunctions.LexFunctions.First(x => x.Name == termName);
}
else
{
term = themes[termName];
}
arg = scheme.AddArgument(term);
var varattrs = from x in xarg.Elements() where x.Name == "VarAttr" select x;
foreach (var attr in varattrs)
{
arg.Attributes.Add(new OntologyNode.Attribute(OntologyNode.Attribute.AttributeType.STRING, attr.Attribute("Name").Value, true));
}
}
else
{
OntologyClass argKlass;
foreach (OntologyClass klass in ontology)
{
argKlass = klass.FindChild(xarg.Attribute(FatonConstants.XML_ARGUMENT_CLASSNAME).Value);
if (argKlass == null)
{
continue;
}
arg = scheme.AddArgument(argKlass);
break;
}
}
arg.Order = uint.Parse(xarg.Attribute(FatonConstants.XML_ARGUMENT_ORDER).Value);
foreach (XElement xcond in xarg.Elements(FatonConstants.XML_ARGUMENT_CONDITION_TAG))
{
var condition = new Argument.ArgumentCondition();
var attrName = xcond.Attribute(FatonConstants.XML_ARGUMENT_CONDITION_ATTRNAME).Value;
var type = xcond.Attribute(FatonConstants.XML_ARGUMENT_CONDITION_TYPE).Value;
var comparType = xcond.Attribute(FatonConstants.XML_ARGUMENT_CONDITION_OPERATION).Value;
var value = xcond.Attribute(FatonConstants.XML_ARGUMENT_CONDITION_DATA).Value;
condition.Operation = (ArgumentConditionOperation)Enum.Parse(typeof(ArgumentConditionOperation), comparType);
condition.CondType = (ArgumentConditionType)Enum.Parse(typeof(ArgumentConditionType), type);
condition.Data = value;
var attr = arg.Attributes.Find(x => x.Name.Equals(attrName));
arg.Conditions[attr].Add(condition);
}
}
foreach (XElement xres in results)
{
OntologyClass resKlass = null;
Result result;
foreach (OntologyClass klass in ontology)
{
resKlass = klass.FindChild(xres.Attribute(FatonConstants.XML_RESULT_CLASSNAME).Value);
if (resKlass != null)
{
break;
}
}
if (resKlass == null)
{
continue;
}
result = scheme.AddResult(resKlass, xres.Attribute(FatonConstants.XML_RESULT_NAME).Value);
foreach (XElement xrul in xres.Elements())
{
Result.RuleType ruleType = (Result.RuleType)Enum.Parse(typeof(Result.RuleType),
xrul.Attribute(FatonConstants.XML_RESULT_RULE_TYPE).Value);
OntologyNode.Attribute attr = result.Reference.AllAttributes.Find(x => x.Name == xrul.Attribute(FatonConstants.XML_RESULT_RULE_ATTR).Value);
if (ruleType == Result.RuleType.ATTR)
{
Argument arg = scheme.Arguments.Find(x => x.Order == int.Parse(xrul.Attribute(FatonConstants.XML_RESULT_RULE_RESOURCE).Value));
OntologyNode.Attribute inputAttr = null;
if (attr.AttrType != OntologyNode.Attribute.AttributeType.OBJECT)
{
inputAttr = arg.Attributes.Find(x => x.Name == xrul.Attribute(FatonConstants.XML_RESULT_RULE_ATTRFROM).Value);
}
var rule = result.AddRule(ruleType, attr, arg, inputAttr);
rule.ResourceType = (RuleResourceType)Enum.Parse(typeof(RuleResourceType),
xrul.Attribute(FatonConstants.XML_RESULT_RULE_RESOURCETYPE).Value);
if (xrul.Attribute("Default") != null)
{
rule.Default = xrul.Attribute("Default").Value;
}
}
if (ruleType == Result.RuleType.FUNC)
{
Functor fun = FunctorFactory.Build(xrul.Attribute(FatonConstants.XML_RESULT_RULE_FUNCTOR_NAME).Value);
fun.CID = UID.Take(uint.Parse(xrul.Attribute(FatonConstants.XML_RESULT_RULE_FUNCTOR_ID).Value));
var inputs = xrul.Elements(FatonConstants.XML_RESULT_RULE_FUNCTOR_INPUT);
fun.Inputs.Clear();
foreach (var xinput in inputs)
{
var resourceType = (RuleResourceType)Enum.Parse(typeof(RuleResourceType),
xinput.Attribute(FatonConstants.XML_RESULT_RULE_FUNCTOR_RESOURCETYPE).Value);
ISchemeComponent resource = null;
OntologyNode.Attribute value = null;
if (resourceType == RuleResourceType.ARG)
{
resource = scheme.Arguments.Find(x => x.Order == int.Parse(xinput.Attribute(FatonConstants.XML_RESULT_RULE_RESOURCE).Value));
value = ((Argument)resource).Attributes.Find(x => x.Name == xinput.Attribute(FatonConstants.XML_RESULT_RULE_FUNCTOR_ATTRFROM).Value);
}
else
{
};
var input = new Functor.FunctorInput("input");
input.Set(value, resource);
fun.Inputs.Add(input);
}
scheme.Components.Add(fun);
var rule = result.AddRule(ruleType, attr, fun, fun.Output);
if (xrul.Attribute("Default") != null)
{
rule.Default = xrul.Attribute("Default").Value;
}
}
}
if (xres.Attribute(FatonConstants.XML_RESULT_ARGEDIT) != null)
{
result.Type = ResultType.EDIT;
result.EditObject = scheme.Arguments.Find(x => x.Order == int.Parse(xres.Attribute(FatonConstants.XML_RESULT_ARGEDIT).Value));
}
}
foreach (var xcomplex in conditionComplexes)
{
var argName1 = uint.Parse(xcomplex.Attribute("Arg1").Value);
var argName2 = uint.Parse(xcomplex.Attribute("Arg2").Value);
var conditions = xcomplex.Elements();
foreach (var xcond in conditions)
{
var cond = scheme.AddCondition();
cond.ID = uint.Parse(xcond.Attribute(FatonConstants.XML_ARGUMENT_CONDITION_ID).Value);
cond.Type = (ConditionType)Enum.Parse(typeof(ConditionType), xcond.Attribute(FatonConstants.XML_ARGUMENT_CONDITION_TYPE).Value);
cond.Operation = (ConditionOperation)Enum.Parse(typeof(ConditionOperation), xcond.Attribute(FatonConstants.XML_ARGUMENT_CONDITION_OPERATION).Value);
var arg1 = scheme.Arguments.Find(x => x.Order == argName1);
var arg2 = scheme.Arguments.Find(x => x.Order == argName2);
cond.Arg1 = arg1;
cond.Arg2 = arg2;
cond.Data = xcond.Attribute(FatonConstants.XML_ARGUMENT_CONDITION_DATA).Value;
}
}
bank.Schemes.Add(scheme);
}
return(bank);
}
public void Set(OntologyNode.Attribute attr, ISchemeComponent attrSource)
{
this.value = attr;
this.source = attrSource;
}
public void RemoveUpper(ISchemeComponent component)
{
throw new NotImplementedException();
}
