SProS.idl

Go to the documentation of this file.

#include "DOM_APISPEC.idl"
#include "MathML_content_APISPEC.idl"

module SProS
{
  interface Base;
  interface BaseSet;
  interface BaseIterator;
  interface SEDMLElement;
  interface NamedElement;
  interface NamedElementSet;
  interface NamedElementIterator;
  interface NamedIdentifiedElement;
  interface NamedIdentifiedElementSet;
  interface NamedIdentifiedElementIterator;
  interface Model;
  interface ModelSet;
  interface ModelIterator;
  interface Simulation;
  interface SimulationSet;
  interface SimulationIterator;
  interface UniformTimeCourse;
  interface Task;
  interface TaskSet;
  interface TaskIterator;
  interface DataGenerator;
  interface DataGeneratorSet;
  interface DataGeneratorIterator;
  interface Output;
  interface OutputSet;
  interface OutputIterator;
  interface Plot2D;
  interface Plot3D;
  interface Report;
  interface Change;
  interface ChangeSet;
  interface ChangeIterator;
  interface ComputeChange;
  interface ChangeAttribute;
  interface AddXML;
  interface ChangeXML;
  interface RemoveXML;
  interface Variable;
  interface VariableSet;
  interface VariableIterator;
  interface Parameter;
  interface ParameterSet;
  interface ParameterIterator;
  interface Curve;
  interface CurveSet;
  interface CurveIterator;
  interface Surface;
  interface SurfaceSet;
  interface SurfaceIterator;
  interface DataSet;
  interface DataSetSet;
  interface DataSetIterator;

  interface Bootstrap
    : XPCOM::IObject
  {
    SEDMLElement createEmptySEDML();

    SEDMLElement parseSEDMLFromURI(in wstring uri, in wstring relativeTo);

    SEDMLElement parseSEDMLFromText(in wstring txt, in wstring baseURI);

    SEDMLElement makeSEDMLFromElement(in dom::Element el);

    wstring sedmlToText(in SEDMLElement el);
  };

  interface Base
    : XPCOM::IObject
  {
    readonly attribute dom::Element domElement;

    readonly attribute dom::NodeList notes;

    readonly attribute dom::NodeList annotations;

    readonly attribute Base parent;
  };

  exception SProSException
  {
  };

  interface BaseSet
    : XPCOM::IObject
  {
    BaseIterator iterateElements();

    void insert(in Base b) raises(SProSException);

    void remove(in Base b);
  };

  interface BaseIterator
    : XPCOM::IObject
  {
    Base nextElement();
  };

  interface SEDMLElement
    : Base
  {
    attribute unsigned long level;
    
    attribute unsigned long version;

    readonly attribute ModelSet models;

    readonly attribute TaskSet tasks;

    readonly attribute SimulationSet simulations;

    readonly attribute DataGeneratorSet generators;

    readonly attribute OutputSet outputs;

    Model createModel();

    UniformTimeCourse createUniformTimeCourse();

    Task createTask();

    DataGenerator createDataGenerator();

    Plot2D createPlot2D();

    Plot3D createPlot3D();

    Report createReport();

    ComputeChange createComputeChange();

    ChangeAttribute createChangeAttribute();

    AddXML createAddXML();

    RemoveXML createRemoveXML();

    ChangeXML createChangeXML();

    Variable createVariable();

    Parameter createParameter();

    Curve createCurve();

    Surface createSurface();

    DataSet createDataSet();
  };

  interface NamedElement
    : Base
  {
    attribute wstring name;
  };

  interface NamedElementSet
    : BaseSet
  {
    NamedElementIterator iterateNamedElement();

    /* Note: Names aren't guaranteed to be unique, they are for human use, so
     * we don't provide a way to find by name.
     */
  };

  interface NamedElementIterator
    : BaseIterator
  {
    NamedElement nextNamedElement();
  };

  interface NamedIdentifiedElement
    : NamedElement
  {
    attribute wstring id;
  };

  interface NamedIdentifiedElementSet
    : NamedElementSet
  {
    NamedIdentifiedElementIterator iterateNamedIdentifiedElements();

    NamedIdentifiedElement getNamedIdentifiedElementByIdentifier(in wstring idMatch);
  };

  interface NamedIdentifiedElementIterator
    : NamedElementIterator
  {
    NamedIdentifiedElement nextNamedIdentifiedElement();
  };

  interface Model
    : NamedIdentifiedElement
  {
    attribute wstring language;

    attribute wstring source;

    readonly attribute ChangeSet changes;
  };

  interface ModelSet
    : NamedIdentifiedElementSet
  {
    ModelIterator iterateModels();

    Model getModelByIdentifier(in wstring idMatch);
  };

  interface ModelIterator
    : NamedIdentifiedElementIterator
  {
    Model nextModel();
  };

  interface Simulation
    : NamedIdentifiedElement
  {
    attribute wstring algorithmKisaoID;
  };

