CellML_APISPEC.idl

Go to the documentation of this file.

#ifndef INCLUDED_CELLML_APISPEC
#define INCLUDED_CELLML_APISPEC

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

module cellml_api
{
  /* Forward definitions... */
  interface Model;
  interface Group;
  interface MapComponents;
  interface CellMLComponent;
  interface ImportComponent;
  interface ImportUnits;
  interface Units;
  interface Unit;
  interface CellMLImport;
  interface CellMLVariable;
  interface ComponentRef;
  interface RelationshipRef;
  interface Connection;
  interface MapVariables;
  interface Reaction;
  interface ReactionSet;
  interface VariableRef;
  interface Role;
  interface ExtensionElementList;
  interface ExtensionAttributeSet;
  interface MathList;
  interface ModelSet;
  interface CellMLElementSet;
  interface CellMLComponentSet;
  interface ImportComponentSet;
  interface CellMLVariableSet;
  interface UnitsSet;
  interface CellMLImportSet;
  interface ImportUnitsSet;
  interface UnitSet;
  interface ConnectionSet;
  interface GroupSet;
  interface RelationshipRefSet;
  interface ComponentRefSet;
  interface MapVariablesSet;
  interface VariableRefSet;
  interface RoleSet;

  typedef dom::Element ExtensionElement;

  typedef wstring CellMLAttributeString;

  typedef mathml_dom::MathMLElement MathMLElement;

  interface RDFRepresentation : XPCOM::IObject
  {
    readonly attribute wstring type;
  };

  interface RDFXMLDOMRepresentation : RDFRepresentation
  {
    attribute dom::Document data;
  };
#pragma terminal-interface

  interface RDFXMLStringRepresentation : RDFRepresentation
  {
    attribute wstring serialisedData;
  };
#pragma terminal-interface

  interface UserData : XPCOM::IObject
  {
  };
#ifdef USERDATA_NEEDED
#pragma every-module
#endif
#pragma cross-module-inheritance
#pragma user-callback

  interface ImportInstantiationListener : XPCOM::IObject
  {
    void loadCompleted(in boolean wasStale);
  };
#pragma terminal-interface

  exception CellMLException{};

  interface URI : XPCOM::IObject
  {
    attribute wstring asText;
  };
#pragma terminal-interface

  interface CellMLElement : XPCOM::IObject
  {
    readonly attribute CellMLAttributeString cellmlVersion;

    attribute CellMLAttributeString cmetaId;

    readonly attribute ExtensionElementList extensionElements;

    void insertExtensionElementAfter(in ExtensionElement marker, in ExtensionElement newEl);

    void appendExtensionElement(in ExtensionElement x);

    void prependExtensionElement(in ExtensionElement x);

    void removeExtensionElement(in ExtensionElement x);

    void replaceExtensionElement(in ExtensionElement x, in ExtensionElement y);

    void clearExtensionElements();

    readonly attribute CellMLElementSet childElements;

    void addElement(in CellMLElement x) raises(CellMLException);

    void removeElement(in CellMLElement x);

    void replaceElement(in CellMLElement x, in CellMLElement y)
      raises(CellMLException);

    void removeByName(in CellMLAttributeString type,
                      in CellMLAttributeString name);

    readonly attribute CellMLElement parentElement;

    readonly attribute Model modelElement;

    void setUserData(in wstring key, in UserData data);

    UserData getUserData(in wstring key) raises(CellMLException);

    UserData getUserDataWithDefault(in wstring key, in UserData defval) raises(CellMLException);


    CellMLElement clone(in boolean deep);

    wstring getExtensionAttributeNS(in wstring ns, in wstring localName);

    void setExtensionAttributeNS(in wstring ns, in wstring qualifiedName, in wstring value);

    void removeExtensionAttributeNS(in wstring ns, in wstring localName);

    readonly attribute ExtensionAttributeSet extensionAttributes;
  };

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

