RequirementManager Class Reference

#include <src/requirement.h>

Classes
class	Private

Public Member Functions
void	addRequirement (Entry *e)
void	generatePage ()
void	writeTagFile (TextStream &tagFile)
void	addRequirementRefsForSymbol (const Definition *symbol)
const RequirementIntf *	find (const QCString &reqId) const
void	writeRef (OutputList &ol, const RequirementRef &ref)
RequirementIntfList	requirements () const
const PageDef *	requirementsPage () const

Static Public Member Functions
static RequirementManager &	instance ()

Private Member Functions
	RequirementManager ()

Private Attributes
std::unique_ptr< Private >	p

Detailed Description

Definition at line 76 of file requirement.h.

Constructor & Destructor Documentation

RequirementManager()

RequirementManager::RequirementManager ( )

private

Definition at line 105 of file requirement.cpp.

                                       : p(std::make_unique<Private>())
{
}

References p.

Referenced by instance().

Member Function Documentation

addRequirement()

void RequirementManager::addRequirement

(

Entry *

e

)

Definition at line 114 of file requirement.cpp.

{
  QCString tagFile;
  QCString extPage;
  if (!Config_getBool(GENERATE_REQUIREMENTS)) // still record the requirement, so we can refer to it.
  {
    if (e->tagInfo())
    {
      //printf("External requirement %s title=%s fileName=%s tagName=%s anchor=%s\n",
      //    qPrint(e->name),qPrint(e->type),qPrint(e->tagInfo()->fileName),qPrint(e->tagInfo()->tagName),qPrint(e->tagInfo()->anchor));
      tagFile = e->tagInfo()->tagName;
      extPage = e->tagInfo()->fileName;
      // register requirement id as anchor; for non-external links this is
      // done in commentscan.l in the comment block containing the @requirement command
      SectionManager::instance().add(e->name,"requirements",1,e->type,SectionType::Requirement,1);
    }
    p->requirements.add(e->name, e->fileName, e->startLine, e->type, e->doc, tagFile, extPage);
  }
  else
  {
    if (p->reqPageDef==nullptr)
    {
      p->reqPageDef = addRelatedPage("requirements",                      // name
          theTranslator->trRequirements(),     // ptitle
          QCString(),                          // doc
          "requirements",                      // fileName
          1,                                   // docLine
          1                                    // startLine
          );
    }
    //printf("requirement ID=%s title='%s' file=%s line=%d brief='%s' doc='%s'\n",
    //    qPrint(e->name), qPrint(e->type), qPrint(e->fileName), e->startLine, qPrint(e->brief), qPrint(e->doc));
    QCString title = parseCommentAsText(p->reqPageDef,nullptr,e->type,e->fileName,e->startLine);
    QCString doc = e->doc;
    if (e->tagInfo())
    {
      //printf("External requirement %s title=%s fileName=%s tagName=%s anchor=%s\n",
      //    qPrint(e->name),qPrint(e->type),qPrint(e->tagInfo()->fileName),qPrint(e->tagInfo()->tagName),qPrint(e->tagInfo()->anchor));
      tagFile = e->tagInfo()->tagName;
      extPage = e->tagInfo()->fileName;
      // register requirement id as anchor; for non-external links this is
      // done in commentscan.l in the comment block containing the @requirement command
      SectionManager::instance().add(e->name,"requirements",1,title,SectionType::Anchor,1);
    }
    if (!e->brief.isEmpty())
    {
      doc.prepend(e->brief+"\n<p>");
    }
    p->requirements.add(e->name, e->fileName, e->startLine, title, doc, tagFile, extPage);
 
    p->reqPageDef->setRefItems(e->sli);
  }
}

References SectionManager::add(), addRelatedPage(), SectionType::Anchor, Entry::brief, Config_getBool, Entry::doc, Entry::fileName, TagInfo::fileName, SectionManager::instance(), QCString::isEmpty(), Entry::name, p, parseCommentAsText(), QCString::prepend(), SectionType::Requirement, Entry::sli, Entry::startLine, Entry::tagInfo(), TagInfo::tagName, theTranslator, and Entry::type.

Referenced by buildRequirementsList().

addRequirementRefsForSymbol()

