//------------------------------------------------------------------------------
// reset() -- Reset parameters
//------------------------------------------------------------------------------
void Route::reset()
{
BaseClass::reset();
// ---
// reset the initial 'to' steerpoint
// ---
directTo(static_cast<unsigned int>(0));
Basic::PairStream* steerpoints = getComponents();
if (steerpoints != nullptr) {
// First try to find by name
if (initToStptName != nullptr) {
directTo(*initToStptName);
}
// Next try to find by index
else if (initToStptIdx != 0) {
directTo(initToStptIdx);
}
// We still don't have a 'to' steerpoint, then just use the first one
if (to == nullptr) {
directTo(1);
}
steerpoints->unref();
steerpoints = nullptr;
}
}
//------------------------------------------------------------------------------
// deleteSteerpoint() - goes through and deletes the steerpoint if there is a match
//------------------------------------------------------------------------------
bool Route::deleteSteerpoint(Steerpoint* const sp)
{
// get a pointer to our current 'to' steerpoint
const Steerpoint* p = getSteerpoint();
// remove the steerpoint
Basic::PairStream* steerpoints = getComponents();
Basic::Component::processComponents(steerpoints,typeid(Steerpoint),nullptr,sp);
if (steerpoints != nullptr) {
steerpoints->unref();
steerpoints = nullptr;
}
// When we just deleted our current 'to' steerpoint,
// force a new 'direct to' using stptIdx
if (p == sp) {
unsigned int idx = stptIdx;
directTo(static_cast<unsigned int>(0));
while ( !directTo(idx) && idx > 0 ) idx--;
}
// Otherwise just force a new 'direct to' using our current
// 'to' steerpoint to make sure our stptIdx is correct.
else {
directTo(p);
}
return true;
}
//------------------------------------------------------------------------------
// Replace the complete steerpoint list with a new one
//------------------------------------------------------------------------------
bool Route::replaceAllSteerpoints(Basic::PairStream* const newSteerpointList, unsigned int newStptIdx)
{
bool ok = false;
if (newSteerpointList != nullptr) {
Basic::Component::processComponents(newSteerpointList, typeid(Steerpoint));
// Try to force a 'Direct to' the new 'stptIdx' or default to stpt #1
directTo(static_cast<unsigned int>(0));
if ( !directTo(newStptIdx) ) directTo(1);
ok = true;
}
return ok;
}
//------------------------------------------------------------------------------
// deleteAllSteerpoints() - deletes all of the steerpoints
//------------------------------------------------------------------------------
bool Route::deleteAllSteerpoints()
{
// This will create a new null(0) steerpoint (components) list
Basic::Component::processComponents(nullptr, typeid(Steerpoint));
// No steerpoints, so we're going nowhere
directTo(static_cast<unsigned int>(0));
return true;
}
bool Route::decStpt()
{
bool ok = false;
const Basic::PairStream* steerpoints = getComponents();
if (steerpoints != nullptr) {
unsigned int n = steerpoints->entries();
unsigned int idx = stptIdx - 1;
if (idx < 1) idx = (wrap ? n : 1);
ok = directTo(idx);
steerpoints->unref();
steerpoints = nullptr;
}
return ok;
}
//------------------------------------------------------------------------------
// Change steerpoints
//------------------------------------------------------------------------------
bool Route::incStpt()
{
bool ok = false;
const base::PairStream* steerpoints = getComponents();
if (steerpoints != nullptr) {
unsigned int n = steerpoints->entries();
unsigned int idx = stptIdx + 1;
if (idx > n) idx = (wrap ? 1 : n);
ok = directTo(idx);
steerpoints->unref();
steerpoints = nullptr;
}
return ok;
}
//------------------------------------------------------------------------------
// insertSteerpoint() -
//------------------------------------------------------------------------------
bool Route::insertSteerpoint(Steerpoint* const newStpt, const int pos)
{
bool ok = false;
unsigned int num = getNumberOfSteerpoints();
// make a new character string
char numString[10];
// this tells us the number of the next steerpoint to be created in the slot list
std::sprintf(numString,"%i",(num+1));
// now we have the slot name, which is the next number in the steerpoint list
// now create a new pair, and if we have a component list, add it to it, if
// not, then create a new component list
Basic::Pair* p = new Basic::Pair(numString, newStpt);
if (p != nullptr) {
// We're its container
newStpt->container(this);
// Get our steerpoints
Basic::PairStream* steerpoints = getComponents();
// now we have to add it to our component list
if (steerpoints != nullptr && num != 0) {
// Copy the current steerpoint list
Basic::PairStream* tempList = new Basic::PairStream();
{
Basic::List::Item* item = steerpoints->getFirstItem();
while (item != nullptr) {
Basic::Pair* pair = (Basic::Pair*) item->getValue();
tempList->put(pair);
item = item->getNext();
}
}
if (pos == -1) {
tempList->addHead(p);
ok = true;
}
else if (pos == 0 || pos > num) {
tempList->addTail(p);
ok = true;
}
else if (pos > 0 && pos <= static_cast<int>(num)) {
// count to our position, then insert it
int counter = 1;
Basic::List::Item* item = tempList->getFirstItem();
while (counter < pos && item != nullptr) {
item = item->getNext();
counter++;
}
// now we should have the reference pair at the 'pos' position
if (item != nullptr) {
Basic::List::Item* newItem = new Basic::List::Item;
newItem->value = p;
p->ref();
// insert 'newItem' just before 'item'
ok = tempList->insert(newItem, item);
}
}
// swap our current steerpoint (components) list for this new one
if (ok) {
Basic::Component::processComponents(tempList,typeid(Steerpoint));
}
tempList->unref();
tempList = nullptr;
}
// if we have no components, we need to start a new component list
else {
Basic::Component::processComponents(nullptr, typeid(Steerpoint), p);
ok = true;
}
// Unref the original steerpoint list
if (steerpoints != nullptr) {
steerpoints->unref();
steerpoints = nullptr;
}
p->unref(); // Our component list has it now.
}
// ---
// Call directTo() to reset the steerpoint index, or if we were going nowhere
// then go direct-to steerpoint one.
// ---
if (ok) {
if (to != nullptr) {
Steerpoint* sp = static_cast<Steerpoint*>(to->object());
directTo(sp);
}
else {
directTo(1);
}
}
return ok;
}
//------------------------------------------------------------------------------
// deleteData() -- delete this object's data
//------------------------------------------------------------------------------
void Route::deleteData()
{
directTo(static_cast<unsigned int>(0));
initToStptName = nullptr;
}