    CellMLElement findCellMLElementFromDOMElement(in dom::Element x);
  };

  interface NamedCellMLElement
    : CellMLElement
  {
    attribute CellMLAttributeString name;
  };

  interface Model
    : NamedCellMLElement
  {
    Model getAlternateVersion(in wstring cellmlVersion) raises(CellMLException);
    
    readonly attribute GroupSet groups;

    readonly attribute CellMLImportSet imports;

    readonly attribute URI base_uri;

    readonly attribute UnitsSet localUnits;

    readonly attribute UnitsSet modelUnits;

    readonly attribute UnitsSet allUnits;

    readonly attribute CellMLComponentSet localComponents;

    readonly attribute CellMLComponentSet modelComponents;

    readonly attribute CellMLComponentSet allComponents;

    readonly attribute ConnectionSet connections;

    GroupSet findGroupsWithRelationshipRefName(in CellMLAttributeString name);

    void fullyInstantiateImports();

    void asyncFullyInstantiateImports(in ImportInstantiationListener listener);

    CellMLComponent createComponent();

    ImportComponent createImportComponent();

    Units createUnits();

    ImportUnits createImportUnits();

    Unit createUnit();

    CellMLImport createCellMLImport();

    CellMLVariable createCellMLVariable();

    ComponentRef createComponentRef();

    RelationshipRef createRelationshipRef();

    Group createGroup();

    Connection createConnection();

    MapVariables createMapVariables();

    Reaction createReaction();

    VariableRef createVariableRef();

    Role createRole();

    mathml_dom::MathMLMathElement createMathElement();

    dom::Element createExtensionElement(in dom::DOMString namespaceURI,
                                        in dom::DOMString qualifiedName);

    readonly attribute dom::DOMString serialisedText;


    RDFRepresentation getRDFRepresentation(in wstring type) raises(CellMLException);


    Model cloneAcrossImports() raises(CellMLException);

    readonly attribute URI xmlBase;

    void clearXMLBase();
  };
#pragma terminal-interface
#pragma cross-module-argument

  interface MathContainer : XPCOM::IObject
  {
    readonly attribute MathList math;

    void addMath(in MathMLElement x) raises(CellMLException);

    void removeMath(in MathMLElement x) raises(CellMLException);

    void replaceMath(in MathMLElement x, in MathMLElement y);

    void clearMath();
  };

  interface CellMLComponent
    : NamedCellMLElement, MathContainer
  {
    readonly attribute CellMLVariableSet variables;

    readonly attribute UnitsSet units;

    readonly attribute ConnectionSet connections;
    
    readonly attribute CellMLComponent encapsulationParent;

    readonly attribute CellMLComponentSet encapsulationChildren;

    readonly attribute CellMLComponent containmentParent;

    readonly attribute CellMLComponentSet containmentChildren;

    readonly attribute ReactionSet reactions;

    readonly attribute unsigned long importNumber;
  };

  interface Units
    : NamedCellMLElement
  {
    attribute boolean isBaseUnits;

    readonly attribute UnitSet unitCollection;
  };

  interface Unit
    : CellMLElement
  {
    attribute long prefix;

    attribute double multiplier;

    attribute double offset;

    attribute double exponent;

    attribute CellMLAttributeString units;
  };
#pragma terminal-interface

  interface CellMLImport
    : CellMLElement
  {
    readonly attribute URI xlinkHref;

    readonly attribute ImportComponentSet components;

    readonly attribute ImportUnitsSet units;

    readonly attribute ConnectionSet importedConnections;

    void instantiate();

    void asyncInstantiate(in ImportInstantiationListener listener);

    void instantiateFromText(in dom::DOMString xmlText)
      raises(CellMLException);

    readonly attribute boolean wasInstantiated;

    readonly attribute unsigned long uniqueIdentifier;


    readonly attribute Model importedModel;

    void uninstantiate();
  };
#pragma terminal-interface

  interface ImportComponent
    : CellMLComponent
  {
    attribute CellMLAttributeString componentRef;
  };
#pragma terminal-interface

  interface ImportUnits
    : Units
  {
    attribute CellMLAttributeString unitsRef;
  };
