C++ TaskManager::GetFactory方法代码示例

bool test_task_or(TaskManager& task_manager,
                  const Waypoints &waypoints)
{
    const Waypoint *wp;

    task_manager.SetFactory(TaskFactoryType::FAI_OR);
    AbstractTaskFactory &fact = task_manager.GetFactory();

    task_report(task_manager, "# adding start\n");
    wp = waypoints.LookupId(1);
    if (wp) {
        OrderedTaskPoint *tp = fact.CreateStart(*wp);
        if (!fact.Append(*tp)) {
            return false;
        }
        delete tp;
    }

    task_manager.SetActiveTaskPoint(0);
    task_manager.Resume();

    task_report(task_manager, "# adding intermediate\n");
    wp = waypoints.LookupId(2);
    if (wp) {
        OrderedTaskPoint *tp = fact.CreateIntermediate(*wp);
        if (!fact.Append(*tp)) {
            return false;
        }
        delete tp;
    }

    task_report(task_manager, "# adding finish\n");
    wp = waypoints.LookupId(1);
    if (wp) {
        OrderedTaskPoint *tp = fact.CreateFinish(*wp);
        if (!fact.Append(*tp)) {
            return false;
        }
        delete tp;
    }

    fact.UpdateStatsGeometry();

    task_report(task_manager, "# checking task..\n");
    if (!fact.Validate()) {
        return false;
    }

    if (!task_manager.CheckOrderedTask()) {
        return false;
    }
    return true;

}

bool test_task_bad(TaskManager& task_manager,
                   const Waypoints& waypoints)
{
  test_task_random(task_manager,waypoints,2);

  task_manager.SetFactory(TaskFactoryType::RACING);
  AbstractTaskFactory& fact = task_manager.GetFactory();

  const Waypoint* wp = random_waypoint(waypoints);

  ok (!fact.CreateFinish((TaskPointFactoryType)20,*wp),"bad finish type",0);
  ok (!fact.CreateStart((TaskPointFactoryType)20,*wp),"bad start type",0);
  ok (!fact.CreateIntermediate((TaskPointFactoryType)20,*wp),"bad intermediate type",0);

  // now create a taskpoint from FAI

  const TaskPointFactoryType s = GetRandomType(fact.GetIntermediateTypes());

  // test it is bad for AAT

  task_manager.SetFactory(TaskFactoryType::AAT);

  AbstractTaskFactory& bfact = task_manager.GetFactory();

  ok (!bfact.CreateIntermediate(s,*wp),"bad intermediate type (after task change)",0);

  bfact.Remove(1);
  bfact.UpdateStatsGeometry();
  ok (bfact.Validate(),"ok with one tp",0);

  bfact.Remove(1);
  bfact.UpdateStatsGeometry();
  ok (bfact.Validate(),"ok with zero tps (just start and finish)",0);

  ok (bfact.Remove(task_manager.TaskSize()-1,false),"remove finish manually",0);
  bfact.UpdateStatsGeometry();
  ok (!bfact.Validate(),"aat is invalid (no finish)",0);

  return true;
}

static void
CreateDefaultTask(TaskManager &task_manager, const Waypoints &way_points)
{
  const TCHAR start_name[] = _T("Bergneustadt");

  task_manager.set_factory(OrderedTask::FactoryType::MIXED);
  AbstractTaskFactory &factory = task_manager.GetFactory();

  const Waypoint *wp;
  OrderedTaskPoint *tp;

  wp = way_points.lookup_name(start_name);
  if (wp != NULL) {
    tp = factory.createStart(AbstractTaskFactory::START_LINE, *wp);
    if (!factory.append(tp, false)) {
      fprintf(stderr, "Failed to create start point\n");
    }
  } else {
    fprintf(stderr, "No start waypoint\n");
  }

  wp = way_points.lookup_name(_T("Uslar"));
  if (wp != NULL) {
    tp = factory.createIntermediate(AbstractTaskFactory::AST_CYLINDER, *wp);
    if (!factory.append(tp, false)) {
      fprintf(stderr, "Failed to create turn point\n");
    }
  } else {
    fprintf(stderr, "No turn point\n");
  }

  wp = way_points.lookup_name(_T("Suhl Goldlaut"));
  if (wp != NULL) {
    tp = factory.createIntermediate(AbstractTaskFactory::AST_CYLINDER, *wp);
    if (!factory.append(tp, false)) {
      fprintf(stderr, "Failed to create turn point\n");
    }
  } else {
    fprintf(stderr, "No turn point\n");
  }

  wp = way_points.lookup_name(start_name);
  if (wp != NULL) {
    tp = factory.createFinish(AbstractTaskFactory::FINISH_LINE, *wp);
    if (!factory.append(tp, false)) {
      fprintf(stderr, "Failed to create finish point\n");
    }
  } else {
    fprintf(stderr, "No finish waypoint\n");
  }
}

