@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")); // } }