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;
}
bool
AbstractTaskFactory::mutate_tps_to_task_type()
{
bool changed = remove_excess_tps_per_task_type();
for (unsigned int i = 0; i < m_task.TaskSize(); i++) {
OrderedTaskPoint *tp = m_task.get_tp(i);
if (!validType(*tp, i) ||
(m_task.get_factory_type() == TaskBehaviour::FACTORY_FAI_GENERAL)) {
LegalPointType_t newtype = getMutatedPointType(*tp);
if (is_position_finish(i)) {
if (!validFinishType(newtype)) {
newtype = m_behaviour.sector_defaults.finish_type;
if (!validFinishType(newtype))
newtype = *m_finish_types.begin();
}
FinishPoint *fp = (FinishPoint*)createMutatedPoint(*tp, newtype);
assert(fp);
if (replace(*fp, i, true))
changed = true;
delete fp;
} else if (i == 0) {
if (!validStartType(newtype)) {
newtype = m_behaviour.sector_defaults.start_type;
if (!validStartType(newtype))
newtype = *m_start_types.begin();
}
StartPoint *sp = (StartPoint*)createMutatedPoint(*tp, newtype);
assert(sp);
if (replace(*sp, i, true))
changed = true;
delete sp;
} else {
if (!validIntermediateType(newtype)) {
newtype = m_behaviour.sector_defaults.turnpoint_type;
if (!validIntermediateType(newtype))
newtype = *m_intermediate_types.begin();
}
OrderedTaskPoint *tpnew = (OrderedTaskPoint*)createMutatedPoint(*tp, newtype);
if (replace(*tpnew, i, true))
changed = true;
delete tpnew;
}
}
}
changed |= mutate_closed_finish_per_task_type();
return changed;
}
bool
AbstractTaskFactory::validAbstractType(LegalAbstractPointType_t type,
const unsigned position) const
{
const bool is_start = is_position_start(position);
const bool is_finish = is_position_finish(position);
const bool is_intermediate = is_position_intermediate(position);
switch (type) {
case POINT_START:
return is_start;
case POINT_FINISH:
return is_finish;
case POINT_AST:
return is_intermediate &&
(validIntermediateType(FAI_SECTOR)
|| validIntermediateType(AST_CYLINDER)
|| validIntermediateType(KEYHOLE_SECTOR)
|| validIntermediateType(BGAFIXEDCOURSE_SECTOR)
|| validIntermediateType(BGAENHANCEDOPTION_SECTOR));
case POINT_AAT:
return is_intermediate &&
(validIntermediateType(AAT_CYLINDER)
|| validIntermediateType(AAT_SEGMENT)
|| validIntermediateType(AAT_ANNULAR_SECTOR));
};
return false;
}
IntermediateTaskPoint*
AbstractTaskFactory::createIntermediate(const Waypoint &wp) const
{
if (get_ordered_task_behaviour().homogeneous_tps && m_task.TaskSize() > 1) {
LegalPointType_t type = getType(*m_task.get_tp(1));
if (validIntermediateType(type))
return createIntermediate(type, wp);
}
LegalPointType_t type = m_behaviour.sector_defaults.turnpoint_type;
if (!validIntermediateType(type))
type = *m_intermediate_types.begin();
return createIntermediate(type, wp);
}
IntermediateTaskPoint*
AbstractTaskFactory::createIntermediate(const LegalPointType_t type,
const Waypoint &wp) const
{
if (!validIntermediateType(type))
return NULL;
return (IntermediateTaskPoint*)createPoint(type, wp);
}
AbstractTaskFactory::LegalPointType_t
AbstractTaskFactory::getMutatedPointType(const OrderedTaskPoint &tp) const
{
const LegalPointType_t oldtype = getType(tp);
LegalPointType_t newtype = oldtype;
switch (tp.GetType()) {
case TaskPoint::START:
if (!validStartType(newtype)) {
newtype = m_behaviour.sector_defaults.start_type;
if (!validStartType(newtype))
newtype = *m_start_types.begin();
}
break;
case TaskPoint::AST:
case TaskPoint::AAT:
if (!validIntermediateType(newtype)) {
newtype = m_behaviour.sector_defaults.turnpoint_type;
if (!validIntermediateType(newtype)) {
newtype = *m_intermediate_types.begin();
}
}
break;
case TaskPoint::FINISH:
if (!validFinishType(newtype)) {
newtype = m_behaviour.sector_defaults.finish_type;
if (!validFinishType(newtype))
newtype = *m_finish_types.begin();
}
break;
case TaskPoint::UNORDERED:
case TaskPoint::ROUTE:
break;
}
return newtype;
}
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;
}