#pragma terminal-interface

  enum VariableInterface
  {
    INTERFACE_IN,
    INTERFACE_OUT,
    INTERFACE_NONE
  };

  interface CellMLVariable
    : NamedCellMLElement
  {
    attribute CellMLAttributeString initialValue;

    readonly attribute boolean initialValueFromVariable;

    attribute CellMLVariable initialValueVariable;

    attribute double initialValueValue;

    attribute VariableInterface privateInterface;

    attribute VariableInterface publicInterface;

    readonly attribute CellMLVariableSet connectedVariables;

    readonly attribute CellMLVariable sourceVariable;

    readonly attribute CellMLAttributeString componentName;

    attribute CellMLAttributeString unitsName;

    attribute Units unitsElement;
  };
#pragma terminal-interface
#pragma cross-module-argument

  interface ComponentRef
    : CellMLElement

  {
    attribute CellMLAttributeString componentName;

    readonly attribute ComponentRefSet componentRefs;

    readonly attribute ComponentRef parentComponentRef;

    readonly attribute Group parentGroup;
  };
#pragma terminal-interface

  interface RelationshipRef
    : CellMLElement
  {
    attribute CellMLAttributeString name;

    readonly attribute CellMLAttributeString relationship;

    readonly attribute CellMLAttributeString relationshipNamespace;

    void setRelationshipName(in CellMLAttributeString namespaceURI,
                             in CellMLAttributeString name);
  };
#pragma terminal-interface

  interface Group : CellMLElement
  {
    readonly attribute RelationshipRefSet relationshipRefs;

    readonly attribute ComponentRefSet componentRefs;

    readonly attribute boolean isEncapsulation;

    readonly attribute boolean isContainment;
  };
#pragma terminal-interface

  interface Connection
    : CellMLElement
  {
    readonly attribute MapComponents componentMapping;

    readonly attribute MapVariablesSet variableMappings;
  };
#pragma terminal-interface

  interface MapComponents
    : CellMLElement
  {
    attribute CellMLAttributeString firstComponentName;

    attribute CellMLAttributeString secondComponentName;

    attribute CellMLComponent firstComponent;

    attribute CellMLComponent secondComponent;
  };
#pragma terminal-interface

  interface MapVariables
    : CellMLElement
  {
    attribute CellMLAttributeString firstVariableName;

    attribute CellMLAttributeString secondVariableName;

    attribute CellMLVariable firstVariable;

    attribute CellMLVariable secondVariable;
  };
#pragma terminal-interface

  interface VariableRef;
  interface Role;

  interface Reaction
    : CellMLElement
  {
    readonly attribute VariableRefSet variableReferences;

    attribute boolean reversible;

    VariableRef getVariableRef(in wstring varName, in boolean create);

    Role getRoleByDeltaVariable(in wstring varName);
  };
#pragma terminal-interface

  interface VariableRef
    : CellMLElement
  {
    attribute CellMLVariable variable;

    attribute wstring variableName;

    readonly attribute RoleSet roles;
  };
#pragma terminal-interface

  interface Role
    : CellMLElement, MathContainer
  {
    enum RoleType
    {
      REACTANT, PRODUCT, RATE, CATALYST, ACTIVATOR, INHIBITOR, MODIFIER
    };

    enum DirectionType
    {
      FORWARD, REVERSE, BOTH
    };

    attribute RoleType variableRole;
    
    attribute DirectionType direction;

    attribute double stoichiometry;

    attribute CellMLVariable deltaVariable;

    attribute wstring deltaVariableName;
  };
#pragma terminal-interface

  interface CellMLElementIterator : XPCOM::IObject
  {
    CellMLElement next();
  };

  interface MathMLElementIterator : XPCOM::IObject
  {
    MathMLElement next();
  };

  interface ExtensionElementList : XPCOM::IObject
  {
    readonly attribute unsigned long length;

    boolean contains(in ExtensionElement x);

    long getIndexOf(in ExtensionElement x);

    ExtensionElement getAt(in unsigned long index);
  };
