private IList <string> fetchPackages(int id_functor_app)
{
IList <string> package_list = new List <string>();
AbstractComponentFunctorApplication acfa = BackEnd.acfadao.retrieve(id_functor_app);
AbstractComponentFunctor acf = BackEnd.acfdao.retrieve(acfa.Id_abstract);
package_list.Add(acf.Library_path);
IList <SupplyParameter> sp_list = BackEnd.spdao.list(id_functor_app);
foreach (SupplyParameter sp in sp_list)
{
if (sp is SupplyParameterComponent)
{
SupplyParameterComponent spc = (SupplyParameterComponent)sp;
foreach (string pk in fetchPackages(spc.Id_functor_app_actual))
{
package_list.Add(pk);
}
}
else if (sp is SupplyParameterParameter)
{
SupplyParameterParameter spp = (SupplyParameterParameter)sp;
// NOTHING TO DO ... the parameter depends on the paramter of the component
}
}
return(package_list);
}
protected IList <SupplyParameter> loadAbstractComponentFunctorApplicationParameters(ComponentInUseType c,
AbstractComponentFunctorApplication aNew,
AbstractComponentFunctorApplication aNew_context)
{
IList <SupplyParameter> pars = new List <SupplyParameter>();
if (c.parameter != null)
{
foreach (ParameterRenaming p in c.parameter)
{
String formFieldId = p.formFieldId;
String varName = p.varName;
Console.WriteLine("loadAbstractcomponentFunctorApplicationParameters -1 " + varName + "," + formFieldId);
SupplyParameter p_ = null;
ParameterType topParameter = lookForParameterByVarName(varName);
ParameterSupplyType s = lookForSupplyForVarName(varName);
if (topParameter != null)
{
Console.WriteLine("loadAbstractcomponentFunctorApplicationParameters 0 " + topParameter.formFieldId + ", " + varName);
p_ = new SupplyParameterParameter();
((SupplyParameterParameter)p_).Id_argument = topParameter.formFieldId;
((SupplyParameterParameter)p_).FreeVariable = false;
}
else if (s != null)
{
Console.WriteLine("loadAbstractcomponentFunctorApplicationParameters 1 " + s.cRef + ", " + varName);
String cRef = s.cRef;
p_ = new SupplyParameterComponent();
// Look for the inner component that supplies that parameter.
InnerComponentType inner = lookForInnerComponent(cRef);
AbstractComponentFunctorApplication cPar = newAbstractComponentFunctorApplication(inner);
if (cPar == null)
{
throw new Exception("DEPLOY ERROR: Unresolved Dependency for base component (context actual parameter) : " + inner.name);
}
((SupplyParameterComponent)p_).Id_functor_app_actual = cPar.Id_functor_app;
}
else
{
Console.WriteLine("loadAbstractcomponentFunctorApplicationParameters 2 " + varName);
p_ = new SupplyParameterParameter();
((SupplyParameterParameter)p_).Id_argument = null;
((SupplyParameterParameter)p_).FreeVariable = true;
}
p_.Id_functor_app = aNew.Id_functor_app;
p_.Id_abstract = aNew.Id_abstract;
p_.Id_parameter = formFieldId;
// SupplyParameterDAO p_DAO = new SupplyParameterDAO();
br.ufc.pargo.hpe.backend.DGAC.BackEnd.spdao.insert(p_);
pars.Add(p_);
}
}
loadSuppliedParametersOfSupertype(c, aNew, aNew_context);
return(pars);
}
// NOT YET TESTED
private int liftFunctorApp(int id_functor_app, IDictionary <string, SupplyParameter> parsSuper)
{
AbstractComponentFunctorApplication acfa = br.ufc.pargo.hpe.backend.DGAC.BackEnd.acfadao.retrieve(id_functor_app);
AbstractComponentFunctorApplication acfaNew = new AbstractComponentFunctorApplication();
acfaNew.Id_abstract = acfa.Id_abstract;
br.ufc.pargo.hpe.backend.DGAC.BackEnd.acfadao.insert(acfaNew);
IList <SupplyParameter> supplyList = br.ufc.pargo.hpe.backend.DGAC.BackEnd.spdao.list(id_functor_app);
foreach (SupplyParameter sp in supplyList)
{
SupplyParameter spNew = null;
if (sp is SupplyParameterComponent)
{
SupplyParameterComponent spc = (SupplyParameterComponent)sp;
SupplyParameterComponent spcNew = new SupplyParameterComponent();
spNew = spcNew;
spcNew.Id_functor_app = acfaNew.Id_functor_app;
spcNew.Id_functor_app_actual = liftFunctorApp(spc.Id_functor_app_actual, parsSuper);
spcNew.Id_abstract = spc.Id_abstract;
spcNew.Id_parameter = spc.Id_parameter;
}
else if (sp is SupplyParameterParameter)
{
SupplyParameterParameter spp = (SupplyParameterParameter)sp;
SupplyParameter spSuper = null;
if (parsSuper.Count > 0)
{
foreach (KeyValuePair <string, SupplyParameter> p in parsSuper)
{
Console.WriteLine("Key=" + p.Key + ", Value=" + p.Value.Id_abstract);
}
}
else
{
Console.WriteLine("parSupers EMPTY !!!!!!");
}
if (parsSuper.TryGetValue(spp.Id_argument, out spSuper))
{
if (spSuper is SupplyParameterComponent)
{
SupplyParameterComponent spcSuper = (SupplyParameterComponent)spSuper;
SupplyParameterComponent spcNew = new SupplyParameterComponent();
spNew = spcNew;
Console.WriteLine("liftFunctorApp: 1" + (spNew == null));
AbstractComponentFunctorApplication acfa_spcSuper = br.ufc.pargo.hpe.backend.DGAC.BackEnd.acfadao.retrieve(spcSuper.Id_functor_app_actual);
spcNew.Id_functor_app = acfaNew.Id_functor_app;
spcNew.Id_abstract = acfa_spcSuper.Id_abstract;
spcNew.Id_parameter = spp.Id_parameter;
spcNew.Id_functor_app_actual = spcSuper.Id_functor_app_actual;
Console.WriteLine("liftFunctorApp: 2" + (spcNew == null));
}
else if (spSuper is SupplyParameterParameter)
{
SupplyParameterParameter sppSuper = (SupplyParameterParameter)spSuper;
SupplyParameterParameter sppNew = new SupplyParameterParameter();
spNew = sppNew;
Console.WriteLine("liftFunctorApp: 3 " + (spNew == null) + " spp.Id_argument=" + spp.Id_argument + ", spp.Id_parameter=" + spp.Id_parameter);
sppNew.Id_functor_app = acfaNew.Id_functor_app;
sppNew.Id_abstract = spSuper.Id_abstract;
sppNew.Id_parameter = spp.Id_parameter;
sppNew.Id_argument = sppSuper.Id_argument;
sppNew.FreeVariable = spp.FreeVariable;
Console.WriteLine("liftFunctorApp: 4" + (sppNew == null));
}
else
{
Console.WriteLine("liftFunctorApp: 5 " + (spp.Id_argument));
}
}
else
{
Console.WriteLine("liftFunctorApp: 5 ");
SupplyParameterParameter sppSuper = (SupplyParameterParameter)spSuper;
SupplyParameterParameter sppNew = new SupplyParameterParameter();
spNew = sppNew;
sppNew.Id_argument = spp.Id_argument;
sppNew.FreeVariable = spp.FreeVariable;
sppNew.Id_functor_app = acfaNew.Id_functor_app;
sppNew.Id_abstract = acfaNew.Id_abstract;
sppNew.Id_parameter = spp.Id_parameter;
//sppNew.Id_parameter_actual = sppSuper.Id_parameter_actual;
//sppNew.FreeVariable = spp.FreeVariable;
}
}
br.ufc.pargo.hpe.backend.DGAC.BackEnd.spdao.insert(spNew);
}
return(acfaNew.Id_functor_app);
}
private void importInnerComponentsOfSuper(AbstractComponentFunctor absC, IList <InnerComponentType> includeAsInner)
{
Console.WriteLine("importInnerComponentsOfSupper : " + "START");
IDictionary <string, SupplyParameter> parsSuper = new Dictionary <string, SupplyParameter>();
// Inner components of the supertype.
if (absC.Id_functor_app_supertype > 0)
{
AbstractComponentFunctorApplication acfa = br.ufc.pargo.hpe.backend.DGAC.BackEnd.acfadao.retrieve(absC.Id_functor_app_supertype);
// It is a parameter in the subtype. Check if it is supplied in the type.
IList <SupplyParameter> spList = br.ufc.pargo.hpe.backend.DGAC.BackEnd.spdao.list(acfa.Id_functor_app);
foreach (SupplyParameter sp in spList)
{
Console.WriteLine("Adding to parSuper - key=" + sp.Id_parameter + ", value: " + sp.Id_functor_app + "/" + sp.Id_abstract + "/" + sp.Id_parameter);
parsSuper.Add(sp.Id_parameter, sp);
}
IList <InnerComponent> iss = br.ufc.pargo.hpe.backend.DGAC.BackEnd.icdao.list(acfa.Id_abstract);
Console.WriteLine("importInnerComponentsOfSuper: " + iss.Count + " - acfa.Id_abstract=" + acfa.Id_abstract);
foreach (InnerComponent i in iss) //if (!i.IsPublic)
{
Console.WriteLine("importInnerComponentsOfSupper 1: " + i.Id_inner + " , " + i.Id_functor_app + " , " + (i.Parameter_top));
InnerComponent iNew = new InnerComponent();
if (i.Parameter_top != null && i.Parameter_top != "")
{
SupplyParameter sp = null;
parsSuper.TryGetValue(i.Parameter_top, out sp);
Console.WriteLine("importInnerComponentsOfSupper 2: " + i.Parameter_top + "," + i.Id_inner);
if (sp is SupplyParameterComponent)
{
Console.WriteLine("importInnerComponentsOfSupper 3: " + "sp is SupplyParameterComponent");
// 1th CASE: It is not a parameter in the current component.
// NOT YET TESTED !!!
SupplyParameterComponent spc = (SupplyParameterComponent)sp;
AbstractComponentFunctorApplication acfaReplace = br.ufc.pargo.hpe.backend.DGAC.BackEnd.acfadao.retrieve(spc.Id_functor_app_actual);
if (br.ufc.pargo.hpe.backend.DGAC.BackEnd.icdao.retrieve(absC.Id_abstract, i.Id_inner) == null)
{
iNew.Id_abstract_inner = acfaReplace.Id_abstract;
//iNew.Parameter_top = i.Parameter_top; // TODO: Testando .........
iNew.Id_abstract_owner = absC.Id_abstract;
iNew.Id_functor_app = liftFunctorApp(acfaReplace.Id_functor_app, parsSuper);
iNew.Id_inner = i.Id_inner;
br.ufc.pargo.hpe.backend.DGAC.BackEnd.icdao.insert(iNew);
}
}
else if (sp is SupplyParameterParameter)
{
Console.WriteLine("importInnerComponentsOfSupper 4: " + "sp is SupplyParameterParameter");
// 2nd CASE: It continues to be a parameter in the current component.
SupplyParameterParameter spp = (SupplyParameterParameter)sp;
String varName = null;
foreach (ParameterRenaming pr in parameterRenamingSuper)
{
if (pr.formFieldId.Equals(i.Parameter_top))
{
varName = pr.varName;
ParameterType parameter = this.lookForParameterByVarName(varName);
InnerComponentType cReplace = lookForInnerComponent(parameter.componentRef);
//cReplace.localRef = i.Id_inner;
cReplace.exposed = i.IsPublic;
cReplace.multiple = i.Multiple;
// cReplace.parameter_id = i.Parameter_top; // TODO: Testano
includeAsInner.Add(cReplace);
}
}
ParameterSupplyType supply = lookForSupplyForVarName(varName);
if (supply != null)
{
InnerComponentType cReplace = lookForInnerComponent(supply.cRef);
if (cReplace != null)
{
includeAsInner.Add(cReplace);
}
}
}
}
else
{
// 3rd CASE:
// NOT YET TESTED !!!
iNew.Id_abstract_inner = i.Id_abstract_inner;
iNew.Parameter_top = null;
iNew.Id_abstract_owner = absC.Id_abstract;
iNew.Id_functor_app = liftFunctorApp(i.Id_functor_app, parsSuper);
iNew.Id_inner = i.Id_inner;
iNew.IsPublic = i.IsPublic;
br.ufc.pargo.hpe.backend.DGAC.BackEnd.icdao.insert(iNew);
}
}
}
Console.WriteLine("importInnerComponentsOfSuper : FINISH");
}
private InterfaceSignature calculateParameters(Interface i, IDictionary <string, int> closed_pars, IDictionary <string, string> open_pars)
{
// id_abstract, id_interface, partition_index, id_interface_super, partition_index_super, uri_source, class_nargs, id_interface_super_top, partition_index_super_top, order
// '43', 'compute_rhs', '0', '', '0', 'adi.ComputeRHS.IComputeRHS', '', '2', 'compute_rhs', '0', '1'
InterfaceSignature isig;
AbstractComponentFunctor acf = (AbstractComponentFunctor)BackEnd.acfdao.retrieve(i.Id_abstract);
isig.package_path = acf.Library_path;
isig.the_interface = i;
isig.parameters = new Dictionary <string, InterfaceSignature>();
isig.varId = new Dictionary <string, string>();
isig.slice_types = new Dictionary <string, InterfaceSignature>();
IList <Slice> slice_list = BackEnd.sdao.listByInterface(i.Id_abstract, i.Id_interface);
// id_abstract, id_inner, id_interface_slice, partition_index, id_interface, property_name, transitive
// '43', 'cells_info', 'cells', '0', 'compute_rhs', 'Cells', '0'
// '43', 'problem_data', 'problem', '0', 'compute_rhs', 'Problem', '0'
foreach (Slice s in slice_list)
{
InnerComponent ic = BackEnd.icdao.retrieve(s.Id_abstract, s.Id_inner);
// id_abstract_owner, id_functor_app, id_inner, id_abstract_inner, parameter_top, transitive, public
// 1st loop:
// '43', '131', 'cells_info', '31', '', '0', '-1'
// 2nd loop:
// '43', '132', 'problem_data', '40', '', '0', '-1'
int id_functor_app_actual = ic.Id_functor_app;
// 1st loop: id_functor_app_actual = 131
// 2nd loop: id_functor_app_actual = 132
Interface i_ = BackEnd.idao.retrieve(ic.Id_abstract_inner, s.Id_interface_slice);
// id_abstract, id_interface, partition_index, id_interface_super, partition_index_super, uri_source, class_nargs, id_interface_super_top, partition_index_super_top, order
// 1st loop:
// '31', 'cells', '0', '', '0', 'common.datapartition.MultiPartitionCells.ICells', '', '0', 'cells', '0', '1', NULL, NULL, NULL
// 2nd loop:
// '40', 'problem', '0', '', '0', 'adi.data.ProblemDefinition.IProblemDefinition', '', '2', 'problem', '0', '1', NULL, NULL, NULL
if (!ic.Parameter_top.Equals("")) // 1st loop: FALSE 2nd loop: FALSE
{
if (closed_pars.ContainsKey(ic.Parameter_top))
{
id_functor_app_actual = closed_pars[ic.Parameter_top];
}
InterfaceParameter ip = BackEnd.ipdao.retrieve(i.Id_abstract, i.Id_interface, ic.Parameter_top);
AbstractComponentFunctorApplication acfa = BackEnd.acfadao.retrieve(id_functor_app_actual);
i_ = BackEnd.idao.retrieveTop(acfa.Id_abstract, ip.Id_unit_parameter);
}
IList <string> parameters = new List <string>();
IDictionary <string, int> closed_pars_ = new Dictionary <string, int>();
IDictionary <string, string> open_pars_ = new Dictionary <string, string>();
IList <SupplyParameter> sp_list = BackEnd.spdao.list(id_functor_app_actual);
// id_parameter, id_functor_app, id_abstract
// 1st loop: empty
// 2nd loop:
// 'class', '132', '40'
// 'instance_type', '132', '40'
foreach (SupplyParameter sp in sp_list)
{
if (sp is SupplyParameterComponent) // always false
{
SupplyParameterComponent spc = (SupplyParameterComponent)sp;
if (!closed_pars_.ContainsKey(spc.Id_parameter))
{
closed_pars_.Add(spc.Id_parameter, spc.Id_functor_app_actual);
}
}
else if (sp is SupplyParameterParameter)
{
SupplyParameterParameter spp = (SupplyParameterParameter)sp;
// id_parameter, id_functor_app, id_parameter_actual, freeVariable
// 2nd outer loop / 1st inner loop:
// 'class', '132', 'class', '0'
// 2nd outer loop / 2nd inner loop
// 'instance_type', '132', 'instance_type', '0'
int id_functor_app_actual_parameter;
if (closed_pars.ContainsKey(spp.Id_argument)) // ALWAYS FALSE
{
id_functor_app_actual_parameter = closed_pars[spp.Id_argument];
if (!closed_pars_.ContainsKey(spp.Id_parameter))
{
closed_pars_.Add(spp.Id_parameter, id_functor_app_actual_parameter);
}
}
else if (open_pars.ContainsKey(spp.Id_argument))
{
if (!open_pars_.ContainsKey(spp.Id_parameter))
{
open_pars_.Add(spp.Id_parameter, open_pars[spp.Id_argument]);
}
// 2nd outer loop / 1st inner loop: add 'class' -> 'C'
// 2nd outer loop / 2nd inner loop: add 'instance_type' -> 'I'
}
else
{
// NEVER REACH THIS ARM ...
}
parameters.Add(spp.Id_parameter);
// 2nd outer loop / 1st inner loop: add 'class'
// 2nd outer loop / 2nd inner loop: add 'instance_type'
}
}
InterfaceSignature par_ic = calculateParameters(i_, closed_pars_, open_pars_);
if (!isig.slice_types.ContainsKey(s.PortName))
{
isig.slice_types.Add(s.PortName, par_ic);
}
else
{
Console.WriteLine("EXISTENTE {0}", s.PortName);
}
// 1st loop:
// InterfaceSignature [
// the_interface = ('31', 'cells', '0', '', '0', 'common.datapartition.MultiPartitionCells.ICells', '', '0', 'cells', '0', '1')
// parameters = {}
// parId = {}
// ]
// 2nd loop:
// InterfaceSignature [
// the_interface = ('40', 'problem', '0', '', '0', 'adi.data.ProblemDefinition.IProblemDefinition', '', '2', 'problem', '0', '1')
// parameters = {C -> InterfaceSignature [ IClass ... ] , I -> InterfaceSignature [ IInstance ... ]}
// parId = {C -> class, I -> instance_type}
// ]
foreach (KeyValuePair <string, InterfaceSignature> is_par in par_ic.parameters)
{
string par_id = is_par.Key;
// 2nd outer loop / 1st inner loop: var_id = C, par_id = class
// 2nd outer loop / 2nd inner loop: var_id = I, par_id = instance_type
if (parameters.Contains(par_id))
{
if (!isig.parameters.ContainsKey(par_id))
{
isig.parameters.Add(par_id, is_par.Value);
}
else
{
;
}
// 2nd outer loop / 1st inner loop: add (class, InterfaceSignature [ IClass ... ])
// 2nd outer loop / 2nd inner loop: add (instance_type, InterfaceSignature [ IInstance[C] ... ])
if (open_pars_.ContainsKey(par_id) && !isig.varId.ContainsKey(par_id))
{
isig.varId.Add(par_id, open_pars_[par_id]);
}
// 2nd outer loop / 1st inner loop: add (class, C)
// 2nd outer loop / 2nd inner loop: add (instance_type, I)
}
}
if (!ic.Parameter_top.Equals("")) // never
{
if (isig.parameters.ContainsKey(ic.Parameter_top))
{
isig.parameters.Remove(ic.Parameter_top);
}
isig.parameters.Add(ic.Parameter_top, par_ic);
if (open_pars.ContainsKey(ic.Parameter_top))
{
if (isig.varId.ContainsKey(ic.Parameter_top))
{
isig.varId.Remove(ic.Parameter_top);
}
isig.varId.Add(ic.Parameter_top, open_pars[ic.Parameter_top]);
}
}
}
return(isig);
}