void
task_report(const TaskManager &task_manager, const char *text)
{
    AircraftState ac;
    if (verbose) {
        printf("%s",text);

        const AbstractTask *task = task_manager.GetActiveTask();
        if (task != NULL) {
            switch (task->GetType()) {
            case TaskType::NONE:
                printf("# task is none\n");
                break;

            case TaskType::ORDERED:
                printf("# task is ordered\n");
                task_manager.GetFactory().UpdateGeometry();
                break;

            case TaskType::ABORT:
                printf("# task is abort\n");
                break;

            case TaskType::GOTO:
                printf("# task is goto\n");
                break;
            }

            TaskPointVisitorPrint tpv;
            task->AcceptTaskPointVisitor(tpv);
            printf("# - dist nominal %g\n",
                   (double)task->GetStats().distance_nominal);

            if (task->GetType() == TaskType::ORDERED &&
                    task->GetStats().distance_max > task->GetStats().distance_min) {
                printf("# - dist max %g\n", (double)task->GetStats().distance_max);
                printf("# - dist min %g\n", (double)task->GetStats().distance_min);
            }
        }

        PrintHelper::taskmanager_print(task_manager, ac);
    }
    if (interactive>1) {
        WaitPrompt();
    }
}

bool test_task_dash(TaskManager& task_manager,
                    const Waypoints &waypoints)
{
  WaypointPtr wp;

  task_manager.SetFactory(TaskFactoryType::TOURING);
  AbstractTaskFactory &fact = task_manager.GetFactory();

  task_report(task_manager, "# adding start\n");
  wp = waypoints.LookupId(1);
  if (wp) {
    OrderedTaskPoint *tp = fact.CreateStart(std::move(wp));
    if (!fact.Append(*tp)) {
      return false;
    }
    delete tp;
  }

  task_manager.SetActiveTaskPoint(0);
  task_manager.Resume();

  task_report(task_manager, "# adding finish\n");
  wp = waypoints.LookupId(3);
  if (wp) {
    OrderedTaskPoint *tp = fact.CreateFinish(std::move(wp));
    if (!fact.Append(*tp)) {
      return false;
    }
    delete tp;
  }

  fact.UpdateStatsGeometry();

  task_report(task_manager, "# checking task..\n");
  if (!fact.Validate()) {
    return false;
  }

  if (!task_manager.CheckOrderedTask()) {
    return false;
  }
  return true;

}

