/// <summary>
/// Adds the modeling rule to the node provided it is instance declaration. If the node is not instance declaration an error is reported.
/// </summary>
void IInstanceNodeContext.AddModelingRule()
{
if (m_IsInstanceDeclaration)
{
return;
}
if (ModelingRulesObject != ModellingRule.None)
{
m_Compiler.AddReference(AddressSpaceIndex, BuildInXmlQualifiedNames.HasModelingRule, false, BuildInXmlQualifiedNames.ModelingRuleSymbolicName(ModelingRulesObject));
}
}
private void Validate(Action <string> traceEvent)
{
//Modeling rules validation.
foreach (ModellingRule _value in Enum.GetValues(typeof(ModellingRule)))
{
if (_value == ModellingRule.None || _value == ModellingRule.CardinalityRestriction) //ModellingRule.CardinalityRestriction has not been defined in the spec.
{
continue;
}
string _symbolicName = BuildInXmlQualifiedNames.ModelingRuleSymbolicName(_value).ToString();
int _key = 0;
if (!m_Dictionary.TryGetValue(_symbolicName, out _key))
{
traceEvent(String.Format("Cannot find an object representing the modeling rules {0} name: {1} in the dictionary.", _value, _symbolicName));
continue;
}
if (m_NodesList[_key].Type == NodeHandle.NodeType.DanglingReference)
{
traceEvent(String.Format("Cannot find definition of the object representing the modeling rules {0} name: {1} ", _value, _symbolicName));
continue;
}
}
IEnumerable <KeyValuePair <int, IModelNode> > _collection = m_NodesList.Where(x => x.Value.Type == NodeHandle.NodeType.DanglingReference).
Select <KeyValuePair <int, NodeHandle>, KeyValuePair <int, IModelNode> >(x => new KeyValuePair <int, IModelNode>(x.Key, x.Value.Node)).
OrderBy <KeyValuePair <int, IModelNode>, string>(x => x.Value.Name);
foreach (KeyValuePair <int, IModelNode> _Handle in _collection)
{
int _errorNumber = m_ErrorNumber;
traceEvent(String.Format("Error {0}: The node name {1} has not bee defined or there is a wrong reference defined, and it is: ", _errorNumber, _Handle.Value.Name));
IEnumerable <AddressSpace.ReferencesTableRow> _errors = m_AddressSpace.ReferencesTable.Where <AddressSpace.ReferencesTableRow>(x => x.TargetNodeIndex == _Handle.Key);
int _maxErrors = c_MaxNumberOfErrors;
foreach (AddressSpace.ReferencesTableRow _targetItem in _errors)
{
if (_maxErrors == 0)
{
traceEvent(String.Format("Error {0}: There are {1} affected nodes, but the listing is too long to be practical.", _errorNumber, _errors.Count()));
break;
}
traceEvent(String.Format("Error {0}: The destination node for the reference type name: {1} and source node class : {2} and name: {3}.",
_errorNumber,
m_NodesList[_targetItem.ReferenceTypeIndex].Node.Name,
m_NodesList[_targetItem.SourceNodeIndex].Node.NodeClass,
m_NodesList[_targetItem.SourceNodeIndex].Node.SymbolicName));
m_NodesList[_targetItem.SourceNodeIndex].Node.ErrorList.Add(new Diagnostics(String.Format("Error {0}: The destination node for the reference type name: {1}",
_errorNumber,
m_NodesList[_targetItem.ReferenceTypeIndex].Node.SymbolicName)));
_maxErrors--;
}
_errors = m_AddressSpace.ReferencesTable.Where <AddressSpace.ReferencesTableRow>(x => x.ReferenceTypeIndex == _Handle.Key);
_maxErrors = c_MaxNumberOfErrors;
foreach (AddressSpace.ReferencesTableRow _targetItem in _errors)
{
if (_maxErrors == 0)
{
traceEvent(String.Format("Error {0}: There are {1} affected nodes, but the listing is too long to be practical.", _errorNumber, _errors.Count()));
break;
}
traceEvent(String.Format("Error {0}: The type definition for the reference connecting the source node class: {1} and name: {2} and the target node class: {3} and name: {4}",
_errorNumber,
m_NodesList[_targetItem.SourceNodeIndex].Node.NodeClass,
m_NodesList[_targetItem.SourceNodeIndex].Node.Name,
m_NodesList[_targetItem.TargetNodeIndex].Node.NodeClass,
m_NodesList[_targetItem.TargetNodeIndex].Node.Name));
m_NodesList[_targetItem.SourceNodeIndex].Node.ErrorList.Add(new Diagnostics(String.Format("Error {0}: The type definition for the reference pointing out the target node class: {1} and name: {2}",
_errorNumber,
m_NodesList[_targetItem.TargetNodeIndex].Node.NodeClass,
m_NodesList[_targetItem.TargetNodeIndex].Node.Name)));
_maxErrors--;
}
_errors = m_AddressSpace.ReferencesTable.Where <AddressSpace.ReferencesTableRow>(x => x.SourceNodeIndex == _Handle.Key);
_maxErrors = c_MaxNumberOfErrors;
foreach (AddressSpace.ReferencesTableRow _targetItem in _errors)
{
if (_maxErrors == 0)
{
traceEvent(String.Format("Error {0}: There are {1} affected nodes, but the listing is too long to be practical.", _errorNumber, _errors.Count()));
break;
}
traceEvent(String.Format("Error {0}: The source node for the reference type name: {1} and target node class: {2} and name: {3}",
_errorNumber,
m_NodesList[_targetItem.ReferenceTypeIndex].Node.Name,
m_NodesList[_targetItem.TargetNodeIndex].Node.NodeClass,
m_NodesList[_targetItem.TargetNodeIndex].Node.Name));
m_NodesList[_targetItem.SourceNodeIndex].Node.ErrorList.Add(new Diagnostics(String.Format("Error {0}: The destination node {1} for the reference type name: {2}.",
_errorNumber,
_Handle.Value.Name,
m_NodesList[_targetItem.ReferenceTypeIndex].Node.Name)));
_maxErrors--;
}
}
traceEvent(String.Format("Finishing address space compilation. there are {0} nodes in the address space", m_NodesList.Count));
}
