@Override
public Parameter[] getOutputParameter() {
Parameter[] temp = new SingleParameter[AddVectorIntClosure.getOutputSinglePortNames().length];
for (int i = 0; i < AddVectorIntClosure.getOutputSinglePortNames().length; i++) {
SingleParameter p = this.OutputPorts[i].getSignal();
if (p != null) {
temp[i] = p;
} else {
System.out.println(
"Closure not correctly initialized: the parameter on port "
+ this.getOutputSinglePortNames()[i]
+ " = null!");
}
}
return temp;
}
public String printClosure() {
String temp = "";
temp = temp + "Closure:\n";
temp = temp + "URI: " + this.getURI();
temp = temp + "Name: " + this.getName();
temp = temp + "input ports:\n";
for (int i = 0; i < AddVectorIntClosure.getInputVectorPortNames().length; i++) {
temp =
temp
+ ("port index = "
+ i
+ " + name = "
+ InputPortsVec[i]
+ "URI= "
+ this.InputPortsVec[i].getURI()
+ "\n");
temp =
temp
+ ("parameter URI: "
+ this.InputPortsVec[i].getSignal().getURI()
+ " ParameterValid: "
+ this.InputPortsVec[i].getSignal().getValid()
+ "\n");
}
temp = temp + "output ports:\n";
for (int i = 0; i < AddVectorIntClosure.getOutputSinglePortNames().length; i++) {
temp =
temp
+ ("port index = "
+ i
+ " + name = "
+ this.OutputPorts[i]
+ "URI= "
+ this.OutputPorts[i].getURI()
+ "\n");
temp =
temp
+ ("parameter URI: "
+ this.OutputPorts[i].getSignal().getURI()
+ " ParameterValue: "
+ this.OutputPorts[i].getSignal().getValueForTriple()
+ "ParameterValid "
+ this.OutputPorts[i].getSignal().getValid()
+ "\n");
}
return temp;
}
@Override
public Parameter[] getInputParameter() {
Parameter[] temp =
new Parameter
[AddVectorIntClosure.getInputVectorPortNames()
.length]; // in general + the single port + the functional port
for (int i = 0; i < AddVectorIntClosure.getInputVectorPortNames().length; i++) {
Parameter p = this.InputPortsVec[i].getSignal();
if (p != null) {
temp[i] = p;
} else {
System.out.println(
"Closure not correctly initialized: the parameter on port "
+ getInputVectorPortNames()[i]
+ " = null!");
}
}
return temp;
}
public void InitializeAddVectorIntClosure(
Vector<String[]> VectorValues,
VectorParameter[] inputVectorParameter,
VectorParameter[] outputVectorParameter,
String[] Singlevalues,
SingleParameter[] inputSingleParameter,
SingleParameter[] outputSingleParameter) {
// two input parameters can be removed, are here to be copied in some reference complete file
// about a general closure
// //Single input :
// SingleParameter p, pout;
// for(int i = 0; i < AddVectorIntClosure.InputSinglePortNames.length;i++)
// {
// p = new SingleParameter();
// if(inputSingleParameter[i]==null)//If I have not a parameter in this constructor I create
// one random
// {
//
//
// p.setURI(UUID.randomUUID().toString());
// p.setType(InputSinglePortTypes[i]);//TypeCheck needed?
// if (!Singlevalues[i].equals(null)) //If I know the value of the parameter I set the value
// and I put Valid == true
// {
// p.setValue(Singlevalues[i]);
// p.setValid(true);
// }
// else //The parameter has not a constant value to be assigned
// {
// p.setValid(false);
// }
//
// }
// else//I have a parameter in the constructor and I use it
// {
// /*
// * Here I consider that who calls this initialization gives me the values of the inputs
// and the references in the
// * the parameters, the initialization assigns the value to the parameters
// * */
// p = inputSingleParameter[i];
// if (!(Singlevalues[i] == null)) //If I know the value of the parameter I set the value
// and I put Valid == true
// {
// p.setValue(Singlevalues[i]);
// p.setValid(true);
// }
// else //The parameter has not a constant value to be assigned
// {
// p.setValid(false);
// }
// }
//
//
//
//
// /*
// * Now p1 can be:
// * 1) random with assigned value and valid
// * 2) random without value and invalid
// * 3) not random with assigned value and true
// * 4) not random witout value and invalid
// * At moment these are all the situations managed
// */
// InputPorts[i].setSignal(p);
// p.addInputToAtomicClosure(this);
// }
//
// Single out
SingleParameter pout;
for (int i = 0; i < AddVectorIntClosure.getOutputSinglePortNames().length; i++) {
if (outputSingleParameter.equals(
null)) // If I have not an output parameter from the constructor (so no reference) I
// create one Randomly
{
pout = new SingleParameter();
pout.setURI(UUID.randomUUID().toString());
pout.setType(OutputSinglePortTypes[i]);
} else {
pout = outputSingleParameter[i];
pout.setType(
OutputSinglePortTypes[i]); // Unuseful if we suppose to pass the right reference
}
this.OutputPorts[i].setSignal(pout);
pout.setWritingAtomicClosure(this);
}
// Vector input
VectorParameter p_v;
for (int i = 0; i < AddVectorIntClosure.getInputVectorPortNames().length; i++) {
p_v = new VectorParameter();
if ((inputVectorParameter == null)
|| (inputVectorParameter[i]
== null)) // If I have not a parameter in this constructor I create one random
{
p_v.setRandomURI();
p_v.setType(InputVectorPortTypes[i]); // TypeCheck needed?
if (!(VectorValues.elementAt(i)
== null)) // If I know the value of the parameter I set the value and I put Valid ==
// true
{
p_v.setContent(VectorValues.elementAt(i), AddVectorIntClosure.InputVectorPortTypes[i]);
p_v.setValid(true);
} else // The parameter has not a constant value to be assigned pr it is just ready
{
p_v.setValid(false);
}
} else // I have a parameter in the constructor and I use it
{
/*
* Here I consider that who calls this initialization gives me the values of the inputs and the references in the
* the parameters, the initialization assigns the value to the parameters
* */
p_v = (inputVectorParameter[i]);
Logger.printFile(
"I have given the the following URI to the input: " + p_v.getURI() + "\n",
DebugFileName);
if ((VectorValues != null)
&& (VectorValues.elementAt(i)
!= null)) // If I know the value of the parameter I set the value and I put Valid
// == true
{
p_v.setContent(VectorValues.elementAt(i), AddVectorIntClosure.InputVectorPortTypes[i]);
p_v.setValid(true);
} else // The parameter has not a constant value to be assigned ot it is ready
{
if (!p_v.getValid()) {
p_v.setValid(false);
}
}
}
/*
* Now p1 can be:
* 1) random with assigned value and valid
* 2) random without value and invalid
* 3) not random with assigned value and true
* 4) not random witout value and invalid
* At moment these are all the situations managed
*/
InputPortsVec[i].setSignal(p_v);
Logger.printFile(
"Final URI of the input of the closure before serialization: "
+ InputPortsVec[0].getSignal().getURI()
+ "\n",
DebugFileName);
p_v.addInputToAtomicClosure(this);
}
// //output Vector
// VectorParameter pout_v;
// for(int i = 0; i < AddVectorIntClosure.OutputPortNamesVec;i++)
// {
// if (outputVectorParameter.equals(null))//If I have not an output parameter from the
// constructor (so no reference) I create one Randomly
// {
// pout_v = new VectorParameter();
// pout_v.setRandomURI();
// pout.setType(OutputPortTypesVec[i]);
// }
// else
// {
// pout = outputVectorParameter[i];
// }
// this.OutputPorts[i].setSignal(pout);
// pout.setWritingAtomicClosure(this);
// }
//
}
// Some rdf:type declarations are not so useful, but I leave them at moment
// Some of the triples seems to be redundant, but this is not an optimized version.
public Vector<Vector<String>> SerializeTriples() {
Logger.printFile(this.printClosure(), DebugFileName);
// String[] InPortParURI = new String[AddVectorIntClosure.InputPortNames.length];
// for(int i = 0; i < AddIntClosure.InputPortNames.length; i++)
// {
// InPortParURI[i] = this.InputPorts[i].getSignal().getURI();;
// }
// String[] InPortVectorParURI = new
// String[AddVectorIntClosure.getInputVectorPortNames().length];
// for(int i = 0; i < AddVectorIntClosure.getInputVectorPortNames().length; i++)
// {
// InPortVectorParURI[i] = this.InputPortsVec[i].getSignal().getURI();;
// }
// Triples
SSAP_XMLTools xmlTools = new SSAP_XMLTools(null, null, null);
Vector<Vector<String>> triples = new Vector<Vector<String>>();
triples.add(
xmlTools.newTriple(
this.URI, OntologyVocabulary.type, OntologyVocabulary.AtomicClosure, "URI", "URI"));
triples.add(
xmlTools.newTriple(
this.URI,
OntologyVocabulary.ClosureHasName,
OntologyVocabulary.AddVectorIntClosure,
"URI",
"URI"));
triples.add(
xmlTools.newTriple(
this.URI,
OntologyVocabulary.ComputationHasFunctionalBehaviour,
OntologyVocabulary.AddVectorIntClosure,
"URI",
"URI"));
for (int i = 0; i < AddVectorIntClosure.getInputVectorPortNames().length; i++) {
triples.add(
xmlTools.newTriple(
this.URI,
OntologyVocabulary.ClosureHasInputPort,
this.InputPortsVec[i].getURI(),
"URI",
"URI"));
triples = TriplesUtilities.concatTriples(triples, this.InputPortsVec[i].getTriples());
}
for (int i = 0; i < AddVectorIntClosure.getOutputSinglePortNames().length; i++) {
triples.add(
xmlTools.newTriple(
this.URI,
OntologyVocabulary.ClosureHasOutputPort,
this.OutputPorts[i].getURI(),
"URI",
"URI"));
triples = TriplesUtilities.concatTriples(triples, this.OutputPorts[i].getTriples());
}
// for(int i = 0; i < AddIntClosure.InputPortNames.length; i++)
// {
// triples.add(xmlTools.newTriple(inputPortsURI[i],
// OntologyVocabulary.type,OntologyVocabulary.InputPort, "URI", "URI"));
// triples.add(xmlTools.newTriple(this.URI, OntologyVocabulary.ClosureHasInputPort,
// inputPortsURI[i], "URI", "URI"));
// triples.add(xmlTools.newTriple(inputPortsURI[i],
// OntologyVocabulary.PortHasDatatype,AddIntClosure.InputPortTypes[i], "URI", "literal"));
// triples.add(xmlTools.newTriple(inputPortsURI[i],
// OntologyVocabulary.PortHasName,AddIntClosure.InputPortNames[i], "URI", "literal"));
// triples.add(xmlTools.newTriple(InPortParURI[i], OntologyVocabulary.type,
// OntologyVocabulary.Parameter, "URI", "URI"));
// triples.add(xmlTools.newTriple(inputPortsURI[i],
// OntologyVocabulary.PortAttachedToPar,InPortParURI[i] , "URI", "URI"));
// triples.add(xmlTools.newTriple(InPortParURI[i], OntologyVocabulary.ParHasDatatype,
// AddIntClosure.InputPortTypes[i], "URI", "literal"));
// if(this.InputPorts[i].getSignal().getValid())
// {
// triples.add(xmlTools.newTriple(InPortParURI[i], OntologyVocabulary.ParHasValue,
// this.InputPorts[i].getSignal().getValueForTriple(), "URI", "literal"));
// triples.add(xmlTools.newTriple(InPortParURI[i], OntologyVocabulary.ParIsValid,
// OntologyVocabulary.ValidParameter, "URI", "literal"));
// }
// else
// {
// triples.add(xmlTools.newTriple(InPortParURI[i], OntologyVocabulary.ParIsValid,
// OntologyVocabulary.InvalidParameter, "URI", "literal"));
// }
// }
// // triples.add(xmlTools.newTriple(InPort2Uri,
// OntoloogyVocabulary.type,OntoloogyVocabulary.InputPort, "URI", "URI"));
// // triples.add(xmlTools.newTriple(this.URI, OntoloogyVocabulary.ClosureHasInputPort,
// InPort2Uri, "URI", "URI"));
// // triples.add(xmlTools.newTriple(InPort2Uri,
// OntoloogyVocabulary.PortHasType,AddIntClosure.InputPort2Type, "URI", "literal"));
// // triples.add(xmlTools.newTriple(InPort2Uri,
// OntoloogyVocabulary.PortHasName,AddIntClosure.InputPort2Name, "URI", "literal"));
// for(int i = 0; i < AddIntClosure.OutputPortNames.length; i++)
// {
// triples.add(xmlTools.newTriple(outputPortsURI[i],
// OntologyVocabulary.type,OntologyVocabulary.OutputPort, "URI", "URI"));
// triples.add(xmlTools.newTriple(this.URI, OntologyVocabulary.ClosureHasOutputPort,
// outputPortsURI[i], "URI", "URI"));
// triples.add(xmlTools.newTriple(outputPortsURI[i],
// OntologyVocabulary.PortHasDatatype,AddIntClosure.OutputPortTypes[i], "URI", "literal"));
// triples.add(xmlTools.newTriple(outputPortsURI[i],
// OntologyVocabulary.PortHasName,AddIntClosure.OutputPortNames[i], "URI", "literal"));
//
// triples.add(xmlTools.newTriple(OutPortParURI[i], OntologyVocabulary.type,
// OntologyVocabulary.Parameter, "URI", "URI"));
// triples.add(xmlTools.newTriple(outputPortsURI[i], OntologyVocabulary.PortAttachedToPar,
// OutPortParURI[i], "URI", "URI"));
// triples.add(xmlTools.newTriple(OutPortParURI[i], OntologyVocabulary.ParHasDatatype,
// AddIntClosure.OutputPortTypes[i], "URI", "literal"));
// if(this.OutputPorts[0].getSignal().getValid())
// {
// triples.add(xmlTools.newTriple(OutPortParURI[i], OntologyVocabulary.ParHasValue,
// this.OutputPorts[i].getSignal().getValueForTriple(), "URI", "literal"));
// triples.add(xmlTools.newTriple(OutPortParURI[i], OntologyVocabulary.ParIsValid,
// OntologyVocabulary.ValidParameter, "URI", "literal"));
// }
// else
// {
// triples.add(xmlTools.newTriple(OutPortParURI[i], OntologyVocabulary.ParIsValid,
// OntologyVocabulary.InvalidParameter, "URI", "literal"));
// }
// }
// This prints the triples in the debug file
Logger.printFile(
"Writing Closure triples\n" + "Closure: " + this.getURI() + "\n" + "Triples:\n",
DebugFileName);
for (int i = 0; i < triples.size(); i++) {
Vector<String> Triple = triples.elementAt(i);
{
Logger.printFile(
"sub = "
+ Triple.elementAt(0)
+ "; pred = "
+ Triple.elementAt(1)
+ "; obj = "
+ Triple.elementAt(2)
+ ";\n",
DebugFileName);
}
}
return triples;
// triples.add(xmlTools.newTriple(InPort1ParURI, OntoloogyVocabulary.type,
// OntoloogyVocabulary.Parameter, "URI", "URI"));
// triples.add(xmlTools.newTriple(InPort1ParURI, OntoloogyVocabulary.ParAttachedToPort,
// InPort1Uri, "URI", "URI"));
// triples.add(xmlTools.newTriple(InPort1ParURI, OntoloogyVocabulary.ParHasType,
// AddIntClosure.InputPort1Type, "URI", "literal"));
// if(this.InputPorts[0].getSignal().getValid())
// {
// triples.add(xmlTools.newTriple(InPort1ParURI, OntoloogyVocabulary.ParHasValue,
// this.InputPorts[0].getSignal().getValueForTriple(), "URI", "literal"));
// triples.add(xmlTools.newTriple(InPort1ParURI, OntoloogyVocabulary.ParIsValid, "true",
// "URI", "Literal"));
// }
// else
// {
// triples.add(xmlTools.newTriple(InPort1ParURI, OntoloogyVocabulary.ParIsValid, "false",
// "URI", "Literal"));
// }
//
// triples.add(xmlTools.newTriple(InPort2ParURI, OntoloogyVocabulary.type,
// OntoloogyVocabulary.Parameter, "URI", "URI"));
// triples.add(xmlTools.newTriple(InPort2ParURI, OntoloogyVocabulary.ParAttachedToPort,
// InPort2Uri, "URI", "URI"));
// triples.add(xmlTools.newTriple(InPort2ParURI, OntoloogyVocabulary.ParHasType,
// AddIntClosure.InputPort2Type, "URI", "literal"));
// if(this.InputPorts[1].getSignal().getValid())
// {
// triples.add(xmlTools.newTriple(InPort2ParURI, OntoloogyVocabulary.ParHasValue,
// this.InputPorts[1].getSignal().getValueForTriple(), "URI", "literal"));
// triples.add(xmlTools.newTriple(InPort2ParURI, OntoloogyVocabulary.ParIsValid, "true",
// "URI", "Literal"));
// }
// else
// {
// triples.add(xmlTools.newTriple(InPort2ParURI, OntoloogyVocabulary.ParIsValid, "false",
// "URI", "Literal"));
// }
// triples.add(xmlTools.newTriple(OutPortParURI, OntoloogyVocabulary.type,
// OntoloogyVocabulary.Parameter, "URI", "URI"));
// triples.add(xmlTools.newTriple(OutPortParURI, OntoloogyVocabulary.ParAttachedToPort,
// OutPortUri, "URI", "URI"));
// triples.add(xmlTools.newTriple(OutPortParURI, OntoloogyVocabulary.ParHasType,
// AddIntClosure.OutputPortType, "URI", "literal"));
// if(this.OutputPorts[0].getSignal().getValid())
// {
// triples.add(xmlTools.newTriple(OutPortParURI, OntoloogyVocabulary.ParHasValue,
// this.OutputPorts[0].getSignal().getValueForTriple(), "URI", "literal"));
// triples.add(xmlTools.newTriple(OutPortParURI, OntoloogyVocabulary.ParIsValid, "true",
// "URI", "Literal"));
// }
// else
// {
// triples.add(xmlTools.newTriple(OutPortParURI, OntoloogyVocabulary.ParIsValid, "false",
// "URI", "Literal"));
// }
}