Examples of org.sbml.jsbml.xml.XMLNode

    //     (notesType is NotesAny.) 
    //




    NOTES_TYPE addedNotesType = NOTES_TYPE.NotesAny; 
    XMLNode   addedNotes = new XMLNode();
    
    //------------------------------------------------------------
    //
    // STEP1 : identifies the type of the given notes
    //
    //------------------------------------------------------------


    if (name == "notes")
    {
      /* check for notes tags on the added notes and strip if present and
           the notes tag has "html" or "body" element */


        if (notes.getChildCount() > 0)  
        { 
          // notes.getChildAt(0) must be "html", "body", or any XHTML
          // element that would be permitted within a "body" element 
          // (e.g. <p>..</p>,  <br>..</br> and so forth).


          String cname = notes.getChildAt(0).getName();


          if (cname == "html")
          {
            addedNotes = notes.getChildAt(0);
            addedNotesType = NOTES_TYPE.NotesHTML;
          }
          else if (cname == "body") 
          {
            addedNotes = notes.getChildAt(0);
            addedNotesType = NOTES_TYPE.NotesBody;
          }
          else
          {
            // the notes tag must NOT be stripped if notes.getChildAt(0) node 
            // is neither "html" nor "body" element because the children of 
            // the addedNotes will be added to the current notes later if the node 
            // is neither "html" nor "body".
            addedNotes = notes;
            addedNotesType = NOTES_TYPE.NotesAny;
          }
        }
        else
        {
          // the given notes is empty 
            // TODO : log an error
          return;
        }
      }
      else
      {
        // if the XMLNode argument notes has been created from a string and 
        // it is a set of subelements there may be a single empty node
        // as parent - leaving this in doesn't affect the writing out of notes
        // but messes up the check for correct syntax
        
        // TODO : check that we are doing that when parsing a String into XMLNode
        
        if (!notes.isStart() && !notes.isEnd() && !notes.isText() ) 
        {
          if (notes.getChildCount() > 0)
          { 
            addedNotes = notes;
            addedNotesType = NOTES_TYPE.NotesAny;
          }
          else
          {
            // the given notes is empty 
            return;
          }
        }
        else
        {
          if (name == "html")
          {
            addedNotes = notes;
            addedNotesType = NOTES_TYPE.NotesHTML;
          }
          else if (name == "body")
          {
            addedNotes = notes;
            addedNotesType = NOTES_TYPE.NotesBody;
          }
          else
          {
            // The given notes node needs to be added to a parent node
            // if the node is neither "html" nor "body" element because the 
            // children of addedNotes will be added to the current notes later if the 
            // node is neither "html" nor "body" (i.e. any XHTML element that 
            // would be permitted within a "body" element)
            addedNotes.addChild(notes);
            addedNotesType = NOTES_TYPE.NotesAny;
          }
        }
      }


      //
      // checks the addedNotes of "html" if the html tag contains "head" and 
      // "body" tags which must be located in this order.
      //
      if (addedNotesType == NOTES_TYPE.NotesHTML)
      {
        if ((addedNotes.getChildCount() != 2) ||
            ( (addedNotes.getChildAt(0).getName() != "head") ||
              (addedNotes.getChildAt(1).getName() != "body")
            )
           )
        {
          // TODO : log an error to the user or throw an exception or both ?          
          return;
        }
      }


      // We do not have a Syntax checker working on XMLNode !!        
      // check whether notes is valid xhtml ?? (libsbml is doing that)


      if ( notesXMLNode != null )
      {
        //------------------------------------------------------------
        //
        //  STEP2: identifies the type of the existing notes 
        //
        //------------------------------------------------------------


        NOTES_TYPE curNotesType   = NOTES_TYPE.NotesAny; 
        XMLNode  curNotes = notesXMLNode;


        // curNotes.getChildAt(0) must be "html", "body", or any XHTML
        // element that would be permitted within a "body" element .


        String cname = curNotes.getChildAt(0).getName();
      
        if (cname == "html")
        {
          XMLNode curHTML = curNotes.getChildAt(0);
          //
          // checks the curHTML if the html tag contains "head" and "body" tags
          // which must be located in this order, otherwise nothing will be done.
          //
          if ((curHTML.getChildCount() != 2) ||
              ( (curHTML.getChildAt(0).getName() != "head") ||
                (curHTML.getChildAt(1).getName() != "body")
              )
             )
          {
            // TODO : log an error
            return;
          }
          curNotesType = NOTES_TYPE.NotesHTML;
        }
        else if (cname == "body") 
        {
          curNotesType = NOTES_TYPE.NotesBody;
        }
        else
        {
          curNotesType = NOTES_TYPE.NotesAny;
        }
      
        /*
         * BUT we also have the issue of the rules relating to notes
         * contents and where to add them ie we cannot add a second body element
         * etc...
         */


        //------------------------------------------------------------
        //
        //  STEP3: appends the given notes to the current notes
        //
        //------------------------------------------------------------
      
        int i;
      
        if (curNotesType == NOTES_TYPE.NotesHTML)
        {
          XMLNode curHTML = curNotes.getChildAt(0); 
          XMLNode curBody = curHTML.getChildAt(1);
          
          if (addedNotesType == NOTES_TYPE.NotesHTML)
          {
            // adds the given html tag to the current html tag
      
            XMLNode addedBody = addedNotes.getChildAt(1);   
      
            for (i=0; i < addedBody.getChildCount(); i++)
            {
              if (curBody.addChild(addedBody.getChildAt(i)) < 0 )
              // TODO : log an error
                return;          
            }
          }
          else if ((addedNotesType == NOTES_TYPE.NotesBody) || (addedNotesType == NOTES_TYPE.NotesAny))
          {
            // adds the given body or other tag (permitted in the body) to the current 
            // html tag
      
            for (i=0; i < addedNotes.getChildCount(); i++)
            {
              if (curBody.addChild(addedNotes.getChildAt(i)) < 0 )
              // TODO : log an error
                return;
            }
          }
        }
        else if (curNotesType == NOTES_TYPE.NotesBody)
        {
          if (addedNotesType == NOTES_TYPE.NotesHTML)
          {
            // adds the given html tag to the current body tag
      
            XMLNode addedHTML = new XMLNode(addedNotes);
            XMLNode addedBody = addedHTML.getChildAt(1);
            XMLNode curBody   = curNotes.getChildAt(0);
      
            for (i=0; i < curBody.getChildCount(); i++)
            {
              addedBody.insertChild(i,curBody.getChildAt(i));
            }
            
            curNotes.removeChildren();
            if (curNotes.addChild(addedHTML) < 0)
              // TODO : log an error
              return;
          }
          else if ((addedNotesType == NOTES_TYPE.NotesBody) || (addedNotesType == NOTES_TYPE.NotesAny))
          {
            // adds the given body or other tag (permitted in the body) to the current 
            // body tag
      
            XMLNode curBody = curNotes.getChildAt(0);
      
            for (i=0; i < addedNotes.getChildCount(); i++)
            {
              if (curBody.addChild(addedNotes.getChildAt(i)) < 0)
              // TODO : log an error
                return;
            }
          }
        }
        else if (curNotesType == NOTES_TYPE.NotesAny)
        {
          if (addedNotesType == NOTES_TYPE.NotesHTML)
          {
            // adds the given html tag to the current any tag permitted in the body.
      
            XMLNode addedHTML = new XMLNode(addedNotes);
            XMLNode addedBody = addedHTML.getChildAt(1);
      
            for (i=0; i < curNotes.getChildCount(); i++)
            {
              addedBody.insertChild(i,curNotes.getChildAt(i));
            }
      
            curNotes.removeChildren();
            if (curNotes.addChild(addedHTML) < 0)
              // TODO : log an error
              return;
          }
          else if (addedNotesType == NOTES_TYPE.NotesBody)
          {
            // adds the given body tag to the current any tag permitted in the body.
      
            XMLNode addedBody = new XMLNode(addedNotes);
      
            for (i=0; i < curNotes.getChildCount(); i++)
            {
              addedBody.insertChild(i,curNotes.getChildAt(i));
            }
      
            curNotes.removeChildren();
            if (curNotes.addChild(addedBody) < 0)
              // TODO : log an error

  /*
   * (non-Javadoc)
   * @see org.sbml.jsbml.SBase#setNotes(java.lang.String)
   */
  public void setNotes(XMLNode notes) {
    XMLNode oldNotes = this.notesXMLNode;
    this.notesXMLNode = notes;
    this.notesXMLNode.setParent(this);
    firePropertyChange(TreeNodeChangeEvent.notes, oldNotes, this.notesXMLNode);
  }

   * 
   * @see org.sbml.jlibsbml.SBase#unsetNotes()
   */
  public void unsetNotes() {
    if (isSetNotes()) {
      XMLNode oldNotes = notesXMLNode;
      notesXMLNode = null;
      firePropertyChange(TreeNodeChangeEvent.notes, oldNotes, getNotes());
    }
  }

        }


        if (elementName.equals("notes")
            && (contextObject instanceof SBase)) {
          SBase sbase = (SBase) contextObject;
          sbase.setNotes(new XMLNode(new XMLTriple("notes", null, null), new XMLAttributes()));
        } else if (elementName.equals("annotation")
            && (contextObject instanceof SBase)) {
          SBase sbase = (SBase) contextObject;
          Annotation annotation = (Annotation) newContextObject;
          sbase.setAnnotation(annotation);


          return annotation;
        } else if (contextObject instanceof SBMLDocument) {
          SBMLDocument sbmlDocument = (SBMLDocument) contextObject;
          if (elementName.equals("model")) {
            Model model = (Model) newContextObject;
            model.setLevel(sbmlDocument.getLevel());
            model.setVersion(sbmlDocument.getVersion());
            model.initDefaults();
            model.setParentSBML(sbmlDocument);
            sbmlDocument.setModel(model);


            return model;
          }
        } else if (contextObject instanceof Model) {


          Model model = (Model) contextObject;
          if (newContextObject instanceof ListOf<?>) {
            if (elementName.equals("listOfFunctionDefinitions")
                && model.getLevel() > 1) {
              ListOf<FunctionDefinition> listOfFunctionDefinitions = (ListOf<FunctionDefinition>) newContextObject;
              model.setListOfFunctionDefinitions(listOfFunctionDefinitions);


              return listOfFunctionDefinitions;
            } else if (elementName.equals("listOfUnitDefinitions")) {
              ListOf<UnitDefinition> listOfUnitDefinitions = (ListOf<UnitDefinition>) newContextObject;
              model.setListOfUnitDefinitions(listOfUnitDefinitions);


              return listOfUnitDefinitions;
            } else if (elementName.equals("listOfCompartments")) {
              ListOf<Compartment> listOfCompartments = (ListOf<Compartment>) newContextObject;
              model.setListOfCompartments(listOfCompartments);


              return listOfCompartments;
            } else if (elementName.equals("listOfSpecies")) {
              ListOf<Species> listOfSpecies = (ListOf<Species>) newContextObject;
              model.setListOfSpecies(listOfSpecies);


              return listOfSpecies;
            } else if (elementName.equals("listOfParameters")) {
              ListOf<Parameter> listOfParameters = (ListOf<Parameter>) newContextObject;
              model.setListOfParameters(listOfParameters);


              return listOfParameters;
            } else if (elementName.equals("listOfInitialAssignments")
                && ((model.getLevel() == 2 && model.getVersion() > 1) 
                    || model.getLevel() >= 3)) {
              ListOf<InitialAssignment> listOfInitialAssignments = (ListOf<InitialAssignment>) newContextObject;
              model.setListOfInitialAssignments(listOfInitialAssignments);


              return listOfInitialAssignments;
            } else if (elementName.equals("listOfRules")) {
              ListOf<Rule> listOfRules = (ListOf<Rule>) newContextObject;
              model.setListOfRules(listOfRules);


              return listOfRules;
            } else if (elementName.equals("listOfConstraints")
                && ((model.getLevel() == 2 && model.getVersion() > 1) 
                    || model.getLevel() >= 3)) {
              ListOf<Constraint> listOfConstraints = (ListOf<Constraint>) newContextObject;
              model.setListOfConstraints(listOfConstraints);


              return listOfConstraints;
            } else if (elementName.equals("listOfReactions")) {
              ListOf<Reaction> listOfReactions = (ListOf<Reaction>) newContextObject;
              model.setListOfReactions(listOfReactions);


              return listOfReactions;
            } else if (elementName.equals("listOfEvents")
                && model.getLevel() > 1) {
              ListOf<Event> listOfEvents = (ListOf<Event>) newContextObject;
              model.setListOfEvents(listOfEvents);


              return listOfEvents;
            } else if (elementName.equals("listOfCompartmentTypes")
                && (model.getLevel() == 2 && model.getVersion() > 1)) {
              ListOf<CompartmentType> listOfCompartmentTypes = (ListOf<CompartmentType>) newContextObject;
              model.setListOfCompartmentTypes(listOfCompartmentTypes);


              return listOfCompartmentTypes;
            } else if (elementName.equals("listOfSpeciesTypes")
                && (model.getLevel() == 2 && model.getVersion() > 1)) {
              ListOf<SpeciesType> listOfSpeciesTypes = (ListOf<SpeciesType>) newContextObject;
              model.setListOfSpeciesTypes(listOfSpeciesTypes);


              return listOfSpeciesTypes;
            } else {
              log4jLogger.warn("The element " + elementName + " is not recognized");
            }
          } else {
            log4jLogger.warn("The element " + elementName + " is not recognized");
          }
        } else if (contextObject instanceof ListOf<?>) {
          ListOf<?> list = (ListOf<?>) contextObject;
          if (list.getParentSBMLObject() instanceof Model) {


            Model model = (Model) list.getParentSBMLObject();
            if (elementName.equals("functionDefinition")
                && list.getSBaseListType().equals(
                    ListOf.Type.listOfFunctionDefinitions)
                && model.getLevel() > 1) {
              FunctionDefinition functionDefinition = (FunctionDefinition) newContextObject;
              model.addFunctionDefinition(functionDefinition);


              return functionDefinition;
            } else if (elementName.equals("unitDefinition")
                && list.getSBaseListType().equals(
                    ListOf.Type.listOfUnitDefinitions)) {
              UnitDefinition unitDefinition = (UnitDefinition) newContextObject;
              model.addUnitDefinition(unitDefinition);


              return unitDefinition;
            } else if (elementName.equals("compartment")
                && list.getSBaseListType().equals(
                    ListOf.Type.listOfCompartments)) {
              Compartment compartment = (Compartment) newContextObject;
              compartment.initDefaults();
              model.addCompartment(compartment);


              return compartment;
            } else if (elementName.equals("species")
                && list.getSBaseListType().equals(
                    ListOf.Type.listOfSpecies)
                && ((model.getLevel() == 1 && model
                    .getVersion() > 1) || model.getLevel() > 1)) {
              Species species = (Species) newContextObject;
              species.initDefaults();
              model.addSpecies(species);


              return species;
            }
            // level 1 : species => specie
            else if (elementName.equals("specie")
                && list.getSBaseListType().equals(
                    ListOf.Type.listOfSpecies)
                && model.getLevel() == 1
                && model.getVersion() == 1) {
              Species species = (Species) newContextObject;
              species.initDefaults();
              model.addSpecies(species);


              return species;
            } else if (elementName.equals("parameter")
                && list.getSBaseListType().equals(
                    ListOf.Type.listOfParameters)) {
              Parameter parameter = (Parameter) newContextObject;
              parameter.initDefaults();
              model.addParameter(parameter);


              return parameter;
            } else if (elementName.equals("initialAssignment")
                && list.getSBaseListType().equals(
                    ListOf.Type.listOfInitialAssignments)
                && ((model.getLevel() == 2 && model
                    .getVersion() > 1) || model.getLevel() >= 3)) {
              InitialAssignment initialAssignment = (InitialAssignment) newContextObject;
              model.addInitialAssignment(initialAssignment);


              return initialAssignment;
            } else if (elementName.equals("algebraicRule")
                && list.getSBaseListType().equals(
                    ListOf.Type.listOfRules)) {
              AlgebraicRule rule = (AlgebraicRule) newContextObject;
              model.addRule(rule);


              return rule;
            } else if (elementName.equals("assignmentRule")
                && list.getSBaseListType().equals(
                    ListOf.Type.listOfRules)
                && model.getLevel() > 1) {
              AssignmentRule rule = (AssignmentRule) newContextObject;
              model.addRule(rule);


              return rule;
            } else if (elementName.equals("parameterRule")
                && list.getSBaseListType().equals(ListOf.Type.listOfRules)
                && model.getLevel() == 1) 
            {
              ExplicitRule rule = (ExplicitRule) newContextObject;
              model.addRule(rule);


              return rule;
            } else if (elementName.equals("specieConcentrationRule")
                && list.getSBaseListType().equals(ListOf.Type.listOfRules)
                && model.getLevel() == 1
                && model.getVersion() == 1) 
            {
              ExplicitRule rule = (ExplicitRule) newContextObject;
              model.addRule(rule);


              return rule;
            } else if (elementName.equals("speciesConcentrationRule")
                && list.getSBaseListType().equals(ListOf.Type.listOfRules)
                && model.getLevel() == 1
                && model.getVersion() == 2) 
            {
              ExplicitRule rule = (ExplicitRule) newContextObject;
              model.addRule(rule);


              return rule;
            } else if (elementName.equals("compartmentVolumeRule")
                && list.getSBaseListType().equals(ListOf.Type.listOfRules)
                && model.getLevel() == 1) 
            {
              ExplicitRule rule = (ExplicitRule) newContextObject;
              model.addRule(rule);


              return rule;
            } else if (elementName.equals("rateRule")
                && list.getSBaseListType().equals(
                    ListOf.Type.listOfRules)) {
              RateRule rule = (RateRule) newContextObject;
              model.addRule(rule);


              return rule;
            } else if (elementName.equals("constraint")
                && list.getSBaseListType().equals(
                    ListOf.Type.listOfConstraints)
                && ((model.getLevel() == 2 && model
                    .getVersion() > 1) || model.getLevel() >= 3)) {
              Constraint constraint = (Constraint) newContextObject;
              model.addConstraint(constraint);


              return constraint;
            } else if (elementName.equals("reaction")
                && list.getSBaseListType().equals(
                    ListOf.Type.listOfReactions)) {
              Reaction reaction = (Reaction) newContextObject;
              model.addReaction(reaction);
              reaction.initDefaults();


              return reaction;
            } else if (elementName.equals("event")
                && list.getSBaseListType().equals(
                    ListOf.Type.listOfEvents)
                && model.getLevel() > 1) {
              Event event = (Event) newContextObject;
              model.addEvent(event);
              event.initDefaults();


              return event;
            } else if (elementName.equals("compartmentType")
                && list.getSBaseListType().equals(
                    ListOf.Type.listOfCompartmentTypes)
                && (model.getLevel() == 2 && model.getVersion() > 1)) {
              CompartmentType compartmentType = (CompartmentType) newContextObject;
              model.addCompartmentType(compartmentType);


              return compartmentType;
            } else if (elementName.equals("speciesType")
                && list.getSBaseListType().equals(
                    ListOf.Type.listOfSpeciesTypes)
                && (model.getLevel() == 2 && model.getVersion() > 1)) {
              SpeciesType speciesType = (SpeciesType) newContextObject;
              model.addSpeciesType(speciesType);


              return speciesType;
            } else {
              log4jLogger.warn("The element " + elementName + " is not recognized");
            }
          } else if (list.getParentSBMLObject() instanceof UnitDefinition) {
            UnitDefinition unitDefinition = (UnitDefinition) list
                .getParentSBMLObject();


            if (elementName.equals("unit")
                && list.getSBaseListType().equals(
                    ListOf.Type.listOfUnits)) {
              Unit unit = (Unit) newContextObject;
              unit.initDefaults();
              unitDefinition.addUnit(unit);


              return unit;
            } else {
              log4jLogger.warn("The element " + elementName + " is not recognized");
            }
          } else if (list.getParentSBMLObject() instanceof Reaction) {
            Reaction reaction = (Reaction) list
                .getParentSBMLObject();


            if (elementName.equals("speciesReference")
                && (reaction.getLevel() > 1 || (reaction
                    .getLevel() == 1 && reaction
                    .getVersion() == 2))) {
              SpeciesReference speciesReference = (SpeciesReference) newContextObject;
              speciesReference.initDefaults();


              if (list.getSBaseListType().equals(
                  ListOf.Type.listOfReactants)) {
                reaction.addReactant(speciesReference);


                return speciesReference;
              } else if (list.getSBaseListType().equals(
                  ListOf.Type.listOfProducts)) {
                reaction.addProduct(speciesReference);


                return speciesReference;
              } else {
                log4jLogger.warn("The element " + elementName + " is not recognized");
              }
            } else if (elementName.equals("specieReference")
                && reaction.getLevel() == 1) {
              SpeciesReference speciesReference = (SpeciesReference) newContextObject;
              speciesReference.initDefaults();


              if (list.getSBaseListType().equals(
                  ListOf.Type.listOfReactants)) {
                reaction.addReactant(speciesReference);


                return speciesReference;
              } else if (list.getSBaseListType().equals(
                  ListOf.Type.listOfProducts)) {
                reaction.addProduct(speciesReference);


                return speciesReference;
              } else {
                log4jLogger.warn("The element " + elementName + " is not recognized");
              }
            } else if (elementName
                .equals("modifierSpeciesReference")
                && list.getSBaseListType().equals(
                    ListOf.Type.listOfModifiers)
                && reaction.getLevel() > 1) {
              ModifierSpeciesReference modifierSpeciesReference = (ModifierSpeciesReference) newContextObject;
              reaction.addModifier(modifierSpeciesReference);


              return modifierSpeciesReference;
            } else {
              log4jLogger.warn("The element " + elementName + " is not recognized");
            }
          } else if (list.getParentSBMLObject() instanceof KineticLaw) {
            KineticLaw kineticLaw = (KineticLaw) list
                .getParentSBMLObject();
            // Level 3 : parameter and listOfParameters =>
            // localParameter and listOfLocalParameter
            if (elementName.equals("localParameter")
                && list.getSBaseListType().equals(
                    ListOf.Type.listOfLocalParameters)
                && kineticLaw.getLevel() >= 3) {
              LocalParameter localParameter = (LocalParameter) newContextObject;
              kineticLaw.addParameter(localParameter);


              return localParameter;
            } else if (elementName.equals("parameter")
                && list.getSBaseListType().equals(
                    ListOf.Type.listOfLocalParameters)
                && kineticLaw.isSetLevel()
                && kineticLaw.getLevel() < 3) {
              LocalParameter localParameter = new LocalParameter(
                  (Parameter) newContextObject);
              kineticLaw.addParameter(localParameter);


              return localParameter;
            } else {
              log4jLogger.warn("The element " + elementName + " is not recognized");
            }
          } else if (list.getParentSBMLObject() instanceof Event) {
            Event event = (Event) list.getParentSBMLObject();


            if (elementName.equals("eventAssignment")
                && list.getSBaseListType().equals(
                    ListOf.Type.listOfEventAssignments)
                && event.getLevel() > 1) {
              EventAssignment eventAssignment = (EventAssignment) newContextObject;
              event.addEventAssignment(eventAssignment);


              return eventAssignment;
            } else {
              log4jLogger.warn("The element " + elementName + " is not recognized");
            }
          } else {
            log4jLogger.warn("The element " + elementName + " is not recognized");
          }
        } else if (contextObject instanceof UnitDefinition) {
          UnitDefinition unitDefinition = (UnitDefinition) contextObject;


          if (elementName.equals("listOfUnits")) {
            ListOf<Unit> listOfUnits = (ListOf<Unit>) newContextObject;
            unitDefinition.setListOfUnits(listOfUnits);


            return listOfUnits;
          }
        } else if (contextObject instanceof Event) {
          Event event = (Event) contextObject;


          if (elementName.equals("listOfEventAssignments")) {
            ListOf<EventAssignment> listOfEventAssignments = (ListOf<EventAssignment>) newContextObject;
            event.setListOfEventAssignments(listOfEventAssignments);


            return listOfEventAssignments;
          } else if (elementName.equals("trigger")) {
            Trigger trigger = (Trigger) newContextObject;
            event.setTrigger(trigger);


            return trigger;
          } else if (elementName.equals("delay")) {
            Delay delay = (Delay) newContextObject;
            event.setDelay(delay);


            return delay;
          } else if (elementName.equals("priority")) {
            Priority priority = (Priority) newContextObject;
            event.setPriority(priority);


            return priority;
          } else {
            log4jLogger.warn("The element " + elementName + " is not recognized");
          }
        } else if (contextObject instanceof Reaction) {
          Reaction reaction = (Reaction) contextObject;
          if (elementName.equals("listOfReactants")) {
            ListOf<SpeciesReference> listOfReactants = (ListOf<SpeciesReference>) newContextObject;
            reaction.setListOfReactants(listOfReactants);


            return listOfReactants;
          } else if (elementName.equals("listOfProducts")) {
            ListOf<SpeciesReference> listOfProducts = (ListOf<SpeciesReference>) newContextObject;
            reaction.setListOfProducts(listOfProducts);


            return listOfProducts;
          } else if (elementName.equals("listOfModifiers")
              && reaction.getLevel() > 1) {
            ListOf<ModifierSpeciesReference> listOfModifiers = (ListOf<ModifierSpeciesReference>) newContextObject;
            reaction.setListOfModifiers(listOfModifiers);


            return listOfModifiers;
          } else if (elementName.equals("kineticLaw")) {
            KineticLaw kineticLaw = (KineticLaw) newContextObject;
            reaction.setKineticLaw(kineticLaw);


            return kineticLaw;
          } else {
            log4jLogger.warn("The element " + elementName + " is not recognized");
          }
        } else if (contextObject instanceof SpeciesReference) {
          SpeciesReference speciesReference = (SpeciesReference) contextObject;


          if (elementName.equals("stoichiometryMath")) {
            StoichiometryMath stoichiometryMath = (StoichiometryMath) newContextObject;
            speciesReference.setStoichiometryMath(stoichiometryMath);


            return stoichiometryMath;
          } else {
            log4jLogger.warn("The element " + elementName + " is not recognized");
          }
        } else if (contextObject instanceof KineticLaw) {
          KineticLaw kineticLaw = (KineticLaw) contextObject;


          if (elementName.equals("listOfLocalParameters")
              && kineticLaw.getLevel() >= 3) {
            ListOf<LocalParameter> listOfLocalParameters = (ListOf<LocalParameter>) newContextObject;
            kineticLaw.setListOfLocalParameters(listOfLocalParameters);
            listOfLocalParameters.setSBaseListType(ListOf.Type.listOfLocalParameters);


            return listOfLocalParameters;
          } else if (elementName.equals("listOfParameters")
              && kineticLaw.isSetLevel() && kineticLaw.getLevel() < 3) {
            ListOf<LocalParameter> listOfLocalParameters = (ListOf<LocalParameter>) newContextObject;
            kineticLaw.setListOfLocalParameters(listOfLocalParameters);
            listOfLocalParameters.setSBaseListType(ListOf.Type.listOfLocalParameters);


            return listOfLocalParameters;
          } else {
            log4jLogger.warn("The element " + elementName + " is not recognized");
          }
        } else if (contextObject instanceof Constraint) {
          Constraint constraint = (Constraint) contextObject;


          if (elementName.equals("message")
              && ((constraint.getLevel() == 2 && constraint
                  .getVersion() > 1) || constraint.getLevel() >= 3)) 
          {
            constraint.setMessage(new XMLNode(new XMLTriple("message", null, null), new XMLAttributes()));


            return constraint;
          } else {
            log4jLogger.warn("The element " + elementName + " is not recognized");
          }

    
    logger.debug("processAttribute : attribute name = " + attributeName + ", value = " + value);
    
    if (contextObject instanceof XMLNode) {
      
      XMLNode xmlNode = (XMLNode) contextObject;
      xmlNode.addAttr(attributeName, value, null, prefix);
      
      
    } else {
      logger.debug("processAttribute : context Object is not an XMLNode !!! " + contextObject);
    }

    
    logger.debug("processCharactersOf called : characters = @" + characters + "@");
    
    // characters = StringTools.encodeForHTML(characters); // TODO : use an apache util for that.


    XMLNode textNode = new XMLNode(characters);


    if (contextObject instanceof XMLNode) {
      
      XMLNode xmlNode = (XMLNode) contextObject;


      xmlNode.addChild(textNode);
      
    } else if (contextObject instanceof SBase) {
      SBase parentSBMLElement = (SBase) contextObject;
      
      XMLNode xmlNode = null;


      if (parentSBMLElement.isSetNotes() && typeOfNotes.equals("notes")) 
      {
        xmlNode = parentSBMLElement.getNotes(); 
      }
      else if (typeOfNotes.equals("message") && parentSBMLElement instanceof Constraint
          && ((Constraint) parentSBMLElement).isSetMessage())
      {
        xmlNode = ((Constraint) parentSBMLElement).getMessage();
      } 
      else 
      {
        logger.warn("The type of String " + typeOfNotes + " on the element " + 
            parentSBMLElement.getElementName() + " is unknown !! Some data might be lost");
        return;
      }


      xmlNode.addChild(textNode);
      
    } else {  
      logger.debug("processCharactersOf : context Object is not an XMLNode or SBase !!! " + contextObject);
    }

   */
  public boolean processEndElement(String elementName, String prefix,
      boolean isNested, Object contextObject) 
  {
    if (contextObject instanceof XMLNode) {
      XMLNode xmlNode = (XMLNode) contextObject;
      
      if (xmlNode.getChildCount() == 0) {
        xmlNode.setEnd();
      }
    }
    
    return true;
  }

      String localName, boolean hasAttributes, boolean isLastNamespace,
      Object contextObject) 
  {
    if (contextObject instanceof XMLNode) {
      
      XMLNode xmlNode = (XMLNode) contextObject;
      if (!xmlNode.isStart()) {
        logger.debug("processNamespace : context Object is not a start node !!! " + contextObject);
      }
      
      xmlNode.addNamespace(URI, prefix);
      
    } else {
      logger.debug("processNamespace : context Object is not an XMLNode !!! " + contextObject);
      logger.debug("processNamespace : element name = " + elementName + ", namespace = " + prefix + ":" + URI);
    }

      Object contextObject) 
  {
    logger.debug("processStartElement : element name = " + elementName);
    
    // Creating a StartElement XMLNode !!  
    XMLNode xmlNode = new XMLNode(new XMLTriple(elementName, null, prefix), new XMLAttributes(), new XMLNamespaces());
    
    if (contextObject instanceof SBase) {
      SBase parentSBMLElement = (SBase) contextObject;
      
      if (typeOfNotes.equals("notes")) {
        parentSBMLElement.getNotes().addChild(xmlNode);
      } else if (typeOfNotes.equals("message") && parentSBMLElement instanceof Constraint) {
        ((Constraint) parentSBMLElement).getMessage().addChild(xmlNode);
      } else {
        logger.warn("The type of String " + typeOfNotes + " on the element " + 
            parentSBMLElement.getElementName() + " is unknown !! Some data might be lost");
      }
      
    } else if (contextObject instanceof XMLNode) {
      XMLNode parentNode = (XMLNode) contextObject;
      
      parentNode.addChild(xmlNode);
    }
    
    return xmlNode;
  }




    long nbChildren = xmlNode.getChildCount();


    for (int i = 0; i < nbChildren; i++) {
      XMLNode child = xmlNode.getChildAt(i);
      write(child);
    }


    if (xmlNode.isElement() && !xmlNode.getName().equals("message")) {
      if (isRoot) {

Examples of org.sbml.jsbml.xml.XMLNode

Related Classes of org.sbml.jsbml.xml.XMLNode