void RequirementManager::addRequirementRefsForSymbol

(

const Definition *

symbol

)

Definition at line 330 of file requirement.cpp.

{
  for (const auto &ref : symbol->requirementReferences())
  {
    Requirement *req = p->requirements.find(ref.reqId());
    if (req)
    {
      //printf("adding reference from %s to requirement %s\n",qPrint(symbol->name()),qPrint(ref.reqId()));
      switch (ref.type())
      {
        case RequirementRefType::Satisfies: req->addSatisfiedBy(symbol); break;
        case RequirementRefType::Verifies:  req->addVerifiedBy(symbol);   break;
      }
    }
    else
    {
      warn(ref.file(),ref.line(),"Reference to unknown requirement '{}' found",ref.reqId());
      // invalid reference (file, and line needed)
    }
  }
}

References Requirement::addSatisfiedBy(), Requirement::addVerifiedBy(), p, Definition::requirementReferences(), Satisfies, Verifies, and warn.

Referenced by ClassDefImpl::addRequirementReferences(), ConceptDefImpl::addRequirementReferences(), DirDefImpl::addRequirementReferences(), FileDefImpl::addRequirementReferences(), GroupDefImpl::addRequirementReferences(), MemberDefImpl::addRequirementReferences(), ModuleDefImpl::addRequirementReferences(), NamespaceDefImpl::addRequirementReferences(), and PageDefImpl::addRequirementReferences().

find()

const RequirementIntf * RequirementManager::find

(

const QCString &

reqId

)

const

Definition at line 325 of file requirement.cpp.

{
  return p->requirements.find(reqId);
}

References p.

Referenced by generatePage(), and writeRef().

generatePage()

void RequirementManager::generatePage

(

)

Definition at line 178 of file requirement.cpp.