bool test_task_random_RT_AAT_FAI(TaskManager& task_manager,
                                 const Waypoints &waypoints,
                                 const unsigned _num_points)
{
    const Waypoint *wp;

    OrderedTaskPoint *tp;
    char tmp[255];
    char tskType[20];
    tskType[0] = '\0';


    switch (rand() %3) {
    case 0:
        task_manager.SetFactory(TaskFactoryType::AAT);
        strcpy(tskType,"AAT");
        test_note("# creating random AAT task\n");
        break;
    case 1:
        task_manager.SetFactory(TaskFactoryType::RACING);
        strcpy(tskType,"RT");
        test_note("# creating random RT task\n");
        break;
    case 2:
        task_manager.SetFactory(TaskFactoryType::FAI_GENERAL);
        strcpy(tskType,"FAI");
        test_note("# creating random FAI GENERAL\n");
        break;
    }

    AbstractTaskFactory &fact = task_manager.GetFactory();

    //max points includes start & finish
    const TaskFactoryConstraints &constraints =
        task_manager.GetOrderedTask().GetFactoryConstraints();
    const unsigned num_points_total =
        std::max(constraints.min_points,
                 _num_points % constraints.max_points) + 1;
    const unsigned num_int_points = num_points_total - 2;

    test_note("# adding start\n");
    wp = random_waypoint(waypoints);
    if (wp) {
        const TaskPointFactoryType s = GetRandomType(fact.GetStartTypes());

        tp = fact.CreateStart(s,*wp);
        if (!fact.Append(*tp,false)) {
            return false;
        }
        delete tp;
    }

    for (unsigned i=0; i<num_int_points; i++) {
        test_note("# adding intermediate\n");
        wp = random_waypoint(waypoints);
        if (wp) {
            const TaskPointFactoryType s = GetRandomType(fact.GetIntermediateTypes());

            tp = fact.CreateIntermediate(s,*wp);
            if (!fact.Append(*tp,false)) {
                return false;
            }
            delete tp;
        }
    }

    test_note("# adding finish\n");
    wp = random_waypoint(waypoints);
    if (wp) {
        const TaskPointFactoryType s = GetRandomType(fact.GetFinishTypes());

        tp = fact.CreateFinish(s,*wp);
        if (!fact.Append(*tp,false)) {
            return false;
        }
        delete tp;
    }

    fact.UpdateStatsGeometry();

    test_note("# validating task..\n");
    if (!fact.Validate()) {
        return false;
    }
    if (task_manager.GetOrderedTask().GetFactoryType()
            == TaskFactoryType::FAI_GENERAL)
    {
        test_note("# checking OZs for FAI General..\n");
        if (!fact.ValidateFAIOZs())
            return false;
    }

    if (task_manager.GetOrderedTask().GetFactoryType()
            == TaskFactoryType::MAT)
    {
        test_note("# checking OZs for MAT General..\n");
        if (!fact.ValidateMATOZs())
            return false;
    }
    task_manager.Resume();
//.........这里部分代码省略.........

bool test_task_random(TaskManager& task_manager,
                      const Waypoints &waypoints,
                      const unsigned num_points)
{
    const Waypoint *wp;

    OrderedTaskPoint *tp;

    task_manager.SetFactory(TaskFactoryType::MIXED);
    AbstractTaskFactory &fact = task_manager.GetFactory();

    task_report(task_manager, "# adding start\n");
    wp = random_waypoint(waypoints);
    if (wp) {
        const TaskPointFactoryType s = GetRandomType(fact.GetStartTypes());

        tp = fact.CreateStart(s,*wp);
        if (!fact.Append(*tp,false)) {
            return false;
        }
        delete tp;
    }

    task_manager.SetActiveTaskPoint(0);
    task_manager.Resume();

    for (unsigned i=0; i<num_points; i++) {
        task_report(task_manager, "# adding intermediate\n");
        wp = random_waypoint(waypoints);
        if (wp) {
            const TaskPointFactoryType s = GetRandomType(fact.GetIntermediateTypes());

            tp = fact.CreateIntermediate(s,*wp);
            if (!fact.Append(*tp,false)) {
                return false;
            }
            delete tp;
        }
    }

    task_report(task_manager, "# adding finish\n");
    wp = random_waypoint(waypoints);
    if (wp) {
        const TaskPointFactoryType s = GetRandomType(fact.GetFinishTypes());

        tp = fact.CreateFinish(s,*wp);
        if (!fact.Append(*tp,false)) {
            return false;
        }
        delete tp;
    }

    fact.UpdateStatsGeometry();

    task_report(task_manager, "# validating task..\n");
    if (!fact.Validate()) {
        return false;
    }
    task_report(task_manager, "# checking task..\n");
    if (!task_manager.CheckOrderedTask()) {
        return false;
    }
    return true;
}

bool test_task_aat(TaskManager& task_manager,
                   const Waypoints &waypoints)
{
    task_manager.SetFactory(TaskFactoryType::AAT);
    AbstractTaskFactory &fact = task_manager.GetFactory();
    const Waypoint *wp;

    task_report(task_manager, "# adding start\n");
    wp = waypoints.LookupId(1);
    if (wp) {
        OrderedTaskPoint *tp = fact.CreateStart(*wp);
        if (!fact.Append(*tp,false)) {
            return false;
        }
        delete tp;
    }

    task_manager.SetActiveTaskPoint(0);
    task_manager.Resume();

    task_report(task_manager, "# adding intermediate\n");
    wp = waypoints.LookupId(2);
    if (wp) {
        OrderedTaskPoint* tp = fact.CreateIntermediate(TaskPointFactoryType::AAT_CYLINDER,*wp);
        if (tp->GetObservationZone().GetShape() == ObservationZone::Shape::CYLINDER) {
            CylinderZone &cz = (CylinderZone &)tp->GetObservationZone();
            cz.SetRadius(fixed(30000.0));
        }
        if (!fact.Append(*tp,false)) {
            return false;
        }
        delete tp;
    }

    task_report(task_manager, "# adding intermediate\n");
    wp = waypoints.LookupId(3);
    if (wp) {
        OrderedTaskPoint* tp = fact.CreateIntermediate(TaskPointFactoryType::AAT_CYLINDER,*wp);
        if (tp->GetObservationZone().GetShape() == ObservationZone::Shape::CYLINDER) {
            CylinderZone &cz = (CylinderZone &)tp->GetObservationZone();
            cz.SetRadius(fixed(40000.0));
        }
        if (!fact.Append(*tp,false)) {
            return false;
        }
        delete tp;
    }

    task_report(task_manager, "# adding finish\n");
    wp = waypoints.LookupId(1);
    if (wp) {
        OrderedTaskPoint *tp = fact.CreateFinish(*wp);
        if (!fact.Append(*tp,false)) {
            return false;
        }
        delete tp;
    }

    fact.UpdateStatsGeometry();

    task_report(task_manager, "# checking task..\n");
    if (!fact.Validate()) {
        return false;
    }

    if (!task_manager.CheckOrderedTask()) {
        return false;
    }
    return true;
}

bool test_task_type_manip(TaskManager& task_manager,
                          const Waypoints &waypoints, unsigned n_points)
{
    if (!test_task_random_RT_AAT_FAI(task_manager, waypoints, n_points))
        return false;

    switch (rand() %4) {
    case 0:
        task_manager.SetFactory(TaskFactoryType::AAT);
        test_note("# switched FACTORY TYPE to AAT\n");
        break;
    case 1:
        task_manager.SetFactory(TaskFactoryType::RACING);
        test_note("# switched FACTORY TYPE to RT\n");
        break;
    case 2:
        task_manager.SetFactory(TaskFactoryType::FAI_GENERAL);
        test_note("# switched FACTORY TYPE to FAI GENERAL\n");
        break;
    case 3:
        task_manager.SetFactory(TaskFactoryType::MAT);
        test_note("# switched FACTORY TYPE to MAT\n");
        break;
    default:
        test_note("# unknown task type\n");
    }

    AbstractTaskFactory &fact = task_manager.GetFactory();
    fact.MutateTPsToTaskType();
    fact.UpdateStatsGeometry();

    test_note("# checking mutated start..\n");
    if (!fact.IsValidStartType(fact.GetType(task_manager.GetOrderedTask().GetTaskPoint(0))))
        return false;


    char tmp[255];
    sprintf(tmp, "# checking mutated intermediates.  task_size():%d..\n",
            task_manager.TaskSize());
    test_note(tmp);

    for (unsigned i = 1; i < (task_manager.TaskSize() - 1); i++) {
        sprintf(tmp, "# checking mutated intermediate point %d..\n", i);
        test_note(tmp);
        if (!fact.IsValidIntermediateType(fact.GetType(task_manager.GetOrderedTask().GetTaskPoint(i))))
            return false;
    }

    test_note("# checking mutated finish..\n");
    if (!fact.IsValidFinishType(
                fact.GetType(task_manager.GetOrderedTask().GetTaskPoint(task_manager.TaskSize() - 1))))
        return false;

    test_note("# validating task..\n");
    if (!fact.Validate()) {
        return false;
    }
    test_note("# checking task..\n");
    if (!task_manager.CheckOrderedTask()) {
        return false;
    }

    if (task_manager.GetOrderedTask().GetFactoryType() ==
            TaskFactoryType::FAI_GENERAL) {
        test_note("# checking OZs for FAI task..\n");
        if (!fact.ValidateFAIOZs())
            return false;
    }

    if (task_manager.GetOrderedTask().GetFactoryType() ==
            TaskFactoryType::MAT) {
        test_note("# checking OZs for MAT task..\n");
        if (!fact.ValidateMATOZs())
            return false;
    }
    return true;
}

bool test_task_manip(TaskManager& task_manager,
                     const Waypoints &waypoints)
{
    if (!test_task_mixed(task_manager, waypoints)) {
        return false;
    }
    AbstractTaskFactory &fact = task_manager.GetFactory();

    task_report(task_manager, "# removing tp 2\n");
    if (!fact.Remove(2)) {
        return false;
    }

    task_report(task_manager, "# removing tp 0\n");
    if (!fact.Remove(0)) {
        return false;
    }

    task_report(task_manager, "# removing tp -1 (illegal)\n");
    if (fact.Remove(0-1)) {
        return false;
    }

    task_report(task_manager, "# removing tp 50 (illegal)\n");
    if (fact.Remove(50)) {
        return false;
    }

    OrderedTaskPoint *tp;
    const Waypoint *wp;

    task_report(task_manager, "# inserting at 3\n");
    wp = waypoints.LookupId(3);
    if (wp) {
        tp = fact.CreateIntermediate(TaskPointFactoryType::AST_CYLINDER,*wp);
        if (!fact.Insert(*tp,3)) return false;
        delete tp;
    }

    task_report(task_manager, "# auto-replacing at 2 (no morph)\n");
    wp = waypoints.LookupId(9);
    if (wp) {
        tp = fact.CreateIntermediate(TaskPointFactoryType::AST_CYLINDER,*wp);
        if (!fact.Replace(*tp,2)) return false;
        delete tp;
    }

    task_report(task_manager, "# auto-replacing at 2 (morph)\n");
    wp = waypoints.LookupId(9);
    if (wp) {
        tp = fact.CreateStart(*wp);
        if (!fact.Replace(*tp,2)) return false;
        delete tp;
    }

    task_report(task_manager, "# auto-replacing at 0 (morph this)\n");
    wp = waypoints.LookupId(12);
    if (wp) {
        tp = fact.CreateIntermediate(TaskPointFactoryType::AST_CYLINDER,*wp);
        if (!fact.Replace(*tp,0)) return false;
        delete tp;
    }

    task_report(task_manager, "# auto-replacing at end (morph this)\n");
    wp = waypoints.LookupId(14);
    if (wp) {
        tp = fact.CreateIntermediate(TaskPointFactoryType::AST_CYLINDER,*wp);
        if (!fact.Replace(*tp,task_manager.TaskSize()-1)) return false;
        delete tp;
    }

    task_report(task_manager, "# removing finish point\n");
    if (!fact.Remove(task_manager.TaskSize()-1)) {
        return false;
    }

    task_report(task_manager, "# inserting at 50 (equivalent to append)\n");
    wp = waypoints.LookupId(8);
    if (wp) {
        tp = fact.CreateFinish(*wp);
        if (!fact.Insert(*tp,50)) return false;
        delete tp;
    }

    task_report(task_manager, "# inserting at 0 (morph this)\n");
    wp = waypoints.LookupId(3);
    if (wp) {
        tp = fact.CreateFinish(*wp);
        if (!fact.Insert(*tp,0)) return false;
        delete tp;
    }

    task_report(task_manager, "# inserting at 2 (morph this)\n");
    wp = waypoints.LookupId(4);
    if (wp) {
        tp = fact.CreateStart(*wp);
        if (!fact.Insert(*tp,2)) return false;
        delete tp;
    }

//.........这里部分代码省略.........