public void LoadComponent(string xml)
{
this.loader = new XmlLoader(the_unit);
this.application = loader.loadComponent(xml);
this.unitName = the_unit.Id_unit;
//this.index = the_unit.PartitionIndex;
foreach (MetaUnit u in application.Units.Values)
{
//Console.WriteLine("[ConfigurationManager.LoadComponent] Unit {0}", the_unit.CID.getInstanceName);
if (u.Name.Equals(this.unitName))
{
this.unit = u;
//u.Index = this.index;
break;
}
}
if (this.unit == null)
{
throw new Exception("Unit not found. Name: " + unitName);
}
ready = true;
Console.WriteLine("[ConfigurationManager.LoadComponent] Unidade {0} carregada e apta para execução.", the_unit.CID.getInstanceName());
N = the_unit.CID.getInstanceName().Equals("app.adi_solver3D-adi");
}
/*
* Retorna o super componente.
*/
public MetaHashComponent getSuperComponent(XmlNode node)
{
MetaHashComponent component = new MetaHashComponent();
component.Id = generator.genId();
supplyTypeInformation(node, component, false);
return(component);
}
public void GenerateChanges(MetaHashComponent component)
{
PairInnerComponent pair = null;
Dictionary <string, PairInnerComponent> changedInners = new Dictionary <string, PairInnerComponent> ();
foreach (MetaInnerComponent inner in component.InnerComponents)
{
if (inner.Parameters != null)
{
foreach (MetaParameter innerParam in inner.Parameters)
{
foreach (MetaParameter changedParam in changedParameters)
{
if (innerParam.Identifier.Equals(changedParam.Identifier))
{
Console.WriteLine("[StructuralReconfigurationRequest.GenerateChanges] Componente '" + inner.Identifier + "' impactado pelo parametro '" + innerParam.Identifier + "': ");
if (!changedInners.TryGetValue(inner.Identifier, out pair))
{
pair = new PairInnerComponent(inner, inner.Clone());
changedInners.Add(inner.Identifier, pair);
}
pair.New.Parameters.Remove(innerParam);
pair.New.Parameters.Add(changedParam);
}
}
}
}
}
Console.WriteLine("[StructuralReconfigurationRequest.GenerateChanges] Finalizada a avaliação dos InnerComponents!");
Console.WriteLine("[StructuralReconfigurationRequest.GenerateChanges] Avaliando unidades impactadas...");
foreach (PairInnerComponent innerPair in changedInners.Values)
{
if (innerPair.Old.Units != null)
{
foreach (MetaUnit metaUnit in innerPair.Old.Units.Values)
{
// Console.WriteLine ("[StructuralReconfigurationRequest.GenerateChanges] Unidade será '{0}.{1}' impactada.", ((MetaInnerComponent) metaUnit.Father).Identifier, metaUnit.Name);
changes.Add(new StructuralChange(metaUnit, innerPair.New.Units [metaUnit.Name]));
//Console.WriteLine("OK {0} ", metaUnit.Name);
}
}
else
{
//Console.WriteLine ("[StructuralReconfigurationRequest.GenerateChanges] InnerComponent {0} não possui Units");
}
}
}
//Método para obteção dos parâmetros de um componente.
public List <MetaParameter> getParameters(XmlNodeList nodes)
{
if (nodes != null)
{
IEnumerator ienum = (IEnumerator)nodes.GetEnumerator();
List <MetaParameter> parameterList = new List <MetaParameter> ();
MetaParameter parameter;
XmlNode data;
while (ienum.MoveNext())
{
XmlNode paramNode = (XmlNode)ienum.Current;
parameter = new MetaParameter();
parameter.Id = generator.genId();
parameter.Identifier = paramNode.SelectSingleNode("identifier").InnerText;
data = paramNode.SelectSingleNode("variable");
if (data != null)
{
parameter.Variable = data.InnerText;
}
data = paramNode.SelectSingleNode("constraint");
if (data != null)
{
MetaHashComponent limitComponent = new MetaHashComponent();
limitComponent.Id = generator.genId();
data = data.SelectSingleNode("componentConstraint");
limitComponent.Name = data.InnerText;
XmlNodeList subParamList = data.SelectNodes("parameter");
limitComponent.Parameters = getParameters(subParamList);
parameter.Constrain = limitComponent;
}
parameterList.Add(parameter);
}
if (parameterList.Count > 0)
{
return(parameterList);
}
}
return(null);
}
/*
* Este método é utilizado para preencher informacões adicionais de um componente hash.
*/
public void supplyTypeInformation(XmlNode typeNode, MetaHashComponent component, bool isInner)
{
if (typeNode != null)
{
component.Name = typeNode.SelectSingleNode("componentName").InnerText;
component.Parameters = getParameters(typeNode.SelectNodes("parameter"));
if (typeNode.SelectSingleNode("package") != null)
{
component.Package = typeNode.SelectSingleNode("package").InnerText;
}
if (isInner)
{
XmlNodeList publicInnerNodeList = typeNode.SelectNodes("publicInnerComponent");
IEnumerator ienum = (IEnumerator)publicInnerNodeList.GetEnumerator();
List <MetaInnerComponent> publicInnerList = new List <MetaInnerComponent> ();
bool ok;
while (ienum.MoveNext())
{
XmlNode innerNode = (XmlNode)ienum.Current;
ok = false;
if (innerComponents != null)
{
foreach (MetaInnerComponent mic in innerComponents)
{
if (mic.Identifier.Equals(innerNode.InnerText))
{
publicInnerList.Add(mic);
ok = true;
break;
}
}
}
if (!ok && candidateInnerComponents != null)
{
foreach (MetaInnerComponent mic in candidateInnerComponents)
{
if (mic.Identifier.Equals(innerNode.InnerText))
{
publicInnerList.Add(mic);
ok = true;
break;
}
}
}
if (!ok)
{
throw new Exception("a variável " + innerNode.InnerText + " não é um inner component válido.");
}
}
if (publicInnerList.Count > 0)
{
component.InnerComponents = publicInnerList;
}
}
}
}
public ReconfigurationRequest loadRequest(string xml, MetaHashComponent component)
{
ReconfigurationRequest request = null;
Console.WriteLine("[XmlLoader.loadRequest] Iniciando carga de script de reconfiguração... ");
if (true /*validator.IsValid (REQUEST_XSD, xml)*/)
{
clear();
generator.setInitialCode(component.LastIdCode);
request = new ReconfigurationRequest();
XmlDocument document = new XmlDocument();
XmlNode nodeRequest, data;
document.Load(xml);
nodeRequest = document.SelectSingleNode("reconfigurationRequest");
data = nodeRequest.SelectSingleNode("targetComponent");
request.TargetComponent = data.InnerText;
//Console.WriteLine("[XmlLoader.LoadRequest] Obtendo componente alvo {0}", request.TargetComponent);
List <MetaParameter> parameterList = uLoader.getParameters(nodeRequest.SelectNodes("parameter"));
if (parameterList != null)
{
Console.WriteLine("[XmlLoader.LoadRequest] Carregando as reconfigurações estruturais...");
request.StructuralRequest = new StructuralReconfigurationRequest(parameterList);
}
BehavioralReconfigurationRequest behavioralRequest = null;
List <MetaInnerComponent> innerComponents = generateInnerComponents(nodeRequest.SelectNodes("innerComponent"));
//Console.WriteLine("[XmlLoader.LoadRequest] Tem innerComponent para adicionar? {0}", innerComponents != null);
if (innerComponents != null)
{
behavioralRequest = new BehavioralReconfigurationRequest();
Console.WriteLine("[XmlLoader.LoadRequest] Carregando novos componentes aninhados...");
//Console.WriteLine("[XmlLoader.LoadRequest] {0} InnerComponent(s) adicionado(s)", innerComponents.Count);
behavioralRequest.NewInnerComponents = innerComponents;
uLoader.CandidateInnerComponents = innerComponents;
}
uLoader.InnerComponents = innerComponents;
XmlNodeList changeActionList = nodeRequest.SelectNodes("changeAction");
if (changeActionList != null)
{
Console.WriteLine("[XmlLoader.LoadRequest] Carregando as reconfigurações comportamentais...");
IEnumerator ienum = changeActionList.GetEnumerator();
BehavioralChange change;
XmlNode changeNode;
if (behavioralRequest == null)
{
behavioralRequest = new BehavioralReconfigurationRequest();
}
XmlAttribute attr;
int initialCode;
int aditionalStates, aditionalTrans;
aditionalStates = aditionalTrans = 0;
while (ienum.MoveNext())
{
changeNode = (XmlNode)ienum.Current;
change = new BehavioralChange();
//Console.WriteLine("[XmlLoader.LoadRequest] Criando uma nova BehavioralChange");
initialCode = generator.getCurrentCode();
attr = (XmlAttribute)changeNode.Attributes.GetNamedItem("unit");
change.Unit = attr.Value;
//Console.WriteLine("[XmlLoader.LoadRequest] Unit a sofrer alteração: {0}", change.Unit);
MetaUnit u = component.Units[change.Unit];
if (u != null)
{
//Console.WriteLine("[XmlLoader.LoadRequest] Unit {0} encontrada!", change.Unit);
attr = (XmlAttribute)changeNode.Attributes.GetNamedItem("action");
change.Action = attr.Value;
//Console.WriteLine("[XmlLoader.LoadRequest] Ação a sofrer alteração: {0}", change.Action);
MetaAction a = u.Actions[change.Action];
if (a != null && !a.IsNative)
{
//Console.WriteLine("[XmlLoader.LoadRequest] Ação {0} encontrada!", change.Action);
attr = (XmlAttribute)changeNode.Attributes.GetNamedItem("type");
if (attr.Value.Equals("remove"))
{
change.Type = BehavioralChange.BehavioralChangeType.REMOVE;
}
else
{
change.Type = BehavioralChange.BehavioralChangeType.INCLUDE;
}
attr = (XmlAttribute)changeNode.Attributes.GetNamedItem("point");
change.Point = attr.Value;
//Console.WriteLine("[XmlLoader.LoadRequest] Ponto a sofrer alteração: {0}", change.Point);
Transition t = a.Protocol.getTransition(change.Point);
if (t != null)
{
//Console.WriteLine("[XmlLoader.LoadRequest] Ponto {0} encontrado.", change.Point);
change.NewSlices = uLoader.getSlices(changeNode.SelectNodes("slice"));
uLoader.CandidateSlices = change.NewSlices;
if (change.Type == BehavioralChange.BehavioralChangeType.INCLUDE)
{
//Console.WriteLine("[XmlLoader.LoadRequest] Obtendo novo protocolo");
change.Transitions = uLoader.getTransitions(changeNode.SelectSingleNode("protocol").FirstChild, u, t.InitialState, t.FinalState, a.Protocol.NumStates + aditionalStates, a.Protocol.LastTransationId + aditionalTrans);
aditionalStates = uLoader.NumStates - a.Protocol.NumStates;
aditionalTrans = uLoader.NumTransations - a.Protocol.LastTransationId;
//TODO remover
//Console.WriteLine("Transações de reconfiguração");
//foreach(Transition tst in change.Transitions) {
// Console.WriteLine(tst);
//}
}
else
{
change.Transitions = new List <Transition>();
change.Transitions.Add(new Transition(t.InitialState, t.FinalState, Configuration.LAMBDA_TRANSITION, a.Protocol.LastTransationId++));
}
}
else
{
throw new Exception("[XmlLoader.loadRequest] Ponto de reconfiguração não existe: " + change.Point);
}
}
else
{
throw new Exception("[XmlLoader.loadRequest] Ação a ser alterada não existe ou nãoo é uma configuração: " + change.Action);
}
}
else
{
throw new Exception("[XmlLoader.loadRequest] Unidade da ação a ser alterada não existe: " + change.Unit);
}
change.AditionalStates = generator.getCurrentCode() - initialCode;
behavioralRequest.AddChange(change);
}
}
request.BehavioralRequest = behavioralRequest;
component.LastIdCode = generator.getCurrentCode();
}
uLoader.CandidateSlices = null;
uLoader.CandidateInnerComponents = null;
Console.WriteLine("[XmlLoader.loadRequest] Carga de script realizada com sucesso!");
return(request);
}
public MetaHashComponent loadComponent(string xml)
{
MetaHashComponent component = null;
Console.WriteLine("[XmlLoader.loadComponent] Iniciando carga de arquivo de configuração... {0}", xml);
if (true /*validator.IsValid (COMPONENT_XSD, xml)*/)
{
clear();
component = new MetaHashComponent();
component.Id = generator.genId();
XmlDocument document = new XmlDocument();
document.Load(xml);
XmlNode nodeComponent = document.SelectSingleNode("hashComponent");
Console.WriteLine("[XmlLoader.loadComponente] ponto 1!");
component.Package = nodeComponent.SelectSingleNode("package").InnerText;
XmlNodeList usingNodeList = nodeComponent.SelectNodes("using");
Console.WriteLine("[XmlLoader.loadComponente] ponto 1.1!");
IEnumerator ienum = usingNodeList.GetEnumerator();
List <string> usingList = new List <string> ();
while (ienum.MoveNext())
{
XmlNode usingNode = (XmlNode)ienum.Current;
usingList.Add(usingNode.InnerText);
}
Console.WriteLine("[XmlLoader.loadComponente] ponto 1.2!");
if (usingList.Count > 0)
{
component.UsingList = usingList;
}
Console.WriteLine("[XmlLoader.loadComponente] Ponto 2!");
component.Kind = nodeComponent.SelectSingleNode("kind").InnerText;
component.Name = nodeComponent.SelectSingleNode("name").InnerText;
XmlNodeList parameterList = nodeComponent.SelectNodes("parameter");
component.Parameters = uLoader.getParameters(parameterList);
XmlNodeList innerComponentList = nodeComponent.SelectNodes("innerComponent");
List <MetaInnerComponent> inners = generateInnerComponents(innerComponentList);
uLoader.InnerComponents = inners;
component.InnerComponents = inners;
XmlNode superComponent = nodeComponent.SelectSingleNode("superComponent");
component.SuperComponent = uLoader.getSuperComponent(superComponent);
XmlNodeList unitList = nodeComponent.SelectNodes("unit");
component.Units = uLoader.getUnits(unitList);
Console.WriteLine("[XmlLoader.loadComponente] Ponto 3!");
foreach (MetaUnit mu in component.Units.Values)
{
foreach (MetaAction ma in mu.Actions.Values)
{
foreach (Transition t in ma.Protocol.Transitions)
{
if (t.getExecutionAction() != null)
{
Queue <Condition> queue = new Queue <Condition> ();
queue.Enqueue(t.getExecutionAction().Condition);
while (queue.Count > 0)
{
Condition c = queue.Dequeue();
if (c != null)
{
foreach (Condition e in c.Conditions)
{
queue.Enqueue(e);
}
if (c.Slice != null && !c.Slice.Equals(""))
{
mu.Slices[c.Slice].Unit.Conditions.Add((c.Name == null || c.Name.Equals("") ? c.Id + "": c.Name), c);
}
}
}
}
}
}
}
component.LastIdCode = generator.getCurrentCode();
}
Console.WriteLine("[XmlLoader.loadComponente] Carga realizada com sucesso!");
return(component);
}