{
  AUTO_TRACE("#requirements={}",p->requirements.size());
  if (!Config_getBool(GENERATE_REQUIREMENTS) || p->requirements.empty()) return;
  std::vector<const SectionInfo*> anchors;
  std::stable_sort(p->requirements.begin(),p->requirements.end(),
                   [](const auto &left,const auto &right) { return qstricmp(left->id(),right->id()) < 0; });
  QCString doc = "<table class=\"doxtable reqlist\">";
  doc.reserve(10*1024); // prevent too many reallocs
  doc += "<tr><th>";
  doc += theTranslator->trRequirementID();
  doc += "</th><th>";
  doc += "</th>";
  using RequirementPtrVector = std::vector<const Requirement*>;
  RequirementPtrVector missingSatisfiedRef, missingVerifiedRef;
  for (const auto &req : p->requirements) // TODO: filter out external references?
  {
    if (const SectionInfo *si = SectionManager::instance().find(req->id()); si!=nullptr)
    {
      anchors.push_back(si);
    }
    doc += "<tr><td valign=\"top\">";
    doc += " \\ifile \""+req->file()+"\" \\iline "+QCString().setNum(req->line())+" ";
    doc += "\\anchor ";
    doc += req->id();
    doc += " ";
    doc += "<span class=\"req_id\">";
    if (QCString tagFile = req->getTagFile(); !tagFile.isEmpty())
    {
      //printf("tagFile=%s extPage=%s\n",qPrint(tagFile),qPrint(req->getExtPage()));
      doc += "<a href=\"";
      doc += createHtmlUrl(QCString(),tagFile,true,false,req->getExtPage(),req->id());
      doc +="\">"+req->id()+"</a>";
    }
    else
    {
      doc += req->id();
    }
    doc += "</span> ";
    doc += "</td><td>";
    doc += "<div class=\"req_title\">"+req->title()+"</div>";
    doc += "<div class=\"req_docs\">";
    doc += req->doc();
    req->sortReferences();
    auto symToString = [](const Definition *sym)
    {
      QCString symName = sym->qualifiedName();
      if (sym->definitionType()==Definition::TypeMember)
      {
        const MemberDef *md = toMemberDef(sym);
        if (!md->isObjCMethod() && md->isFunctionOrSignalSlot()) symName += "()";
      }
      return symName;
    };
    int numSatisfiedBy = static_cast<int>(req->satisfiedBy().size());
    if (numSatisfiedBy>0)
    {
      doc += "<p><div class=\"satisfiedby\">";
      doc += theTranslator->trSatisfiedBy(
                 writeMarkerList(theTranslator->trWriteList(numSatisfiedBy).str(),
                     numSatisfiedBy,
                     [&symToString, &refs = req->satisfiedBy()](size_t entryIndex) {
                       return symToString(refs[entryIndex]);
                     }));
      doc += "</div></p>";
    }
    else
    {
      missingSatisfiedRef.push_back(req.get());
    }
    int numVerifiedBy = static_cast<int>(req->verifiedBy().size());
    if (numVerifiedBy>0)
    {
      doc += "<p><div class=\"verifiedby\">";
      doc += theTranslator->trVerifiedBy(
                 writeMarkerList(theTranslator->trWriteList(numVerifiedBy).str(),
                     numVerifiedBy,
                     [&symToString, &refs = req->verifiedBy()](size_t entryIndex) {
                       return symToString(refs[entryIndex]);
                     }));
      doc += "</div></p>";
    }
    else
    {
      missingVerifiedRef.push_back(req.get());
    }
    doc += "\n</div></td></tr>\n";
  }
  doc += "</table>\n";
 
  //------------
  doc += " \\ifile \"requirements\" \\iline 1\n";
 
  auto writeMissingRef = [&doc,&anchors](const RequirementPtrVector &reqs,
                                         const char *label,const QCString &section,const QCString &text)
  {
    if (!reqs.empty())
    {
      SectionManager &sm = SectionManager::instance();
      const SectionInfo *si = sm.add(QCString("missing_")+label,"requirements",1,section,SectionType::Section,1);
      anchors.push_back(si);
      doc += "\\htmlonly <div class=\"missing_";
      doc += label;
      doc += "\">\\endhtmlonly\n";
      doc += QCString("@section missing_")+label+" "+section+"\n"+text+"\n";
      doc += "\\htmlonly </div>\\endhtmlonly\n";
    }
  };
 
  // write list of requirements that do not have a satisfies relation
  auto traceInfo = Config_getEnum(REQ_TRACEABILITY_INFO);
  int numMissingSatisfied = static_cast<int>(missingSatisfiedRef.size());
  if ((traceInfo==REQ_TRACEABILITY_INFO_t::YES || traceInfo==REQ_TRACEABILITY_INFO_t::UNSATISFIED_ONLY) && numMissingSatisfied>0)
  {
    writeMissingRef(missingSatisfiedRef,
                    "satisfies",
                    theTranslator->trUnsatisfiedRequirements(),
                    theTranslator->trUnsatisfiedRequirementsText(numMissingSatisfied==1,
                     writeMarkerList(theTranslator->trWriteList(numMissingSatisfied).str(),
                       numMissingSatisfied,
                       [&missingSatisfiedRef](size_t entryIndex) {
                         QCString id = missingSatisfiedRef[entryIndex]->id();
                         return "@ref "+id + " \""+id+"\"";
                       })));
  }
 
  // write list of requirements that do not have a verifies relation
  int numMissingVerified = static_cast<int>(missingVerifiedRef.size());
  if ((traceInfo==REQ_TRACEABILITY_INFO_t::YES || traceInfo==REQ_TRACEABILITY_INFO_t::UNVERIFIED_ONLY) && numMissingVerified>0)
  {
    writeMissingRef(missingVerifiedRef,
                    "verifies",
                    theTranslator->trUnverifiedRequirements(),
                    theTranslator->trUnverifiedRequirementsText(numMissingVerified==1,
                     writeMarkerList(theTranslator->trWriteList(numMissingVerified).str(),
                       numMissingVerified,
                       [&missingVerifiedRef](size_t entryIndex) {
                         QCString id = missingVerifiedRef[entryIndex]->id();
                         return "@ref "+id + " \""+id+"\"";
                       })));
  }
 
  AUTO_TRACE_ADD("doc=[[\n{}\n]]\n",doc);
  p->reqPageDef->setDocumentation(doc,"requirements",1,false);
  p->reqPageDef->addSectionsToDefinition(anchors);
}

