bool
AbstractTaskFactory::validType(const OrderedTaskPoint &new_tp,
unsigned position) const
{
switch (new_tp.GetType()) {
case TaskPoint::START:
return validAbstractType(POINT_START, position) &&
validStartType(getType(new_tp));
case TaskPoint::AST:
return validAbstractType(POINT_AST, position) &&
validIntermediateType(getType(new_tp));
case TaskPoint::AAT:
return validAbstractType(POINT_AAT, position)&&
validIntermediateType(getType(new_tp));
case TaskPoint::FINISH:
return validAbstractType(POINT_FINISH, position)&&
validFinishType(getType(new_tp));
case TaskPoint::UNORDERED:
case TaskPoint::ROUTE:
/* obviously, when we check the type of an OrderedTaskPoint, we
should never get type==UNORDERED or ROUTE */
assert(false);
break;
}
return false;
}
AbstractTaskFactory::LegalPointVector
AbstractTaskFactory::getValidTypes(unsigned position) const
{
LegalPointVector v;
if (validAbstractType(POINT_START, position))
v.insert(v.end(), m_start_types.begin(), m_start_types.end());
LegalPointVector i = getValidIntermediateTypes(position);
if (!i.empty())
v.insert(v.end(), i.begin(), i.end());
if (validAbstractType(POINT_FINISH, position))
v.insert(v.end(), m_finish_types.begin(), m_finish_types.end());
return v;
}
AbstractTaskFactory::LegalPointVector
AbstractTaskFactory::getValidIntermediateTypes(unsigned position) const
{
LegalPointVector v;
if (!is_position_intermediate(position))
return v;
if (get_ordered_task_behaviour().homogeneous_tps
&& (position>1) && (m_task.task_size()>1)) {
LegalPointType_t type = getType(*m_task.get_tp(1));
if (validIntermediateType(type)) {
v.push_back(type);
return v;
}
}
if (validAbstractType(POINT_AAT, position) ||
validAbstractType(POINT_AST, position))
v.insert(v.end(), m_intermediate_types.begin(), m_intermediate_types.end());
return v;
}
