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; }