#pragma terminal-interface

  interface MathList : XPCOM::IObject
  {
    readonly attribute unsigned long length;

    boolean contains(in MathMLElement x);

    MathMLElementIterator iterate();
  };
#pragma terminal-interface

  interface ExtensionAttributeIterator : XPCOM::IObject
  {
    dom::Attr nextAttribute();
  };
#pragma terminal-interface

  interface ExtensionAttributeSet : XPCOM::IObject
  {
    ExtensionAttributeIterator iterate();
  };
#pragma terminal-interface


  interface CellMLElementSet : XPCOM::IObject
  {
    readonly attribute unsigned long length;

    boolean contains(in CellMLElement x);

    CellMLElementIterator iterate();
  };

  interface NamedCellMLElementSet : CellMLElementSet
  {
    NamedCellMLElement get(in CellMLAttributeString name);
  };

  interface ModelIterator : CellMLElementIterator
  {
    Model nextModel();
  };
#pragma terminal-interface

  interface ModelSet
    : NamedCellMLElementSet
  {
    ModelIterator iterateModels();

    Model getModel(in CellMLAttributeString name);
  };
#pragma terminal-interface

  interface CellMLComponentIterator : CellMLElementIterator
  {
    CellMLComponent nextComponent();
  };

  interface CellMLComponentSet
    : NamedCellMLElementSet
  {
    CellMLComponentIterator iterateComponents();

    CellMLComponent getComponent(in CellMLAttributeString name);
  };


  interface ImportComponentIterator : CellMLComponentIterator
  {
    ImportComponent nextImportComponent();
  };
#pragma terminal-interface

  interface ImportComponentSet
    : CellMLComponentSet
  {
    ImportComponentIterator iterateImportComponents();

    ImportComponent getImportComponent(in CellMLAttributeString name);
  };
#pragma terminal-interface

  interface CellMLVariableIterator : CellMLElementIterator
  {
    CellMLVariable nextVariable();
  };
#pragma terminal-interface

  interface CellMLVariableSet
    : NamedCellMLElementSet
  {
    CellMLVariableIterator iterateVariables();

    CellMLVariable getVariable(in CellMLAttributeString name);
  };
#pragma terminal-interface

  interface UnitsIterator : CellMLElementIterator
  {
    Units nextUnits();
  };

  interface UnitsSet
    : NamedCellMLElementSet
  {
    UnitsIterator iterateUnits();

    Units getUnits(in CellMLAttributeString name);
  };

  interface ImportUnitsIterator : UnitsIterator
  {
    ImportUnits nextImportUnits();
  };
#pragma terminal-interface

  interface ImportUnitsSet
    : UnitsSet
  {
    ImportUnitsIterator iterateImportUnits();

    ImportUnits getImportUnits(in CellMLAttributeString name);
  };
#pragma terminal-interface

  interface CellMLImportIterator : CellMLElementIterator
  {
    CellMLImport nextImport();
  };
#pragma terminal-interface

  interface CellMLImportSet
    : CellMLElementSet
  {
    CellMLImportIterator iterateImports();
  };
#pragma terminal-interface

  interface UnitIterator : CellMLElementIterator
  {
    Unit nextUnit();
  };
#pragma terminal-interface

  interface UnitSet
    : CellMLElementSet
  {
    UnitIterator iterateUnits();
  };
#pragma terminal-interface

  interface ConnectionIterator : CellMLElementIterator
  {
    Connection nextConnection();
  };
#pragma terminal-interface

  interface ConnectionSet
    : CellMLElementSet
  {
    ConnectionIterator iterateConnections();
  };
#pragma terminal-interface

  interface GroupIterator : CellMLElementIterator
  {
    Group nextGroup();
  };
#pragma terminal-interface

  interface GroupSet
    : CellMLElementSet
  {
    GroupIterator iterateGroups();

    GroupSet getSubsetInvolvingRelationship(in CellMLAttributeString relName);

    readonly attribute GroupSet subsetInvolvingEncapsulation;

    readonly attribute GroupSet subsetInvolvingContainment;
  };
