C++ XMLOutputStream::endElement方法代码示例

void
ASTCSymbolDelayNode::write(XMLOutputStream& stream) const
{
  if (&stream == NULL) return;

  stream.startElement("apply");
  
  stream.startElement("csymbol");

  stream.setAutoIndent(false);
  
  ASTBase::writeAttributes(stream);

  stream.writeAttribute( "encoding"     , mEncoding );
  stream.writeAttribute( "definitionURL", mDefinitionURL  );

  stream << " " << getName() << " ";
  
  stream.endElement("csymbol");
  
  stream.setAutoIndent(true);

  for (unsigned int n = 0; n < getNumChildren(); n++)
  {
    ASTFunctionBase::getChild(n)->write(stream);
  }
  
  stream.endElement("apply");
}

void
ASTPiecewiseFunctionNode::write(XMLOutputStream& stream) const
{
  if (&stream == NULL) return;

  ASTBase::writeStartElement(stream);

  unsigned int i;
  unsigned int numChild = 0;
  unsigned int numChildren = ASTFunctionBase::getNumChildren();
  for (i = 0; i < getNumPiece(); i++)
  {
  /* HACK TO REPLICATE OLD AST */
  /* old ast behaviour would take each child in turn as elements of piece
   * and then otherwise
   */
    if (ASTFunctionBase::getChild(i)->getType() == AST_CONSTRUCTOR_PIECE)
    {
      ASTFunctionBase::getChild(i)->write(stream);
    }
    else
    {
      stream.startElement("piece");
      if (numChild < numChildren)
      {
        ASTFunctionBase::getChild(numChild)->write(stream);
        numChild++;
      }
      if (numChild < numChildren)
      {
        ASTFunctionBase::getChild(numChild)->write(stream);
        numChild++;
      }
      stream.endElement("piece");
    }
  }

  if (getHasOtherwise() == true)
  {
    if (ASTFunctionBase::getChild(numChildren-1)->getType() 
                                             == AST_CONSTRUCTOR_OTHERWISE)
    {
      ASTFunctionBase::getChild(numChildren-1)->write(stream);
    }
    else
    {
      stream.startElement("otherwise");
      ASTFunctionBase::getChild(numChildren-1)->write(stream);
      stream.endElement("otherwise");
    }
  }

  
    
  stream.endElement("piecewise");
}

/*
 * Subclasses should override this method to write out their contained
 * SBML objects as XML elements.  Be sure to call your parents
 * implementation of this method as well.
 */
void
SpeciesReference::writeElements (XMLOutputStream& stream) const
{
  if ( mNotes != NULL ) stream << *mNotes;
  SpeciesReference * sr = const_cast <SpeciesReference *> (this);
  sr->syncAnnotation();
  if ( mAnnotation != NULL ) stream << *mAnnotation;

  if (getLevel() == 2)
  {
    if (mStoichiometryMath || mDenominator != 1)
    {
      if (mStoichiometryMath != NULL) 
      {
        mStoichiometryMath->write(stream);
      }
      else
      {
        ASTNode node;
        node.setValue(static_cast<long>(mStoichiometry), mDenominator);

        stream.startElement("stoichiometryMath");
        writeMathML(&node, stream);
        stream.endElement("stoichiometryMath");
      }
    }
  }

  //
  // (EXTENSION)
  //
  SBase::writeExtensionElements(stream);

}

void
ASTLambdaFunctionNode::write(XMLOutputStream& stream) const
{

  ASTBase::writeStartElement(stream);

  /* HACK TO REPLICATE OLD AST */
  /* all but the last child will be wrapped as bvars
   * even if they are technically not
   */
  unsigned int numChildren = ASTFunctionBase::getNumChildren();
  for (unsigned int i = 0; i < numChildren; i++)
  {
    if (i < numChildren-1 && ASTFunctionBase::getChild(i)->getType() != AST_QUALIFIER_BVAR)
    {
      ASTQualifierNode * bvar = new ASTQualifierNode(AST_QUALIFIER_BVAR);
      bvar->addChild(ASTFunctionBase::getChild(i)->deepCopy());
      bvar->write(stream);
      delete bvar;
    }
    else
    {
      ASTFunctionBase::getChild(i)->write(stream);
    }
  }
    
  stream.endElement("lambda");
}

void 
ASTSemanticsNode::write(XMLOutputStream& stream) const
{
  stream.startElement("semantics");

  ASTBase::writeAttributes(stream);

  if (isSetDefinitionURL() == true)
  {
    stream.writeAttribute( "definitionURL", mDefinitionURL  );
  }

  if (getNumChildren() > 0)
  {
    getChild(0)->write(stream);
  }


  for (unsigned int n = 0; n < getNumSemanticsAnnotations(); n++)
  {
    stream << *getSemanticsAnnotation(n);
  }

  stream.endElement("semantics");
}

