src/Task/MapTaskManager.cpp

   1 /* Copyright_License {
   2
   3   XCSoar Glide Computer - http://www.xcsoar.org/
   4   Copyright (C) 2000-2013 The XCSoar Project
   5   A detailed list of copyright holders can be found in the file "AUTHORS".
   6
   7   This program is free software; you can redistribute it and/or
   8   modify it under the terms of the GNU General Public License
   9   as published by the Free Software Foundation; either version 2
  10   of the License, or (at your option) any later version.
  11
  12   This program is distributed in the hope that it will be useful,
  13   but WITHOUT ANY WARRANTY; without even the implied warranty of
  14   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15   GNU General Public License for more details.
  16
  17   You should have received a copy of the GNU General Public License
  18   along with this program; if not, write to the Free Software
  19   Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
  20 }
  21  */
  22
  23 #include "Task/MapTaskManager.hpp"
  24 #include "Task/ProtectedTaskManager.hpp"
  25 #include "Components.hpp"
  26 #include "Protection.hpp"
  27 #include "Engine/Task/Ordered/OrderedTask.hpp"
  28 #include "Engine/Task/Ordered/Points/OrderedTaskPoint.hpp"
  29 #include "Engine/Task/Factory/AbstractTaskFactory.hpp"
  30 #include "Interface.hpp"
  31
  32 static const TaskBehaviour&
  33 GetTaskBehaviour()
  34 {
  35   return CommonInterface::GetComputerSettings().task;
  36 }
  37
  38 static MapTaskManager::TaskEditResult
  39 AppendToTask(OrderedTask *task, const Waypoint &waypoint)
  40 {
  41   if (task->TaskSize()==0)
  42     return MapTaskManager::NOTASK;
  43
  44   int i = task->TaskSize() - 1;
  45   // skip all finish points
  46   while (i >= 0) {
  47     const OrderedTaskPoint &tp = task->GetPoint(i);
  48     if (tp.IsSuccessorAllowed()) {
  49       ++i;
  50       break;
  51     }
  52
  53     --i;
  54   }
  55
  56   const AbstractTaskFactory &factory = task->GetFactory();
  57   OrderedTaskPoint *task_point =
  58       (OrderedTaskPoint *)factory.CreateIntermediate(waypoint);
  59   if (task_point == NULL)
  60     return MapTaskManager::UNMODIFIED;
  61
  62   bool success = i >= 0 ? task->Insert(*task_point, i) : task->Append(*task_point);
  63   delete task_point;
  64
  65   if (!success)
  66     return MapTaskManager::UNMODIFIED;
  67
  68   if (!task->CheckTask())
  69     return MapTaskManager::INVALID;
  70
  71   return MapTaskManager::SUCCESS;
  72 }
  73
  74 static MapTaskManager::TaskEditResult
  75 MutateFromGoto(OrderedTask *task, const Waypoint &finish_waypoint,
  76                const Waypoint &start_waypoint)
  77 {
  78   const AbstractTaskFactory &factory = task->GetFactory();
  79   OrderedTaskPoint *start_point =
  80       (OrderedTaskPoint *)factory.CreateStart(start_waypoint);
  81   if (start_point == NULL)
  82     return MapTaskManager::UNMODIFIED;
  83
  84   bool success = task->Append(*start_point);
  85   delete start_point;
  86   if (!success)
  87     return MapTaskManager::UNMODIFIED;
  88
  89   OrderedTaskPoint *finish_point =
  90       (OrderedTaskPoint *)factory.CreateFinish(finish_waypoint);
  91   if (finish_point == NULL)
  92     return MapTaskManager::UNMODIFIED;
  93
  94   success = task->Append(*finish_point);
  95   delete finish_point;
  96
  97   if (!success)
  98     return MapTaskManager::UNMODIFIED;
  99
 100   return MapTaskManager::MUTATED_FROM_GOTO;
 101 }
 102
 103 MapTaskManager::TaskEditResult
 104 MapTaskManager::AppendToTask(const Waypoint &waypoint)
 105 {
 106   assert(protected_task_manager != NULL);
 107   ProtectedTaskManager::ExclusiveLease task_manager(*protected_task_manager);
 108   TaskEditResult result = MapTaskManager::UNMODIFIED;
 109   if (task_manager->GetOrderedTask().CheckTask()) {
 110     OrderedTask *task = task_manager->Clone(GetTaskBehaviour());
 111     result = AppendToTask(task, waypoint);
 112     if (result == SUCCESS)
 113       task_manager->Commit(*task);
 114     delete task;
 115   } else { // ordered task invalid
 116     switch (task_manager->GetMode()) {
 117     case TaskType::NONE:
 118     case TaskType::ABORT:
 119     case TaskType::ORDERED:
 120       result = task_manager->DoGoto(waypoint) ? MapTaskManager::MUTATED_TO_GOTO :
 121                               MapTaskManager::UNMODIFIED;
 122       break;
 123     case TaskType::GOTO:
 124     {
 125       OrderedTask *task = task_manager->Clone(GetTaskBehaviour());
 126       const TaskWaypoint *OldGotoTWP = task_manager->GetActiveTaskPoint();
 127       if (!OldGotoTWP)
 128         break;
 129
 130       const Waypoint &OldGotoWp = OldGotoTWP->GetWaypoint();
 131       result = MutateFromGoto(task, waypoint, OldGotoWp);
 132       if (result == MUTATED_FROM_GOTO)
 133         task_manager->Commit(*task);
 134
 135       delete task;
 136       break;
 137     }
 138     }
 139   }
 140   return result;
 141 }
 142
 143 static MapTaskManager::TaskEditResult
 144 InsertInTask(OrderedTask *task, const Waypoint &waypoint)
 145 {
 146   if (task->TaskSize()==0)
 147     return MapTaskManager::NOTASK;
 148
 149   int i = task->GetActiveIndex();
 150   /* skip all start points */
 151   while (true) {
 152     if (i >= (int)task->TaskSize())
 153       return MapTaskManager::UNMODIFIED;
 154
 155     const OrderedTaskPoint &task_point = task->GetPoint(i);
 156     if (task_point.IsPredecessorAllowed())
 157       break;
 158
 159     ++i;
 160   }
 161
 162   const AbstractTaskFactory &factory = task->GetFactory();
 163   OrderedTaskPoint *task_point =
 164       (OrderedTaskPoint *)factory.CreateIntermediate(waypoint);
 165   if (task_point == NULL)
 166     return MapTaskManager::UNMODIFIED;
 167
 168   bool success = task->Insert(*task_point, i);
 169   delete task_point;
 170   if (!success)
 171     return MapTaskManager::UNMODIFIED;
 172   if (!task->CheckTask())
 173     return MapTaskManager::INVALID;
 174   return MapTaskManager::SUCCESS;
 175 }
 176
 177 MapTaskManager::TaskEditResult
 178 MapTaskManager::InsertInTask(const Waypoint &waypoint)
 179 {
 180   assert(protected_task_manager != NULL);
 181   ProtectedTaskManager::ExclusiveLease task_manager(*protected_task_manager);
 182   TaskEditResult result = MapTaskManager::UNMODIFIED;
 183   if (task_manager->GetOrderedTask().CheckTask()) {
 184     OrderedTask *task = task_manager->Clone(GetTaskBehaviour());
 185
 186     result = InsertInTask(task, waypoint);
 187     if (result == SUCCESS)
 188       task_manager->Commit(*task);
 189     delete task;
 190   } else { // ordered task invalid
 191     switch (task_manager->GetMode()) {
 192     case TaskType::NONE:
 193     case TaskType::ABORT:
 194     case TaskType::ORDERED:
 195       result = task_manager->DoGoto(waypoint) ? MapTaskManager::MUTATED_TO_GOTO :
 196                               MapTaskManager::UNMODIFIED;
 197       break;
 198     case TaskType::GOTO:
 199     {
 200       OrderedTask *task = task_manager->Clone(GetTaskBehaviour());
 201       const TaskWaypoint *OldGotoTWP = task_manager->GetActiveTaskPoint();
 202       if (!OldGotoTWP)
 203         break;
 204       const Waypoint &OldGotoWp = OldGotoTWP->GetWaypoint();
 205       result = MutateFromGoto(task, OldGotoWp, waypoint);
 206       if (result == MUTATED_FROM_GOTO)
 207         task_manager->Commit(*task);
 208       delete task;
 209       break;
 210     }
 211     }
 212   }
 213   return result;
 214 }
 215
 216 MapTaskManager::TaskEditResult
 217 MapTaskManager::InsertInMatProForma(OrderedTask &task,
 218                                     const Waypoint &waypoint)
 219 {
 220   assert(task.CheckTask());
 221   return InsertInTask(&task, waypoint);
 222 }
 223
 224 static MapTaskManager::TaskEditResult
 225 ReplaceInTask(OrderedTask *task, const Waypoint &waypoint)
 226 {
 227   if (task->TaskSize()==0)
 228     return MapTaskManager::NOTASK;
 229
 230   unsigned i = task->GetActiveIndex();
 231   if (i >= task->TaskSize())
 232     return MapTaskManager::UNMODIFIED;
 233
 234   task->Relocate(i, waypoint);
 235
 236   if (!task->CheckTask())
 237     return MapTaskManager::INVALID;
 238
 239   return MapTaskManager::SUCCESS;
 240 }
 241
 242 MapTaskManager::TaskEditResult
 243 MapTaskManager::ReplaceInTask(const Waypoint &waypoint)
 244 {
 245   assert(protected_task_manager != NULL);
 246   ProtectedTaskManager::ExclusiveLease task_manager(*protected_task_manager);
 247   OrderedTask *task = task_manager->Clone(GetTaskBehaviour());
 248
 249   TaskEditResult result = ReplaceInTask(task, waypoint);
 250   if (result == SUCCESS)
 251     task_manager->Commit(*task);
 252
 253   delete task;
 254   return result;
 255 }
 256
 257 static int
 258 GetUnachievedIndexInTask(const OrderedTask &task,
 259                          const Waypoint &waypoint)
 260 {
 261   if (task.TaskSize() < 2)
 262     return -1;
 263
 264   unsigned last_achieved_index = task.GetLastIntermediateAchieved();
 265
 266   int TPindex = -1;
 267   for (unsigned i = task.TaskSize() - 2; i > last_achieved_index; i--) {
 268     const OrderedTaskPoint &tp = task.GetPoint(i);
 269
 270     if (tp.GetWaypoint() == waypoint) {
 271       TPindex = i;
 272       break;
 273     }
 274   }
 275   return TPindex;
 276 }
 277
 278 int
 279 MapTaskManager::GetUnachievedIndexInTask(const Waypoint &waypoint)
 280 {
 281   assert(protected_task_manager != NULL);
 282   ProtectedTaskManager::Lease task_manager(*protected_task_manager);
 283
 284   if (task_manager->GetMode() == TaskType::ORDERED) {
 285     const OrderedTask &task = task_manager->GetOrderedTask();
 286     return GetUnachievedIndexInTask(task, waypoint);
 287   }
 288   return -1;
 289 }
 290
 291 static int
 292 GetIndexInTask(const OrderedTask &task, const Waypoint &waypoint)
 293 {
 294   if (task.TaskSize() == 0)
 295     return -1;
 296
 297   unsigned i = task.GetActiveIndex();
 298   if (i >= task.TaskSize())
 299     return -1;
 300
 301   int TPindex = -1;
 302   for (unsigned i = task.TaskSize(); i--;) {
 303     const OrderedTaskPoint &tp = task.GetPoint(i);
 304
 305     if (tp.GetWaypoint() == waypoint) {
 306       TPindex = i;
 307       break;
 308     }
 309   }
 310   return TPindex;
 311 }
 312
 313 int
 314 MapTaskManager::GetIndexInTask(const Waypoint &waypoint)
 315 {
 316   assert(protected_task_manager != NULL);
 317   ProtectedTaskManager::ExclusiveLease task_manager(*protected_task_manager);
 318   if (task_manager->GetMode() == TaskType::ORDERED) {
 319     const OrderedTask &task = task_manager->GetOrderedTask();
 320     return GetIndexInTask(task, waypoint);
 321   }
 322   return -1;
 323 }
 324
 325 static MapTaskManager::TaskEditResult
 326 RemoveFromTask(OrderedTask *task, const Waypoint &waypoint)
 327 {
 328   if (task->TaskSize()==0)
 329     return MapTaskManager::NOTASK;
 330
 331   int i = GetIndexInTask(*task, waypoint);
 332   if (i >= 0)
 333     task->GetFactory().Remove(i);
 334
 335   // if finish was removed
 336   if (i == (int)task->TaskSize())
 337     task->GetFactory().CheckAddFinish();
 338
 339   if (i == -1)
 340     return MapTaskManager::UNMODIFIED;
 341
 342   if (!task->CheckTask())
 343     return MapTaskManager::INVALID;
 344
 345   return MapTaskManager::SUCCESS;
 346 }
 347
 348 MapTaskManager::TaskEditResult
 349 MapTaskManager::RemoveFromTask(const Waypoint &wp)
 350 {
 351   assert(protected_task_manager != NULL);
 352   ProtectedTaskManager::ExclusiveLease task_manager(*protected_task_manager);
 353   OrderedTask *task = task_manager->Clone(GetTaskBehaviour());
 354
 355   TaskEditResult result = RemoveFromTask(task, wp);
 356   if (result == SUCCESS)
 357     task_manager->Commit(*task);
 358
 359   delete task;
 360   return result;
 361 }