memberhandler.cpp

Doxygen的词根来源于Document（文档）和Oxygen（氧气）

}

void MemberHandler::startInbodyDesc(const QXmlAttributes& attrib)
{
  DocHandler *docHandler = new DocHandler(this);
  docHandler->startDoc(attrib);
  m_inbody = docHandler;
}

void MemberHandler::startLocation(const QXmlAttributes& attrib)
{
  m_defFile = attrib.value("file");
  m_bodyFile = attrib.value("bodyfile");
  QCString s;
  s = attrib.value("line");
  if (!s.isEmpty()) m_defLine=s.toInt();
  s = attrib.value("bodystart");
  if (!s.isEmpty()) m_bodyStart=s.toInt();
  s = attrib.value("bodyend");
  if (!s.isEmpty()) m_bodyEnd=s.toInt();
}

void MemberHandler::startReferences(const QXmlAttributes& attrib)
{
  MemberReference *mr = new MemberReference;
  mr->m_memId = attrib.value("refid");
  m_references.append(mr);
  m_curString="";
}

void MemberHandler::endReferences()
{
  m_references.getLast()->m_name = m_curString;
}

void MemberHandler::startReferencedBy(const QXmlAttributes& attrib)
{
  MemberReference *mr = new MemberReference;
  mr->m_memId = attrib.value("refid");
  m_referencedBy.append(mr);
  m_curString="";
}

void MemberHandler::endReferencedBy()
{
  m_referencedBy.getLast()->m_name = m_curString;
}

void MemberHandler::startReimplements(const QXmlAttributes& attrib)
{
  m_reimplements = new MemberReference;
  m_reimplements->m_memId = attrib.value("refid");
  m_curString="";
}

void MemberHandler::endReimplements()
{
  m_reimplements->m_name = m_curString;
}

void MemberHandler::startReimplementedBy(const QXmlAttributes& attrib)
{
  MemberReference *mr = new MemberReference;
  mr->m_memId = attrib.value("refid");
  m_reimplementedBy.append(mr);
  m_curString="";
}

void MemberHandler::endReimplementedBy()
{
  m_reimplementedBy.getLast()->m_name = m_curString;
}

void MemberHandler::endMember()
{
  m_parent->setDelegate(0);
}

void MemberHandler::startType(const QXmlAttributes &)
{
  debug(2,"startType!\n");
  delete m_linkedTextHandler;
  m_linkedTextHandler = new LinkedTextHandler(this,m_type);
  m_linkedTextHandler->start("type");
}

void MemberHandler::startInitializer(const QXmlAttributes &)
{
  debug(2,"startInitializer!\n");
  delete m_linkedTextHandler;
  m_linkedTextHandler = new LinkedTextHandler(this,m_initializer);
  m_linkedTextHandler->start("initializer");
}

void MemberHandler::startException(const QXmlAttributes &)
{
  debug(2,"startException!\n");
  delete m_linkedTextHandler;
  m_linkedTextHandler = new LinkedTextHandler(this,m_exception);
  m_linkedTextHandler->start("exceptions");
}

void MemberHandler::startName(const QXmlAttributes &)
{
  m_curString="";
}

void MemberHandler::endName()
{
  m_name = m_curString.stripWhiteSpace();
  debug(2,"member name=`%s'\n",m_name.data());
}

void MemberHandler::startRead(const QXmlAttributes &)
{
  m_curString="";
}

void MemberHandler::endRead()
{
  m_read = m_curString.stripWhiteSpace();
  debug(2,"member read=`%s'\n",m_read.data());
}

void MemberHandler::startWrite(const QXmlAttributes &)
{
  m_curString="";
}

void MemberHandler::endWrite()
{
  m_write = m_curString.stripWhiteSpace();
  debug(2,"member write=`%s'\n",m_write.data());
}

void MemberHandler::startDefinition(const QXmlAttributes&)
{
  m_curString="";
}