void 
ASTBase::writeConstant(XMLOutputStream& stream, const std::string & name) const
{

	stream.startElement(name);
  writeAttributes(stream);
	stream.endElement(name);
}

void 
ASTBase::writeNegInfinity(XMLOutputStream& stream) const
{

  stream.startElement("apply");
  stream.startEndElement("minus");
  stream.startEndElement("infinity");
  stream.endElement("apply");
}

void 
ASTBase::writeStartEndElement (XMLOutputStream& stream) const
{

  const char * name = getNameFromType(getExtendedType());
	stream.startElement(name);
  writeAttributes(stream);
	stream.endElement(name);
  
}

/*
 * Writes (serializes) this SBML object by writing it to XMLOutputStream.
 */
void
Text::write (XMLOutputStream& stream) const
{
    
  stream.startElement( getElementName() );

  writeAttributes( stream );
  // in addition to attributes we need to write the characters
  stream << this->getText();

  stream.endElement( getElementName() );
}

void
PolygonObject::write(XMLOutputStream& stream) const
{
  stream.startElement(getElementName(), getPrefix());
  writeAttributes(stream);
  if(isSetPointIndex())
  {
    for (int i = 0; i < mPointIndexLength; ++i)
    {
      stream << (long)mPointIndex[i] << " ";
    }
  }
  stream.endElement(getElementName(), getPrefix());
}

void
ImageData::write(XMLOutputStream& stream) const
{
  stream.startElement(getElementName(), getPrefix());
  writeAttributes(stream);
  if(isSetSamples())
  {
    for (int i = 0; i < mSamplesLength; ++i)
    {
      stream << (long)mSamples[i] << " ";
    }
  }
  stream.endElement(getElementName(), getPrefix());
}

/*
 * Writes this XMLNode and its children to stream.
 */
void
XMLNode::write (XMLOutputStream& stream) const
{
  if (&stream == NULL) return;

  unsigned int children = getNumChildren();

  XMLToken::write(stream);

  if (children > 0)
  {
    bool haveTextNode = false;
    for (unsigned int c = 0; c < children; ++c) 
    {
        const XMLNode& current = getChild(c);
        stream << current;
        haveTextNode |= current.isText();
    }

    if (!mTriple.isEmpty())
    {
      // edge case ... we have an element with a couple of elements, and 
      // one is a text node (ugly!) in this case we can get a hanging
      // indent ... so we downindent ... 
      if (children > 1 && haveTextNode)
      {
        stream.downIndent();
      }
      stream.endElement( mTriple );
    }
  }
  else if ( isStart() && !isEnd() ) 
  {
    stream.endElement( mTriple );
  }

}

void
ASTUnaryFunctionNode::write(XMLOutputStream& stream) const
{
  if (&stream == NULL) return;

  stream.startElement("apply");
    
  //const char * name = ASTBase::getNameFromType(type);
  		
  ASTBase::writeStartEndElement(stream);

  /* write the one child
   * note we expect to have one child but cannot guarantee it 
   */
   
  unsigned int numChildren = getNumChildren();

  /* HACK TO REPLICATE OLD AST */
  /* for log 10 write out the logbase explicilty
   * for sqrt write out the degree explicilty
   * NOTE the qualifier node will add the necessary integers
   */
  if (numChildren == 1)
  {
    if (isLog10() == true)
    {
      ASTQualifierNode * logbase = new ASTQualifierNode(AST_QUALIFIER_LOGBASE);
      logbase->write(stream);
      delete logbase;
    }
    else if (isSqrt() == true)
    {
      ASTQualifierNode * degree = new ASTQualifierNode(AST_QUALIFIER_DEGREE);
      degree->write(stream);
      delete degree;
    }

    ASTFunctionBase::getChild(0)->write(stream);
  }
  else
  {
    for (unsigned int n = 0; n < numChildren; n++)
    {
      ASTFunctionBase::getChild(n)->write(stream);
    }
  }

  stream.endElement("apply");
}

/*
 * Writes this XMLToken to stream.
 */
void
XMLToken::write (XMLOutputStream& stream) const
{
  if ( isEOF () ) return;

  if ( isText() )
  {
    stream << getCharacters();
    return;
  }

  if ( isStart() ) stream.startElement( mTriple );
  if ( isStart() ) stream << mNamespaces << mAttributes;
  if ( isEnd()   ) stream.endElement( mTriple );
}

void
ASTCnExponentialNode::write(XMLOutputStream& stream) const
{
  stream.startElement("cn");

  stream.setAutoIndent(false);

  ASTCnBase::write(stream);

  writeENotation (  getMantissa(), getExponent(), stream);
  
  stream.endElement("cn");
  
  stream.setAutoIndent(true);
}