  interface SimulationSet
    : NamedIdentifiedElementSet
  {
    SimulationIterator iterateSimulations();

    Simulation getSimulationByIdentifier(in wstring idMatch);
  };

  interface SimulationIterator
    : NamedIdentifiedElementIterator
  {
    Simulation nextSimulation();
  };

  interface UniformTimeCourse
    : Simulation
  {
    attribute double initialTime;

    attribute double outputStartTime;

    attribute double outputEndTime;

    attribute unsigned long numberOfPoints;
  };

  interface Task
    : NamedIdentifiedElement
  {
    attribute wstring simulationReferenceIdentifier;

    attribute Simulation simulationReference;

    attribute wstring modelReferenceIdentifier;

    attribute Model modelReference;
  };

  interface TaskSet
    : NamedIdentifiedElementSet
  {
    TaskIterator iterateTasks();

    Task getTaskByIdentifier(in wstring idMatch);
  };

  interface TaskIterator
    : NamedIdentifiedElementIterator
  {
    Task nextTask();
  };

  interface DataGenerator
    : NamedIdentifiedElement
  {
    readonly attribute ParameterSet parameters;

    readonly attribute VariableSet variables;

    attribute mathml_dom::MathMLMathElement math;
  };

  interface DataGeneratorSet
    : NamedIdentifiedElementSet
  {
    DataGeneratorIterator iterateDataGenerators();

    DataGenerator getDataGeneratorByIdentifier(in wstring idMatch);
  };

  interface DataGeneratorIterator
    : NamedIdentifiedElementIterator
  {
    DataGenerator nextDataGenerator();
  };

  interface Output
    : NamedIdentifiedElement
  {
  };

  interface OutputSet
    : NamedIdentifiedElementSet
  {
    OutputIterator iterateOutputs();
    
    Output getOutputByIdentifier(in wstring idMatch);
  };

  interface OutputIterator
    : NamedIdentifiedElementIterator
  {
    Output nextOutput();
  };

  interface Plot2D
    : Output
  {
    readonly attribute CurveSet curves;
  };

  interface Plot3D
    : Output
  {
    readonly attribute SurfaceSet surfaces;
  };

  interface Report
    : Output
  {
    readonly attribute DataSetSet datasets;
  };

  interface Change
    : Base
  {
    attribute wstring target;
  };

  interface ChangeSet
    : BaseSet
  {
    ChangeIterator iterateChanges();
  };

  interface ChangeIterator
    : BaseIterator
  {
    Change nextChange();
  };

  interface ComputeChange
    : Change
  {
    readonly attribute VariableSet variables;

    readonly attribute ParameterSet parameters;

    attribute mathml_dom::MathMLMathElement math;
  };

  interface ChangeAttribute
    : Change
  {
    readonly attribute wstring newValue;
  };

  interface AddXML
    : Change
  {
    readonly attribute dom::NodeList anyXML;
  };

  interface ChangeXML
    : AddXML
  {
  };

  interface RemoveXML
    : Change
  {
  };

  interface Variable
    : NamedIdentifiedElement
  {
    attribute wstring target;

    attribute wstring symbol;

    attribute wstring taskReferenceID;

    attribute Task taskReference;
  };

  interface VariableSet
    : NamedIdentifiedElementSet
  {
    VariableIterator iterateVariables();

    Variable getVariableByIdentifier(in wstring idMatch);
  };

  interface VariableIterator
    : NamedIdentifiedElementIterator
  {
    Variable nextVariable();
  };

  interface Parameter
    : NamedIdentifiedElement
  {
    attribute double value;
  };

  interface ParameterSet
    : NamedIdentifiedElementSet
  {
    ParameterIterator iterateParameters();

    Parameter getParameterByIdentifier(in wstring idMatch);
  };

  interface ParameterIterator
    : NamedIdentifiedElementIterator
  {
    Parameter nextParameter();
  };

  interface Curve
    : NamedElement
  {
    attribute boolean logX;

    attribute boolean logY;

    attribute wstring xDataGeneratorID;

    attribute wstring yDataGeneratorID;

    attribute DataGenerator xDataGenerator;

    attribute DataGenerator yDataGenerator;
  };

  interface CurveSet
    : NamedElementSet
  {
    CurveIterator iterateCurves();
  };

  interface CurveIterator
    : NamedElementIterator
  {
    Curve nextCurve();
  };

  interface Surface
    : Curve
  {
    attribute boolean logZ;

    attribute wstring zDataGeneratorID;

    attribute DataGenerator zDataGenerator;
  };

  interface SurfaceSet
    : CurveSet
  {
    SurfaceIterator iterateSurfaces();
  };

  interface SurfaceIterator
    : CurveIterator
  {
    Surface nextSurface();
  };

  interface DataSet
    : NamedElement
  {
    attribute wstring dataGeneratorID;

    attribute DataGenerator dataGen;
  };

  interface DataSetSet
    : NamedElementSet
  {
    DataSetIterator iterateDataSets();
  };

  interface DataSetIterator
    : NamedElementIterator
  {
    DataSet nextDataSet();
  };
};