void MemberHandler::endDefinition()
{
  m_definition = m_curString.stripWhiteSpace();
  debug(2,"definition=%s\n",m_definition.data());
}
  
void MemberHandler::startArgsString(const QXmlAttributes&)
{
  m_curString="";
}

void MemberHandler::endArgsString()
{
  m_argsstring = m_curString.stripWhiteSpace();
  debug(2,"arggstring=%s\n",m_argsstring.data());
}
  
void MemberHandler::startParam(const QXmlAttributes& attrib)
{
  ParamHandler *paramHandler = new ParamHandler(this);
  paramHandler->startParam(attrib);
  if (m_insideTemplateParamList)
  {
    m_templateParams.append(paramHandler);
  }
  else
  {
    m_params.append(paramHandler);
  }
}

void MemberHandler::startTemplateParamList(const QXmlAttributes&)
{
  m_insideTemplateParamList = TRUE;
  m_hasTemplateParamList = TRUE;
}

void MemberHandler::endTemplateParamList()
{
  m_insideTemplateParamList = FALSE;
}

void MemberHandler::initialize(MainHandler *mh)
{
  {
    QListIterator<MemberReference> mli(m_references);
    MemberReference *mr;
    for (;(mr=mli.current());++mli)
    {
      mr->initialize(mh);
    }
  }
  {
    QListIterator<MemberReference> mli(m_referencedBy);
    MemberReference *mr;
    for (;(mr=mli.current());++mli)
    {
      mr->initialize(mh);
    }
  }
  {
    QListIterator<MemberReference> mli(m_reimplementedBy);
    MemberReference *mr;
    for (;(mr=mli.current());++mli)
    {
      mr->initialize(mh);
    }
  }
  if (m_reimplements) m_reimplements->initialize(mh);
}

void MemberHandler::setCompoundHandler(CompoundHandler *c)
{
  m_compound = c;
}

ICompound *MemberHandler::compound() const
{
  m_compound->addref();
  return m_compound->toICompound();
}

void MemberHandler::setSectionHandler(SectionHandler *c)
{
  m_section = c;
}

ISection *MemberHandler::section() const
{
  return m_section;
}

IMemberIterator *MemberHandler::enumValues() const
{ 
  return new MemberIterator(m_enumValues); 
}

ILinkedTextIterator *MemberHandler::type() const 
{ 
  return new LinkedTextIterator(m_type); 
}

const IString *MemberHandler::typeString() const
{ 
  MemberHandler *that = (MemberHandler *)this;
  that->m_typeString = LinkedTextHandler::toString(m_type); 
  return &m_typeString;
}

IParamIterator *MemberHandler::parameters() const 
{ 
  return new ParamIterator(m_params); 
}

IParamIterator *MemberHandler::templateParameters() const 
{ 
  return m_hasTemplateParamList ? new ParamIterator(m_templateParams) : 0; 
}

IMemberReferenceIterator *MemberHandler::references() const 
{ 
  return new MemberReferenceIterator(m_references); 
}

IMemberReferenceIterator *MemberHandler::referencedBy() const 
{ 
  return new MemberReferenceIterator(m_referencedBy); 
}

ILinkedTextIterator *MemberHandler::initializer() const
{ 
  return new LinkedTextIterator(m_initializer); 
}

ILinkedTextIterator *MemberHandler::exceptions() const
{ 
  return new LinkedTextIterator(m_exception); 
}

IMemberReferenceIterator *MemberHandler::reimplementedBy() const
{ 
  return new MemberReferenceIterator(m_reimplementedBy); 
}

IDocRoot *MemberHandler::briefDescription() const
{ 
  return m_brief; 
}
    
IDocRoot *MemberHandler::detailedDescription() const
{ 
  return m_detailed; 
}

IDocRoot *MemberHandler::inbodyDescription() const
{ 
  return m_inbody; 
}