\hypertarget{classRequirement}{\section{\-Requirement \-Class \-Reference}
\label{classRequirement}\index{\-Requirement@{\-Requirement}}
}


{\ttfamily \#include $<$\-Requirement.\-h$>$}



\-Collaboration diagram for \-Requirement\-:\nopagebreak
\begin{figure}[H]
\begin{center}
\leavevmode
\includegraphics[width=350pt]{classRequirement__coll__graph}
\end{center}
\end{figure}
\subsection*{\-Public \-Member \-Functions}
\begin{DoxyCompactItemize}
\item 
\hyperlink{classRequirement_a736fc43bd4319803a378e96ff07d01a8}{\-Requirement} (\hyperlink{Requirement_8h_aa293759f8299cef93bbb4ac3b4ec5e30}{\-Requirement\-Type} type, int amount)
\item 
\hyperlink{classRequirement_acf3b479760619aabc418e6d82a44342d}{\-Requirement} (int priority, int duration, \hyperlink{Interface_8h_ab8fbb9e601c27f783b69f16c5a1fd40a}{\-Unit} unit, \hyperlink{Interface_8h_a7ae5d695cf6b7c013c5ad30d124278e0}{\-Position} position)
\item 
\hyperlink{classRequirement_ab0dfd17b84d1f9146341c32a697b2551}{\-Requirement} (int priority, int duration, \hyperlink{structUnitFilter}{\-Unit\-Filter} unit\-Filter, \hyperlink{Interface_8h_a7ae5d695cf6b7c013c5ad30d124278e0}{\-Position} position)
\item 
\hyperlink{classRequirement_ad1ad69df6ecd8f2fc87f37701fb13b55}{\-Requirement} (\hyperlink{Requirement_8h_a10d9e68ef4957f6a76bc93eb32bf2670}{\-Task\-Pointer} task)
\item 
\hyperlink{classRequirement_ad79cf3002374408f0a215621a7a4eff4}{\-Requirement} (\hyperlink{classBWAPI_1_1UnitType}{\-B\-W\-A\-P\-I\-::\-Unit\-Type} unit)
\item 
\hyperlink{classRequirement_aac9084dad18b122743f6fd17774a50bf}{\-Requirement} (\hyperlink{classBWAPI_1_1TechType}{\-B\-W\-A\-P\-I\-::\-Tech\-Type} tech)
\item 
\hyperlink{classRequirement_afc8fd380a29c36efa53c4d382231ccb7}{\-Requirement} (\hyperlink{classBWAPI_1_1UpgradeType}{\-B\-W\-A\-P\-I\-::\-Upgrade\-Type} upgrade, int level)
\item 
int \hyperlink{classRequirement_a62ddf2c2230180fa8bfa2f31af90d243}{earliest\-Time} ()
\item 
std\-::map$<$ int, int $>$ \hyperlink{classRequirement_adba3e80448b77fa6cefe6f2eef199c33}{earliest\-Unit\-Time} (int start\-Time, int end\-Time, std\-::set$<$ \hyperlink{Interface_8h_ab8fbb9e601c27f783b69f16c5a1fd40a}{\-Unit} $>$ \&current\-Units)
\item 
void \hyperlink{classRequirement_a44d269cdbb42f1d7b8e7fa79afc46d9a}{reserve} (int frame\-Time)
\item 
\hyperlink{Requirement_8h_aa293759f8299cef93bbb4ac3b4ec5e30}{\-Requirement\-Type} \hyperlink{classRequirement_a9820a2a5531a745a6550213c73795970}{get\-Type} ()
\item 
bool \hyperlink{classRequirement_a677bf4e89b75589a7bd300ad90903f36}{unit\-Requirement} ()
\item 
\hyperlink{Interface_8h_ab8fbb9e601c27f783b69f16c5a1fd40a}{\-Unit} \hyperlink{classRequirement_aa4e0b9d642d1e54c56b207b65e6a4cc4}{get\-Unit} () const 
\item 
int \hyperlink{classRequirement_a66be3576b8df403aa4116eddcf82a7f3}{get\-Delay} ()
\item 
bool \hyperlink{classRequirement_a7b6dd7f39494dac5782afd487b1281d7}{operator==} (const \hyperlink{classRequirement}{\-Requirement} \&other) const 
\item 
bool \hyperlink{classRequirement_aa3e14f48f5a314974eb243ae00046d92}{operator$<$} (const \hyperlink{classRequirement}{\-Requirement} \&other) const 
\end{DoxyCompactItemize}
\subsection*{\-Static \-Public \-Attributes}
\begin{DoxyCompactItemize}
\item 
static const int \hyperlink{classRequirement_a531592fa2181a048f64b4e1e876ec07d}{max\-Time} = std\-::numeric\-\_\-limits$<$int$>$\-::max()
\end{DoxyCompactItemize}
\subsection*{\-Private \-Member \-Functions}
\begin{DoxyCompactItemize}
\item 
int \hyperlink{classRequirement_a455aee817218fa85f66eb6e03e8467fc}{earliest\-Time\-For\-Type} (\hyperlink{classBWAPI_1_1UnitType}{\-B\-W\-A\-P\-I\-::\-Unit\-Type} unit\-Type)
\end{DoxyCompactItemize}
\subsection*{\-Private \-Attributes}
\begin{DoxyCompactItemize}
\item 
\hyperlink{Requirement_8h_aa293759f8299cef93bbb4ac3b4ec5e30}{\-Requirement\-Type} \hyperlink{classRequirement_a632366a32490e4f1353966a334d22cff}{m\-Type}
\item 
int \hyperlink{classRequirement_a578de0eb7228e8a3f01c12e3b270e81a}{m\-Amount}
\item 
\hyperlink{structUnitFilter}{\-Unit\-Filter} \hyperlink{classRequirement_aea6d57d8d9a30239eed5ca96c3ef4c15}{m\-Unit\-Filter}
\item 
\hyperlink{Interface_8h_ab8fbb9e601c27f783b69f16c5a1fd40a}{\-Unit} \hyperlink{classRequirement_acf78696642fcc8ce3fc7815923d4f7ef}{m\-Unit}
\item 
\hyperlink{Interface_8h_a7ae5d695cf6b7c013c5ad30d124278e0}{\-Position} \hyperlink{classRequirement_a1227bd87ef8df3e83b8de2f3b4990823}{m\-Position}
\item 
int \hyperlink{classRequirement_ae378299ef00bd412b3b976e88e090eca}{m\-Priority}
\item 
int \hyperlink{classRequirement_a54ed183668aedf5ef6237de18d89a574}{m\-Duration}
\item 
int \hyperlink{classRequirement_a7d2693735057b1ac6ff97c7f0fd5bdca}{m\-Delay}
\item 
\hyperlink{Requirement_8h_a10d9e68ef4957f6a76bc93eb32bf2670}{\-Task\-Pointer} \hyperlink{classRequirement_abc6543ab92900ba3afa355a3bcf1ed09}{m\-Task}
\item 
\hyperlink{classBWAPI_1_1UnitType}{\-B\-W\-A\-P\-I\-::\-Unit\-Type} \hyperlink{classRequirement_ad2f3236de8f4662286da8491ad0ae359}{m\-Unit\-Type}
\item 
\hyperlink{classBWAPI_1_1TechType}{\-B\-W\-A\-P\-I\-::\-Tech\-Type} \hyperlink{classRequirement_ab0a2817104720224eb4ab35762b8be70}{m\-Tech\-Type}
\item 
\hyperlink{classBWAPI_1_1UpgradeType}{\-B\-W\-A\-P\-I\-::\-Upgrade\-Type} \hyperlink{classRequirement_a1542a5d7a36fddcd4b188990359a4f57}{m\-Upgrade\-Type}
\end{DoxyCompactItemize}


\subsection{\-Detailed \-Description}


\-Definition at line 33 of file \-Requirement.\-h.



\subsection{\-Constructor \& \-Destructor \-Documentation}
\hypertarget{classRequirement_a736fc43bd4319803a378e96ff07d01a8}{\index{\-Requirement@{\-Requirement}!\-Requirement@{\-Requirement}}
\index{\-Requirement@{\-Requirement}!Requirement@{\-Requirement}}
\subsubsection[{\-Requirement}]{\setlength{\rightskip}{0pt plus 5cm}{\bf \-Requirement\-::\-Requirement} (
\begin{DoxyParamCaption}
\item[{{\bf \-Requirement\-Type}}]{type, }
\item[{int}]{amount}
\end{DoxyParamCaption}
)}}\label{classRequirement_a736fc43bd4319803a378e96ff07d01a8}


\-Definition at line 13 of file \-Requirement.\-cpp.


\begin{DoxyCode}
        : mType(type)
        , mAmount(amount)
        , mPosition(BWAPI::Positions::None)
        , mUnit()
        , mUnitFilter()
        , mUnitType(BWAPI::UnitTypes::None)
        , mTechType(BWAPI::TechTypes::None)
        , mUpgradeType(BWAPI::UpgradeTypes::None)
        , mTask()
        , mPriority(0)
        , mDuration(0)
        , mDelay(0)
{
}
\end{DoxyCode}
\hypertarget{classRequirement_acf3b479760619aabc418e6d82a44342d}{\index{\-Requirement@{\-Requirement}!\-Requirement@{\-Requirement}}
\index{\-Requirement@{\-Requirement}!Requirement@{\-Requirement}}
\subsubsection[{\-Requirement}]{\setlength{\rightskip}{0pt plus 5cm}{\bf \-Requirement\-::\-Requirement} (
\begin{DoxyParamCaption}
\item[{int}]{priority, }
\item[{int}]{duration, }
\item[{{\bf \-Unit}}]{unit, }
\item[{{\bf \-Position}}]{position}
\end{DoxyParamCaption}
)}}\label{classRequirement_acf3b479760619aabc418e6d82a44342d}


\-Definition at line 29 of file \-Requirement.\-cpp.


\begin{DoxyCode}
        : mType(RequirementType::Unit)
        , mAmount(1)
        , mPosition(position)
        , mUnit(unit)
        , mUnitFilter()
        , mUnitType(BWAPI::UnitTypes::None)
        , mTechType(BWAPI::TechTypes::None)
        , mUpgradeType(BWAPI::UpgradeTypes::None)
        , mTask()
        , mPriority(priority)
        , mDuration(duration)
        , mDelay(0)
{
}
\end{DoxyCode}
\hypertarget{classRequirement_ab0dfd17b84d1f9146341c32a697b2551}{\index{\-Requirement@{\-Requirement}!\-Requirement@{\-Requirement}}
\index{\-Requirement@{\-Requirement}!Requirement@{\-Requirement}}
\subsubsection[{\-Requirement}]{\setlength{\rightskip}{0pt plus 5cm}{\bf \-Requirement\-::\-Requirement} (
\begin{DoxyParamCaption}
\item[{int}]{priority, }
\item[{int}]{duration, }
\item[{{\bf \-Unit\-Filter}}]{unit\-Filter, }
\item[{{\bf \-Position}}]{position}
\end{DoxyParamCaption}
)}}\label{classRequirement_ab0dfd17b84d1f9146341c32a697b2551}


\-Definition at line 45 of file \-Requirement.\-cpp.


\begin{DoxyCode}
        : mType(RequirementType::UnitFilter)
        , mAmount(1)
        , mPosition(position)
        , mUnit()
        , mUnitFilter(unitFilter)
        , mUnitType(BWAPI::UnitTypes::None)
        , mTechType(BWAPI::TechTypes::None)
        , mUpgradeType(BWAPI::UpgradeTypes::None)
        , mTask()
        , mPriority(priority)
        , mDuration(duration)
        , mDelay(0)
{
}
\end{DoxyCode}
\hypertarget{classRequirement_ad1ad69df6ecd8f2fc87f37701fb13b55}{\index{\-Requirement@{\-Requirement}!\-Requirement@{\-Requirement}}
\index{\-Requirement@{\-Requirement}!Requirement@{\-Requirement}}
\subsubsection[{\-Requirement}]{\setlength{\rightskip}{0pt plus 5cm}{\bf \-Requirement\-::\-Requirement} (
\begin{DoxyParamCaption}
\item[{{\bf \-Task\-Pointer}}]{task}
\end{DoxyParamCaption}
)}}\label{classRequirement_ad1ad69df6ecd8f2fc87f37701fb13b55}


\-Definition at line 61 of file \-Requirement.\-cpp.


\begin{DoxyCode}
        : mType(RequirementType::Task)
        , mAmount(0)
        , mPosition(BWAPI::Positions::None)
        , mUnit()
        , mUnitFilter()
        , mUnitType(BWAPI::UnitTypes::None)
        , mTechType(BWAPI::TechTypes::None)
        , mUpgradeType(BWAPI::UpgradeTypes::None)
        , mTask(task)
        , mPriority(0)
        , mDuration(0)
        , mDelay(0)
{
}
\end{DoxyCode}
\hypertarget{classRequirement_ad79cf3002374408f0a215621a7a4eff4}{\index{\-Requirement@{\-Requirement}!\-Requirement@{\-Requirement}}
\index{\-Requirement@{\-Requirement}!Requirement@{\-Requirement}}
\subsubsection[{\-Requirement}]{\setlength{\rightskip}{0pt plus 5cm}{\bf \-Requirement\-::\-Requirement} (
\begin{DoxyParamCaption}
\item[{{\bf \-B\-W\-A\-P\-I\-::\-Unit\-Type}}]{unit}
\end{DoxyParamCaption}
)}}\label{classRequirement_ad79cf3002374408f0a215621a7a4eff4}


\-Definition at line 77 of file \-Requirement.\-cpp.


\begin{DoxyCode}
        : mType(RequirementType::RequiredForUnit)
        , mAmount(0)
        , mPosition(BWAPI::Positions::None)
        , mUnit()
        , mUnitFilter()
        , mUnitType(unit)
        , mTechType(BWAPI::TechTypes::None)
        , mUpgradeType(BWAPI::UpgradeTypes::None)
        , mTask()
        , mPriority(0)
        , mDuration(0)
        , mDelay(0)
{
}
\end{DoxyCode}
\hypertarget{classRequirement_aac9084dad18b122743f6fd17774a50bf}{\index{\-Requirement@{\-Requirement}!\-Requirement@{\-Requirement}}
\index{\-Requirement@{\-Requirement}!Requirement@{\-Requirement}}
\subsubsection[{\-Requirement}]{\setlength{\rightskip}{0pt plus 5cm}{\bf \-Requirement\-::\-Requirement} (
\begin{DoxyParamCaption}
\item[{{\bf \-B\-W\-A\-P\-I\-::\-Tech\-Type}}]{tech}
\end{DoxyParamCaption}
)}}\label{classRequirement_aac9084dad18b122743f6fd17774a50bf}


\-Definition at line 93 of file \-Requirement.\-cpp.


\begin{DoxyCode}
        : mType(RequirementType::RequiredForTech)
        , mAmount(0)
        , mPosition(BWAPI::Positions::None)
        , mUnit()
        , mUnitFilter()
        , mUnitType(BWAPI::UnitTypes::None)
        , mTechType(tech)
        , mUpgradeType(BWAPI::UpgradeTypes::None)
        , mTask()
        , mPriority(0)
        , mDuration(0)
        , mDelay(0)
{
}
\end{DoxyCode}
\hypertarget{classRequirement_afc8fd380a29c36efa53c4d382231ccb7}{\index{\-Requirement@{\-Requirement}!\-Requirement@{\-Requirement}}
\index{\-Requirement@{\-Requirement}!Requirement@{\-Requirement}}
\subsubsection[{\-Requirement}]{\setlength{\rightskip}{0pt plus 5cm}{\bf \-Requirement\-::\-Requirement} (
\begin{DoxyParamCaption}
\item[{{\bf \-B\-W\-A\-P\-I\-::\-Upgrade\-Type}}]{upgrade, }
\item[{int}]{level}
\end{DoxyParamCaption}
)}}\label{classRequirement_afc8fd380a29c36efa53c4d382231ccb7}


\-Definition at line 109 of file \-Requirement.\-cpp.


\begin{DoxyCode}
        : mType(RequirementType::RequiredForUpgrade)
        , mAmount(level)
        , mPosition(BWAPI::Positions::None)
        , mUnit()
        , mUnitFilter()
        , mUnitType(BWAPI::UnitTypes::None)
        , mTechType(BWAPI::TechTypes::None)
        , mUpgradeType(upgrade)
        , mTask()
        , mPriority(0)
        , mDuration(0)
        , mDelay(0)
{
}
\end{DoxyCode}


\subsection{\-Member \-Function \-Documentation}
\hypertarget{classRequirement_a62ddf2c2230180fa8bfa2f31af90d243}{\index{\-Requirement@{\-Requirement}!earliest\-Time@{earliest\-Time}}
\index{earliest\-Time@{earliest\-Time}!Requirement@{\-Requirement}}
\subsubsection[{earliest\-Time}]{\setlength{\rightskip}{0pt plus 5cm}int {\bf \-Requirement\-::earliest\-Time} (
\begin{DoxyParamCaption}
{}
\end{DoxyParamCaption}
)}}\label{classRequirement_a62ddf2c2230180fa8bfa2f31af90d243}


\-Definition at line 220 of file \-Requirement.\-cpp.



\-References earliest\-Time\-For\-Type(), \-Requirement\-Type\-Def\-::\-Gas, \-Singleton$<$ T $>$\-::\-Instance(), m\-Amount, max\-Time, \-Requirement\-Type\-Def\-::\-Mineral, m\-Task, m\-Tech\-Type, m\-Type, m\-Unit\-Type, m\-Upgrade\-Type, \-B\-W\-A\-P\-I\-::\-Upgrade\-Types\-::\-Protoss\-\_\-\-Air\-\_\-\-Armor, \-B\-W\-A\-P\-I\-::\-Upgrade\-Types\-::\-Protoss\-\_\-\-Air\-\_\-\-Weapons, \-B\-W\-A\-P\-I\-::\-Unit\-Types\-::\-Protoss\-\_\-\-Cybernetics\-\_\-\-Core, \-B\-W\-A\-P\-I\-::\-Unit\-Types\-::\-Protoss\-\_\-\-Fleet\-\_\-\-Beacon, \-B\-W\-A\-P\-I\-::\-Upgrade\-Types\-::\-Protoss\-\_\-\-Ground\-\_\-\-Armor, \-B\-W\-A\-P\-I\-::\-Upgrade\-Types\-::\-Protoss\-\_\-\-Ground\-\_\-\-Weapons, \-B\-W\-A\-P\-I\-::\-Upgrade\-Types\-::\-Protoss\-\_\-\-Plasma\-\_\-\-Shields, \-B\-W\-A\-P\-I\-::\-Unit\-Types\-::\-Protoss\-\_\-\-Templar\-\_\-\-Archives, \-Requirement\-Type\-Def\-::\-Required\-For\-Tech, \-Requirement\-Type\-Def\-::\-Required\-For\-Unit, \-Requirement\-Type\-Def\-::\-Required\-For\-Upgrade, \-B\-W\-A\-P\-I\-::\-Unit\-Type\-::required\-Units(), \-Requirement\-Type\-Def\-::\-Supply, \-Requirement\-Type\-Def\-::\-Task, \-Requirement\-Type\-Def\-::\-Time, \-B\-W\-A\-P\-I\-::\-Tech\-Type\-::what\-Researches(), and \-B\-W\-A\-P\-I\-::\-Upgrade\-Type\-::what\-Upgrades().


\begin{DoxyCode}
{
        if(mType == RequirementType::Mineral)
                return ResourceTracker::Instance().earliestMineralAvailability(
      mAmount);
        else if(mType == RequirementType::Gas)
                return ResourceTracker::Instance().earliestGasAvailability(
      mAmount);
        else if(mType == RequirementType::Supply)
                return ResourceTracker::Instance().earliestSupplyAvailability(
      mAmount);
        else if(mType == RequirementType::Time)
                return mAmount;
        else if(mType == RequirementType::Task)
                return mTask->getEndTime();
        else if(mType == RequirementType::RequiredForUnit)
        {
                int latestTime = 0;

                for(std::map<BWAPI::UnitType, int>::const_iterator it = 
      mUnitType.requiredUnits().begin(); it != mUnitType.requiredUnits().end(); ++it)
                        latestTime = std::max(latestTime, earliestTimeForType(
      it->first));

                return latestTime;
        }
        else if(mType == RequirementType::RequiredForUpgrade)
        {
                int latestTime = earliestTimeForType(mUpgradeType.whatUpgrades(
      ));

                if(mAmount > 1)
                {
                        if(mUpgradeType == 
      BWAPI::UpgradeTypes::Protoss_Ground_Weapons || mUpgradeType == 
      BWAPI::UpgradeTypes::Protoss_Ground_Armor)
                                latestTime = std::max(latestTime, 
      earliestTimeForType(BWAPI::UnitTypes::Protoss_Templar_Archives));
                        else if(mUpgradeType == 
      BWAPI::UpgradeTypes::Protoss_Plasma_Shields)
                                latestTime = std::max(latestTime, 
      earliestTimeForType(BWAPI::UnitTypes::Protoss_Cybernetics_Core));
                        else if(mUpgradeType == 
      BWAPI::UpgradeTypes::Protoss_Air_Armor || mUpgradeType == 
      BWAPI::UpgradeTypes::Protoss_Air_Weapons)
                                latestTime = std::max(latestTime, 
      earliestTimeForType(BWAPI::UnitTypes::Protoss_Fleet_Beacon));
                }

                return latestTime;
        }
        else if(mType == RequirementType::RequiredForTech)
                return earliestTimeForType(mTechType.whatResearches());

        return Requirement::maxTime;
}
\end{DoxyCode}


\-Here is the call graph for this function\-:\nopagebreak
\begin{figure}[H]
\begin{center}
\leavevmode
\includegraphics[width=350pt]{classRequirement_a62ddf2c2230180fa8bfa2f31af90d243_cgraph}
\end{center}
\end{figure}


\hypertarget{classRequirement_a455aee817218fa85f66eb6e03e8467fc}{\index{\-Requirement@{\-Requirement}!earliest\-Time\-For\-Type@{earliest\-Time\-For\-Type}}
\index{earliest\-Time\-For\-Type@{earliest\-Time\-For\-Type}!Requirement@{\-Requirement}}
\subsubsection[{earliest\-Time\-For\-Type}]{\setlength{\rightskip}{0pt plus 5cm}int {\bf \-Requirement\-::earliest\-Time\-For\-Type} (
\begin{DoxyParamCaption}
\item[{{\bf \-B\-W\-A\-P\-I\-::\-Unit\-Type}}]{unit\-Type}
\end{DoxyParamCaption}
)\hspace{0.3cm}{\ttfamily  \mbox{[}private\mbox{]}}}}\label{classRequirement_a455aee817218fa85f66eb6e03e8467fc}


\-Definition at line 352 of file \-Requirement.\-cpp.



\-References \-B\-W\-A\-P\-I\-::\-Broodwar, \-Singleton$<$ T $>$\-::\-Instance(), and max\-Time.



\-Referenced by earliest\-Time().


\begin{DoxyCode}
{
        int thisTime = Requirement::maxTime;
        for each(Unit requiredUnit in UnitTracker::Instance().selectAllUnits(
      unitType))
        {
                if(requiredUnit->isCompleted())
                        return BWAPI::Broodwar->getFrameCount();
                else
                {
                        int completeTime = requiredUnit->getCompletedTime();
                        if(completeTime < thisTime)
                                thisTime = completeTime;
                }
        }

        return thisTime;
}\end{DoxyCode}


\-Here is the call graph for this function\-:\nopagebreak
\begin{figure}[H]
\begin{center}
\leavevmode
\includegraphics[width=350pt]{classRequirement_a455aee817218fa85f66eb6e03e8467fc_cgraph}
\end{center}
\end{figure}




\-Here is the caller graph for this function\-:\nopagebreak
\begin{figure}[H]
\begin{center}
\leavevmode
\includegraphics[width=350pt]{classRequirement_a455aee817218fa85f66eb6e03e8467fc_icgraph}
\end{center}
\end{figure}


\hypertarget{classRequirement_adba3e80448b77fa6cefe6f2eef199c33}{\index{\-Requirement@{\-Requirement}!earliest\-Unit\-Time@{earliest\-Unit\-Time}}
\index{earliest\-Unit\-Time@{earliest\-Unit\-Time}!Requirement@{\-Requirement}}
\subsubsection[{earliest\-Unit\-Time}]{\setlength{\rightskip}{0pt plus 5cm}std\-::map$<$ int, int $>$ {\bf \-Requirement\-::earliest\-Unit\-Time} (
\begin{DoxyParamCaption}
\item[{int}]{start\-Time, }
\item[{int}]{end\-Time, }
\item[{std\-::set$<$ {\bf \-Unit} $>$ \&}]{current\-Units}
\end{DoxyParamCaption}
)}}\label{classRequirement_adba3e80448b77fa6cefe6f2eef199c33}


\-Definition at line 263 of file \-Requirement.\-cpp.



\-References \-Singleton$<$ T $>$\-::\-Instance(), max\-Time, m\-Delay, m\-Duration, m\-Position, m\-Priority, m\-Type, m\-Unit, m\-Unit\-Filter, \-B\-W\-A\-P\-I\-::\-Positions\-::\-None, \-Unit\-Filter\-::passes\-Filter(), and \-Requirement\-Type\-Def\-::\-Unit.


\begin{DoxyCode}
{
        const bool &allowAnyBlockLength = mDuration == Requirement::maxTime;

        if(mType == RequirementType::Unit)
        {
                if(currentUnits.count(mUnit) > 0)
                        return std::map<int, int>();

                if(mPosition != BWAPI::Positions::None)
                        mDelay = int((mUnit->getPosition().getApproxDistance(
      mPosition) * 1.6) / mUnit->getType().topSpeed()) + 15;

                return TaskManager::Instance().earliestFreeTimes(mUnit, 
      mPriority, startTime - mDelay, endTime, mDuration, allowAnyBlockLength);
        }

        std::map<int, int> bestTimes;
        int bestStartTime = Requirement::maxTime;
        int bestDelay = Requirement::maxTime;

        for each(Unit unit in UnitTracker::Instance().selectAllUnits())
        {
                if(currentUnits.count(unit) > 0)
                        continue;

                if(!mUnitFilter.passesFilter(unit))//TODO: only checks if it
       currently passes the filter, but some it can tell when in the future it will pass,
       might be worth implementing
                        continue;

                int delay = 0;
                if(mPosition != BWAPI::Positions::None)
                {
                        if(!unit->hasPath(mPosition))
                                continue;

                        delay = int((unit->getPosition().getApproxDistance(
      mPosition) * 1.6) / unit->getType().topSpeed()) + 15;
                }

                // If the delay for this unit pushes it outside the endtime,
       continue
                if(mDuration != Requirement::maxTime && startTime + mDuration +
       delay > endTime)
                        continue;

                const std::map<int, int> &currentTimes = TaskManager::Instance(
      ).earliestFreeTimes(unit, mPriority, startTime - delay, endTime, mDuration + 
      delay, allowAnyBlockLength);
                if(!currentTimes.empty())
                {
                        std::map<int, int> currentTimesPlusDelay;
                        for(std::map<int, int>::const_iterator it = 
      currentTimes.begin(); it != currentTimes.end(); ++it)
                                currentTimesPlusDelay[it->first + delay] = it->
      second;

                        // Find the earliest time in these blocks
                        std::map<int, int>::const_iterator it = 
      currentTimesPlusDelay.begin();
                        if(it != currentTimesPlusDelay.end())
                        {
                                // Save it if its the best we have found, also
       prefer if the delay is shorter so it
                                // doesn't choose a unit really far away even
       though it will make it in time
                                if(it->first < bestStartTime || (it->first == 
      bestStartTime && delay < bestDelay))
                                {
                                        mUnit = unit;
                                        mDelay = delay;
                                        
                                        bestTimes = currentTimesPlusDelay;
                                        bestStartTime = it->first;
                                        bestDelay = delay;
                                }
                        }
                }
        }

        return bestTimes;
}
\end{DoxyCode}


\-Here is the call graph for this function\-:\nopagebreak
\begin{figure}[H]
\begin{center}
\leavevmode
\includegraphics[width=350pt]{classRequirement_adba3e80448b77fa6cefe6f2eef199c33_cgraph}
\end{center}
\end{figure}


\hypertarget{classRequirement_a66be3576b8df403aa4116eddcf82a7f3}{\index{\-Requirement@{\-Requirement}!get\-Delay@{get\-Delay}}
\index{get\-Delay@{get\-Delay}!Requirement@{\-Requirement}}
\subsubsection[{get\-Delay}]{\setlength{\rightskip}{0pt plus 5cm}int {\bf \-Requirement\-::get\-Delay} (
\begin{DoxyParamCaption}
{}
\end{DoxyParamCaption}
)\hspace{0.3cm}{\ttfamily  \mbox{[}inline\mbox{]}}}}\label{classRequirement_a66be3576b8df403aa4116eddcf82a7f3}


\-Definition at line 56 of file \-Requirement.\-h.



\-References m\-Delay.


\begin{DoxyCode}
{ return mDelay; }
\end{DoxyCode}
\hypertarget{classRequirement_a9820a2a5531a745a6550213c73795970}{\index{\-Requirement@{\-Requirement}!get\-Type@{get\-Type}}
\index{get\-Type@{get\-Type}!Requirement@{\-Requirement}}
\subsubsection[{get\-Type}]{\setlength{\rightskip}{0pt plus 5cm}{\bf \-Requirement\-Type} {\bf \-Requirement\-::get\-Type} (
\begin{DoxyParamCaption}
{}
\end{DoxyParamCaption}
)\hspace{0.3cm}{\ttfamily  \mbox{[}inline\mbox{]}}}}\label{classRequirement_a9820a2a5531a745a6550213c73795970}


\-Definition at line 50 of file \-Requirement.\-h.



\-References m\-Type.


\begin{DoxyCode}
{ return mType; }
\end{DoxyCode}
\hypertarget{classRequirement_aa4e0b9d642d1e54c56b207b65e6a4cc4}{\index{\-Requirement@{\-Requirement}!get\-Unit@{get\-Unit}}
\index{get\-Unit@{get\-Unit}!Requirement@{\-Requirement}}
\subsubsection[{get\-Unit}]{\setlength{\rightskip}{0pt plus 5cm}{\bf \-Unit} {\bf \-Requirement\-::get\-Unit} (
\begin{DoxyParamCaption}
{}
\end{DoxyParamCaption}
) const\hspace{0.3cm}{\ttfamily  \mbox{[}inline\mbox{]}}}}\label{classRequirement_aa4e0b9d642d1e54c56b207b65e6a4cc4}


\-Definition at line 54 of file \-Requirement.\-h.



\-References m\-Unit.


\begin{DoxyCode}
{ return mUnit; }
\end{DoxyCode}
\hypertarget{classRequirement_aa3e14f48f5a314974eb243ae00046d92}{\index{\-Requirement@{\-Requirement}!operator$<$@{operator$<$}}
\index{operator$<$@{operator$<$}!Requirement@{\-Requirement}}
\subsubsection[{operator$<$}]{\setlength{\rightskip}{0pt plus 5cm}bool \-Requirement\-::operator$<$ (
\begin{DoxyParamCaption}
\item[{const {\bf \-Requirement} \&}]{other}
\end{DoxyParamCaption}
) const}}\label{classRequirement_aa3e14f48f5a314974eb243ae00046d92}


\-Definition at line 155 of file \-Requirement.\-cpp.



\-References m\-Amount, m\-Delay, m\-Duration, m\-Position, m\-Priority, m\-Task, m\-Tech\-Type, m\-Type, m\-Unit, m\-Unit\-Filter, m\-Unit\-Type, and m\-Upgrade\-Type.


\begin{DoxyCode}
{
        if(mType < other.mType)
                return true;
        else if(mType != other.mType)
                return false;

        if(mAmount < other.mAmount)
                return true;
        else if(mAmount != other.mAmount)
                return false;

        if(mUnitFilter < other.mUnitFilter)
                return true;
        else if(mUnitFilter != other.mUnitFilter)
                return false;

        if(mUnit < other.mUnit)
                return true;
        else if(mUnit != other.mUnit)
                return false;

        if(mPosition < other.mPosition)
                return true;
        else if(mPosition != other.mPosition)
                return false;

        if(mPriority < other.mPriority)
                return true;
        else if(mPriority != other.mPriority)
                return false;

        if(mDuration < other.mDuration)
                return true;
        else if(mDuration != other.mDuration)
                return false;

        if(mDelay < other.mDelay)
                return true;
        else if(mDelay != other.mDelay)
                return false;

        if(mTask < other.mTask)
                return true;
        else if(mTask != other.mTask)
                return false;

        if(mUnitType < other.mUnitType)
                return true;
        else if(mUnitType != other.mUnitType)
                return false;

        if(mTechType < other.mTechType)
                return true;
        else if(mTechType != other.mTechType)
                return false;

        if(mUpgradeType < other.mUpgradeType)
                return true;
        else if(mUpgradeType != other.mUpgradeType)
                return false;

        return false;
}
\end{DoxyCode}
\hypertarget{classRequirement_a7b6dd7f39494dac5782afd487b1281d7}{\index{\-Requirement@{\-Requirement}!operator==@{operator==}}
\index{operator==@{operator==}!Requirement@{\-Requirement}}
\subsubsection[{operator==}]{\setlength{\rightskip}{0pt plus 5cm}bool \-Requirement\-::operator== (
\begin{DoxyParamCaption}
\item[{const {\bf \-Requirement} \&}]{other}
\end{DoxyParamCaption}
) const}}\label{classRequirement_a7b6dd7f39494dac5782afd487b1281d7}


\-Definition at line 125 of file \-Requirement.\-cpp.



\-References m\-Amount, m\-Delay, m\-Duration, m\-Position, m\-Priority, m\-Task, m\-Tech\-Type, m\-Type, m\-Unit, m\-Unit\-Filter, m\-Unit\-Type, and m\-Upgrade\-Type.


\begin{DoxyCode}
{
        if(mType != other.mType)
                return false;
        else if(mAmount != other.mAmount)
                return false;
        else if(mUnitFilter != other.mUnitFilter)
                return false;
        else if(mUnit != other.mUnit)
                return false;
        else if(mPosition != other.mPosition)
                return false;
        else if(mPriority != other.mPriority)
                return false;
        else if(mDuration != other.mDuration)
                return false;
        else if(mDelay != other.mDelay)
                return false;
        else if(mTask != other.mTask)
                return false;
        else if(mUnitType != other.mUnitType)
                return false;
        else if(mTechType != other.mTechType)
                return false;
        else if(mUpgradeType != other.mUpgradeType)
                return false;
        else
                return true;
}
\end{DoxyCode}
\hypertarget{classRequirement_a44d269cdbb42f1d7b8e7fa79afc46d9a}{\index{\-Requirement@{\-Requirement}!reserve@{reserve}}
\index{reserve@{reserve}!Requirement@{\-Requirement}}
\subsubsection[{reserve}]{\setlength{\rightskip}{0pt plus 5cm}void {\bf \-Requirement\-::reserve} (
\begin{DoxyParamCaption}
\item[{int}]{frame\-Time}
\end{DoxyParamCaption}
)}}\label{classRequirement_a44d269cdbb42f1d7b8e7fa79afc46d9a}


\-Definition at line 332 of file \-Requirement.\-cpp.



\-References \-Requirement\-Type\-Def\-::\-Gas, \-Singleton$<$ T $>$\-::\-Instance(), m\-Amount, m\-Duration, \-Requirement\-Type\-Def\-::\-Mineral, m\-Priority, m\-Type, m\-Unit, \-Requirement\-Type\-Def\-::\-Supply, \-Safe\-Enum$<$ def, inner $>$\-::underlying(), \-Requirement\-Type\-Def\-::\-Unit, and \-Requirement\-Type\-Def\-::\-Unit\-Filter.


\begin{DoxyCode}
{
        switch(mType.underlying())
        {
        case RequirementType::Mineral:
                ResourceTracker::Instance().reservePlannedMinerals(frameTime, 
      mAmount);
                break;
        case RequirementType::Gas:
                ResourceTracker::Instance().reservePlannedGas(frameTime, mAmount
      );
                break;
        case RequirementType::Supply:
                ResourceTracker::Instance().reservePlannedSupply(frameTime, 
      mAmount);
                break;
        case RequirementType::Unit:
        case RequirementType::UnitFilter:
                TaskManager::Instance().reserveUnit(mUnit, frameTime, mPriority
      , mDuration);
                break;
        }
}
\end{DoxyCode}


\-Here is the call graph for this function\-:\nopagebreak
\begin{figure}[H]
\begin{center}
\leavevmode
\includegraphics[width=340pt]{classRequirement_a44d269cdbb42f1d7b8e7fa79afc46d9a_cgraph}
\end{center}
\end{figure}


\hypertarget{classRequirement_a677bf4e89b75589a7bd300ad90903f36}{\index{\-Requirement@{\-Requirement}!unit\-Requirement@{unit\-Requirement}}
\index{unit\-Requirement@{unit\-Requirement}!Requirement@{\-Requirement}}
\subsubsection[{unit\-Requirement}]{\setlength{\rightskip}{0pt plus 5cm}bool {\bf \-Requirement\-::unit\-Requirement} (
\begin{DoxyParamCaption}
{}
\end{DoxyParamCaption}
)\hspace{0.3cm}{\ttfamily  \mbox{[}inline\mbox{]}}}}\label{classRequirement_a677bf4e89b75589a7bd300ad90903f36}


\-Definition at line 52 of file \-Requirement.\-h.



\-References m\-Type, \-Requirement\-Type\-Def\-::\-Unit, and \-Requirement\-Type\-Def\-::\-Unit\-Filter.


\begin{DoxyCode}
{ return mType == RequirementType::Unit || mType == RequirementType::UnitFilter
      ; }
\end{DoxyCode}


\subsection{\-Member \-Data \-Documentation}
\hypertarget{classRequirement_a578de0eb7228e8a3f01c12e3b270e81a}{\index{\-Requirement@{\-Requirement}!m\-Amount@{m\-Amount}}
\index{m\-Amount@{m\-Amount}!Requirement@{\-Requirement}}
\subsubsection[{m\-Amount}]{\setlength{\rightskip}{0pt plus 5cm}int {\bf \-Requirement\-::m\-Amount}\hspace{0.3cm}{\ttfamily  \mbox{[}private\mbox{]}}}}\label{classRequirement_a578de0eb7228e8a3f01c12e3b270e81a}


\-Definition at line 65 of file \-Requirement.\-h.



\-Referenced by earliest\-Time(), operator$<$(), operator==(), and reserve().

\hypertarget{classRequirement_a531592fa2181a048f64b4e1e876ec07d}{\index{\-Requirement@{\-Requirement}!max\-Time@{max\-Time}}
\index{max\-Time@{max\-Time}!Requirement@{\-Requirement}}
\subsubsection[{max\-Time}]{\setlength{\rightskip}{0pt plus 5cm}const int {\bf \-Requirement\-::max\-Time} = std\-::numeric\-\_\-limits$<$int$>$\-::max()\hspace{0.3cm}{\ttfamily  \mbox{[}static\mbox{]}}}}\label{classRequirement_a531592fa2181a048f64b4e1e876ec07d}


\-Definition at line 61 of file \-Requirement.\-h.



\-Referenced by \-Task\-::dispatch\-Time(), \-Task\-Manager\-Class\-::earliest\-Free\-Times(), \-Resource\-Tracker\-Class\-::earliest\-Gas\-Availability(), \-Resource\-Tracker\-Class\-::earliest\-Mineral\-Availability(), \-Resource\-Tracker\-Class\-::earliest\-Supply\-Availability(), \-Requirement\-Group\-::earliest\-Time(), earliest\-Time(), earliest\-Time\-For\-Type(), earliest\-Unit\-Time(), \-Tech\-Task\-::get\-End\-Time(), \-Train\-Task\-::get\-End\-Time(), \-Upgrade\-Task\-::get\-End\-Time(), \-Idle\-Task\-::get\-End\-Time(), \-Default\-Squad\-Task\-::get\-End\-Time(), \-Mine\-Blocking\-Mineral\-Task\-::get\-End\-Time(), \-Construction\-Task\-::get\-End\-Time(), \-Gather\-Task\-::get\-End\-Time(), \-Defense\-Squad\-Task\-::get\-End\-Time(), \-Worker\-Scout\-Task\-::get\-End\-Time(), \-Observer\-Scout\-Task\-::get\-End\-Time(), \-Construction\-Task\-::pre\-Update(), \-Requirement\-Group\-::recurse\-For\-Unit\-Time(), \-Resource\-Tracker\-Class\-::reserve\-Current\-Gas(), \-Resource\-Tracker\-Class\-::reserve\-Current\-Minerals(), \-Resource\-Tracker\-Class\-::reserve\-Current\-Supply(), \-Resource\-Tracker\-Class\-::reserve\-Planned\-Gas(), \-Resource\-Tracker\-Class\-::reserve\-Planned\-Minerals(), \-Resource\-Tracker\-Class\-::reserve\-Planned\-Supply(), \-Task\-::start\-Time(), \-Construction\-Task\-::update\-Requirements(), \-Gather\-Task\-::update\-Requirements(), \-Mine\-Blocking\-Mineral\-Task\-::update\-Requirements(), \-Worker\-Scout\-Task\-::update\-Requirements(), \-Observer\-Scout\-Task\-::update\-Requirements(), \-Defense\-Squad\-Task\-::update\-Requirements(), and \-Default\-Squad\-Task\-::update\-Requirements().

\hypertarget{classRequirement_a7d2693735057b1ac6ff97c7f0fd5bdca}{\index{\-Requirement@{\-Requirement}!m\-Delay@{m\-Delay}}
\index{m\-Delay@{m\-Delay}!Requirement@{\-Requirement}}
\subsubsection[{m\-Delay}]{\setlength{\rightskip}{0pt plus 5cm}int {\bf \-Requirement\-::m\-Delay}\hspace{0.3cm}{\ttfamily  \mbox{[}private\mbox{]}}}}\label{classRequirement_a7d2693735057b1ac6ff97c7f0fd5bdca}


\-Definition at line 73 of file \-Requirement.\-h.



\-Referenced by earliest\-Unit\-Time(), get\-Delay(), operator$<$(), and operator==().

\hypertarget{classRequirement_a54ed183668aedf5ef6237de18d89a574}{\index{\-Requirement@{\-Requirement}!m\-Duration@{m\-Duration}}
\index{m\-Duration@{m\-Duration}!Requirement@{\-Requirement}}
\subsubsection[{m\-Duration}]{\setlength{\rightskip}{0pt plus 5cm}int {\bf \-Requirement\-::m\-Duration}\hspace{0.3cm}{\ttfamily  \mbox{[}private\mbox{]}}}}\label{classRequirement_a54ed183668aedf5ef6237de18d89a574}


\-Definition at line 72 of file \-Requirement.\-h.



\-Referenced by earliest\-Unit\-Time(), operator$<$(), operator==(), and reserve().

\hypertarget{classRequirement_a1227bd87ef8df3e83b8de2f3b4990823}{\index{\-Requirement@{\-Requirement}!m\-Position@{m\-Position}}
\index{m\-Position@{m\-Position}!Requirement@{\-Requirement}}
\subsubsection[{m\-Position}]{\setlength{\rightskip}{0pt plus 5cm}{\bf \-Position} {\bf \-Requirement\-::m\-Position}\hspace{0.3cm}{\ttfamily  \mbox{[}private\mbox{]}}}}\label{classRequirement_a1227bd87ef8df3e83b8de2f3b4990823}


\-Definition at line 70 of file \-Requirement.\-h.



\-Referenced by earliest\-Unit\-Time(), operator$<$(), and operator==().

\hypertarget{classRequirement_ae378299ef00bd412b3b976e88e090eca}{\index{\-Requirement@{\-Requirement}!m\-Priority@{m\-Priority}}
\index{m\-Priority@{m\-Priority}!Requirement@{\-Requirement}}
\subsubsection[{m\-Priority}]{\setlength{\rightskip}{0pt plus 5cm}int {\bf \-Requirement\-::m\-Priority}\hspace{0.3cm}{\ttfamily  \mbox{[}private\mbox{]}}}}\label{classRequirement_ae378299ef00bd412b3b976e88e090eca}


\-Definition at line 71 of file \-Requirement.\-h.



\-Referenced by earliest\-Unit\-Time(), operator$<$(), operator==(), and reserve().

\hypertarget{classRequirement_abc6543ab92900ba3afa355a3bcf1ed09}{\index{\-Requirement@{\-Requirement}!m\-Task@{m\-Task}}
\index{m\-Task@{m\-Task}!Requirement@{\-Requirement}}
\subsubsection[{m\-Task}]{\setlength{\rightskip}{0pt plus 5cm}{\bf \-Task\-Pointer} {\bf \-Requirement\-::m\-Task}\hspace{0.3cm}{\ttfamily  \mbox{[}private\mbox{]}}}}\label{classRequirement_abc6543ab92900ba3afa355a3bcf1ed09}


\-Definition at line 75 of file \-Requirement.\-h.



\-Referenced by earliest\-Time(), operator$<$(), and operator==().

\hypertarget{classRequirement_ab0a2817104720224eb4ab35762b8be70}{\index{\-Requirement@{\-Requirement}!m\-Tech\-Type@{m\-Tech\-Type}}
\index{m\-Tech\-Type@{m\-Tech\-Type}!Requirement@{\-Requirement}}
\subsubsection[{m\-Tech\-Type}]{\setlength{\rightskip}{0pt plus 5cm}{\bf \-B\-W\-A\-P\-I\-::\-Tech\-Type} {\bf \-Requirement\-::m\-Tech\-Type}\hspace{0.3cm}{\ttfamily  \mbox{[}private\mbox{]}}}}\label{classRequirement_ab0a2817104720224eb4ab35762b8be70}


\-Definition at line 78 of file \-Requirement.\-h.



\-Referenced by earliest\-Time(), operator$<$(), and operator==().

\hypertarget{classRequirement_a632366a32490e4f1353966a334d22cff}{\index{\-Requirement@{\-Requirement}!m\-Type@{m\-Type}}
\index{m\-Type@{m\-Type}!Requirement@{\-Requirement}}
\subsubsection[{m\-Type}]{\setlength{\rightskip}{0pt plus 5cm}{\bf \-Requirement\-Type} {\bf \-Requirement\-::m\-Type}\hspace{0.3cm}{\ttfamily  \mbox{[}private\mbox{]}}}}\label{classRequirement_a632366a32490e4f1353966a334d22cff}


\-Definition at line 64 of file \-Requirement.\-h.



\-Referenced by earliest\-Time(), earliest\-Unit\-Time(), get\-Type(), operator$<$(), operator==(), reserve(), and unit\-Requirement().

\hypertarget{classRequirement_acf78696642fcc8ce3fc7815923d4f7ef}{\index{\-Requirement@{\-Requirement}!m\-Unit@{m\-Unit}}
\index{m\-Unit@{m\-Unit}!Requirement@{\-Requirement}}
\subsubsection[{m\-Unit}]{\setlength{\rightskip}{0pt plus 5cm}{\bf \-Unit} {\bf \-Requirement\-::m\-Unit}\hspace{0.3cm}{\ttfamily  \mbox{[}private\mbox{]}}}}\label{classRequirement_acf78696642fcc8ce3fc7815923d4f7ef}


\-Definition at line 68 of file \-Requirement.\-h.



\-Referenced by earliest\-Unit\-Time(), get\-Unit(), operator$<$(), operator==(), and reserve().

\hypertarget{classRequirement_aea6d57d8d9a30239eed5ca96c3ef4c15}{\index{\-Requirement@{\-Requirement}!m\-Unit\-Filter@{m\-Unit\-Filter}}
\index{m\-Unit\-Filter@{m\-Unit\-Filter}!Requirement@{\-Requirement}}
\subsubsection[{m\-Unit\-Filter}]{\setlength{\rightskip}{0pt plus 5cm}{\bf \-Unit\-Filter} {\bf \-Requirement\-::m\-Unit\-Filter}\hspace{0.3cm}{\ttfamily  \mbox{[}private\mbox{]}}}}\label{classRequirement_aea6d57d8d9a30239eed5ca96c3ef4c15}


\-Definition at line 67 of file \-Requirement.\-h.



\-Referenced by earliest\-Unit\-Time(), operator$<$(), and operator==().

\hypertarget{classRequirement_ad2f3236de8f4662286da8491ad0ae359}{\index{\-Requirement@{\-Requirement}!m\-Unit\-Type@{m\-Unit\-Type}}
\index{m\-Unit\-Type@{m\-Unit\-Type}!Requirement@{\-Requirement}}
\subsubsection[{m\-Unit\-Type}]{\setlength{\rightskip}{0pt plus 5cm}{\bf \-B\-W\-A\-P\-I\-::\-Unit\-Type} {\bf \-Requirement\-::m\-Unit\-Type}\hspace{0.3cm}{\ttfamily  \mbox{[}private\mbox{]}}}}\label{classRequirement_ad2f3236de8f4662286da8491ad0ae359}


\-Definition at line 77 of file \-Requirement.\-h.



\-Referenced by earliest\-Time(), operator$<$(), and operator==().

\hypertarget{classRequirement_a1542a5d7a36fddcd4b188990359a4f57}{\index{\-Requirement@{\-Requirement}!m\-Upgrade\-Type@{m\-Upgrade\-Type}}
\index{m\-Upgrade\-Type@{m\-Upgrade\-Type}!Requirement@{\-Requirement}}
\subsubsection[{m\-Upgrade\-Type}]{\setlength{\rightskip}{0pt plus 5cm}{\bf \-B\-W\-A\-P\-I\-::\-Upgrade\-Type} {\bf \-Requirement\-::m\-Upgrade\-Type}\hspace{0.3cm}{\ttfamily  \mbox{[}private\mbox{]}}}}\label{classRequirement_a1542a5d7a36fddcd4b188990359a4f57}


\-Definition at line 79 of file \-Requirement.\-h.



\-Referenced by earliest\-Time(), operator$<$(), and operator==().



\-The documentation for this class was generated from the following files\-:\begin{DoxyCompactItemize}
\item 
\-Skynet/\-Skynet/\hyperlink{Requirement_8h}{\-Requirement.\-h}\item 
\-Skynet/\-Skynet/\hyperlink{Requirement_8cpp}{\-Requirement.\-cpp}\end{DoxyCompactItemize}