References SectionManager::add(), AUTO_TRACE, AUTO_TRACE_ADD, Config_getBool, Config_getEnum, createHtmlUrl(), find(), SectionManager::instance(), QCString::isEmpty(), MemberDef::isFunctionOrSignalSlot(), MemberDef::isObjCMethod(), p, QCString::reserve(), SectionType::Section, QCString::setNum(), theTranslator, toMemberDef(), Definition::TypeMember, and writeMarkerList().

Referenced by parseInput().

instance()

RequirementManager & RequirementManager::instance ( )

static

Definition at line 99 of file requirement.cpp.

{
  static RequirementManager s_instance;
  return s_instance;
}

References RequirementManager().

Referenced by ClassDefImpl::addRequirementReferences(), ConceptDefImpl::addRequirementReferences(), DirDefImpl::addRequirementReferences(), FileDefImpl::addRequirementReferences(), GroupDefImpl::addRequirementReferences(), MemberDefImpl::addRequirementReferences(), ModuleDefImpl::addRequirementReferences(), NamespaceDefImpl::addRequirementReferences(), PageDefImpl::addRequirementReferences(), buildRequirementsList(), generateXML(), generateXMLForRequirement(), DocParser::handleLinkedWord(), parseInput(), writeRef(), and writeTagFile().

requirements()

RequirementIntfList RequirementManager::requirements

(

)

const

Definition at line 168 of file requirement.cpp.

{
  RequirementIntfList result;
  for (const auto &req : p->requirements)
  {
    result.push_back(req.get());
  }
  return result;
}

References p.

requirementsPage()

const PageDef * RequirementManager::requirementsPage

(

)

const

Definition at line 109 of file requirement.cpp.

{
  return p->reqPageDef;
}

References p.

writeRef()

void RequirementManager::writeRef	(	OutputList &	ol,
		const RequirementRef &	ref )

Definition at line 353 of file requirement.cpp.

{
  if (!Config_getBool(GENERATE_REQUIREMENTS)) return;
  if (const RequirementIntf *req = RequirementManager::instance().find(ref.reqId()); req!=nullptr)
  {
    QCString title = ref.reqId();
    if (!ref.title().isEmpty())
    {
      title +=" (";
      title += parseCommentAsText(p->reqPageDef,nullptr,ref.title(),ref.file(),ref.line());
      title +=")";
    }
    else if (!req->title().isEmpty())
    {
      title += " (";
      title += req->title();
      title += ")";
    }
    else
    {
      title = ref.reqId();
    }
    ol.writeObjectLink(QCString(),req->getOutputFileBase(),ref.reqId(),title);
  }
  else
  {
    ol.docify(ref.reqId());
  }
}

References Config_getBool, OutputList::docify(), RequirementRef::file(), find(), instance(), QCString::isEmpty(), RequirementRef::line(), p, parseCommentAsText(), RequirementRef::reqId(), RequirementRef::title(), and OutputList::writeObjectLink().

writeTagFile()

void RequirementManager::writeTagFile

(

TextStream &

tagFile

)

Definition at line 383 of file requirement.cpp.

{
  if (!Config_getBool(GENERATE_REQUIREMENTS)) return;
  if (!p->requirements.empty())
  {
    for (const auto &req : p->requirements)
    {
      tagFile << "  <compound kind=\"requirement\">\n";
      tagFile << "    <id>" << req->id() << "</id>\n";
      tagFile << "    <title>" << convertToXML(req->title()) << "</title>\n";
      QCString fn = req->getOutputFileBase();
      addHtmlExtensionIfMissing(fn);
      tagFile << "    <filename>" << fn << "</filename>\n";
      tagFile << "  </compound>\n";
    }
  }
}

References addHtmlExtensionIfMissing(), Config_getBool, convertToXML(), and p.

Referenced by writeTagFile().

Member Data Documentation

p

std::unique_ptr<Private> RequirementManager::p

private

Definition at line 91 of file requirement.h.

Referenced by addRequirement(), addRequirementRefsForSymbol(), find(), generatePage(), RequirementManager(), requirements(), requirementsPage(), writeRef(), and writeTagFile().

---

The documentation for this class was generated from the following files:

• src/requirement.h
• src/requirement.cpp