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); }