#pragma terminal-interface
  
  interface RelationshipRefIterator : CellMLElementIterator
  {
    RelationshipRef nextRelationshipRef();
  };
#pragma terminal-interface

  interface RelationshipRefSet
    : CellMLElementSet
  {
    RelationshipRefIterator iterateRelationshipRefs();
  };
#pragma terminal-interface

  interface ComponentRefIterator : CellMLElementIterator
  {
    ComponentRef nextComponentRef();
  };
#pragma terminal-interface

  interface ComponentRefSet
    : CellMLElementSet
  {
    ComponentRefIterator iterateComponentRefs();
  };
#pragma terminal-interface

  interface MapVariablesIterator : CellMLElementIterator
  {
    MapVariables nextMapVariable();

    MapVariables nextMapVariables();
  };
#pragma terminal-interface

  interface MapVariablesSet
    : CellMLElementSet
  {
    MapVariablesIterator iterateMapVariables();
  };
#pragma terminal-interface

  interface ReactionIterator
    : CellMLElementIterator
  {
    Reaction nextReaction();
  };
#pragma terminal-interface

  interface ReactionSet
    : CellMLElementSet
  {
    ReactionIterator iterateReactions();
  };
#pragma terminal-interface

  interface VariableRefIterator : CellMLElementIterator
  {
    VariableRef nextVariableRef();
  };
#pragma terminal-interface

  interface VariableRefSet
    : CellMLElementSet
  {
    VariableRefIterator iterateVariableRefs();
  };
#pragma terminal-interface

  interface RoleIterator : CellMLElementIterator
  {
    Role nextRole();
  };
#pragma terminal-interface

  interface RoleSet
    : CellMLElementSet
  {
    RoleIterator iterateRoles();
  };
#pragma terminal-interface

  interface ModelLoadedListener
    : XPCOM::IObject
  {
    void loadCompleted(in Model m);
  };
#pragma terminal-interface

  interface DocumentLoadedListener
    : XPCOM::IObject
  {
    void loadCompleted(in dom::Document doc);
  };
#pragma terminal-interface

  interface ModelLoader
    : XPCOM::IObject
  {
    Model loadFromURL(in dom::DOMString URL)
      raises(CellMLException);

    void asyncLoadFromURL(in dom::DOMString URL,
                          in ModelLoadedListener listener);

    Model createFromText(in dom::DOMString xmlText)
      raises(CellMLException);

    readonly attribute dom::DOMString lastErrorMessage;
  };

  interface DOMURLLoader
    : XPCOM::IObject
  {
    dom::Document loadDocument(in dom::DOMString URL)
      raises(CellMLException);

    dom::Document loadDocumentFromText(in dom::DOMString xmlText)
      raises(CellMLException);

    void asyncLoadDocument(in dom::DOMString URL,
                           in DocumentLoadedListener listener)
      raises(CellMLException);

    readonly attribute dom::DOMString lastErrorMessage;
  };
#pragma terminal-interface

  interface DOMModelLoader
    : ModelLoader
  {
    Model createFromDOM(in dom::DOMString url, in DOMURLLoader loader)
      raises(CellMLException);

    Model createFromDOMDocument(in dom::Document doc)
      raises(CellMLException);

    void asyncCreateFromDOM(in dom::DOMString url, in DOMURLLoader loader,
                       in ModelLoadedListener listener)
      raises(CellMLException);
  };
#pragma terminal-interface

  interface CellMLBootstrap
    : XPCOM::IObject
  {
    readonly attribute DOMModelLoader modelLoader;

    readonly attribute dom::DOMImplementation domImplementation;

    readonly attribute DOMURLLoader localURLLoader;

    Model createModel(in wstring version);

    dom::DOMString serialiseNode(in dom::Node node);

    wstring makeURLAbsolute(in wstring relTo, in wstring relURL);
  };
#pragma terminal-interface
#pragma cross-module-argument
};

#endif // INCLUDED_CELLML_APISPEC