//------------------------------------------------------------------------------ // build() -- build the table in our components list //------------------------------------------------------------------------------ void Table::build() { Basic::PairStream* newList = 0; if (rows > 0 && columns != 0) { newList = new Basic::PairStream(); // For each row: create a TableRow containing all the items in 'columns' for (unsigned int i = 1; i <= rows; i++) { // new row TableRow* row = new TableRow(); row->container(this); const Basic::List::Item* item = columns->getFirstItem(); while (item != 0) { const Basic::Pair* pair = static_cast<const Basic::Pair*>(item->getValue()); const Basic::Object* obj = pair->object(); if (obj->isClassType(typeid(BasicGL::Graphic))) { Basic::Pair* pp = pair->clone(); BasicGL::Graphic* gobj = static_cast<BasicGL::Graphic*>(pp->object()); gobj->container(row); row->put(pp); pp->unref(); } item = item->getNext(); } // put the row on our components list with a slotname equal to its row number { char cbuf[8]; sprintf(cbuf,"%d",i); Basic::Pair* pp = new Basic::Pair(cbuf,row); newList->put(pp); pp->unref(); } row->unref(); } // Position our subcomponents position(); } // These are new our subcomponents ... processComponents(newList,typeid(Basic::Component)); if (newList != 0) newList->unref(); }
// test station builder static TestStation* builder(const char* const filename) { // read configuration file int errors = 0; Basic::Object* obj = Basic::lcParser(filename, Factory::createObj, &errors); if (errors > 0) { std::cerr << "File: " << filename << ", errors: " << errors << std::endl; std::exit(EXIT_FAILURE); } // test to see if an object was created if (obj == nullptr) { std::cerr << "Invalid configuration file, no objects defined!" << std::endl; std::exit(EXIT_FAILURE); } // do we have a Basic::Pair, if so, point to object in Pair, not Pair itself Basic::Pair* pair = dynamic_cast<Basic::Pair*>(obj); if (pair != nullptr) { obj = pair->object(); obj->ref(); pair->unref(); } // try to cast to proper object, and check TestStation* testStation = dynamic_cast<TestStation*>(obj); if (testStation == nullptr) { std::cerr << "Invalid configuration file!" << std::endl; std::exit(EXIT_FAILURE); } return testStation; }
//------------------------------------------------------------------------------ // addSymbol() - adds a symbol to our array list; // -- return the symbol's index; range [ 1 .. getMaxSymbols() ] // or zero if not added. //------------------------------------------------------------------------------ int SymbolLoader::addSymbol(const int nType, const char* const id, int specName) { int idx = 0; if (templates != 0) { // Find the graphic template for this type symbol, and make // sure that the template is a BasicGL::Graphic, since it // will be use as the symbol's graphical component. Basic::Pair* tpair = templates->getPosition(nType); if (tpair != 0) { BasicGL::Graphic* tg = dynamic_cast<BasicGL::Graphic*>(tpair->object()); if (tg != 0) { // Find an empty symbol slot in our master symbol table for (int i = 0; i < MAX_SYMBOLS && idx == 0; i++) { if ( symbols[i] == 0 ) { // Create a new SlSymbol object to manage this symbol. symbols[i] = symbolFactory(); // Clone the graphic template and set it as the // symbol's graphical component. Basic::Pair* newPair = tpair->clone(); BasicGL::Graphic* newGraph = (BasicGL::Graphic*)(newPair->object()); // Set the new graphical component's select name GLuint mySelName = 0; if (specName > 0) mySelName = specName; else mySelName = BasicGL::Graphic::getNewSelectName(); newGraph->setSelectName(mySelName); // Add the symbol's graphical component to our component list. { Basic::PairStream* comp = getComponents(); Basic::Component::processComponents(comp, typeid(BasicGL::Graphic), newPair); if (comp != 0) comp->unref(); } // Set the symbol's graphical component pointer symbols[i]->setSymbolPair( newPair ); newPair->unref(); // symbol[i] now owns it. // Set the symbol's type and ID. symbols[i]->setType( nType ); symbols[i]->setId( id ); // And this is the new symbol's index idx = (i + 1); } } } } } return idx; }
//------------------------------------------------------------------------------ // setSymbolType() - change an existing symbol type to another type //------------------------------------------------------------------------------ bool SymbolLoader::setSymbolType(const int idx, const int nType) { bool ok = false; // Find the symbol if (idx >= 1 && idx <= MAX_SYMBOLS) { const int i = (idx - 1); if (symbols[i] != 0) { // Find the graphic template for this type symbol, and make // sure that the template is a BasicGL::Graphic, since it // will be use as the symbol's graphical component. if (templates != 0) { Basic::Pair* tpair = templates->getPosition(nType); if (tpair != 0) { BasicGL::Graphic* tg = dynamic_cast<BasicGL::Graphic*>(tpair->object()); if (tg != 0) { // Get the symbol's old graphical component Basic::Pair* oldPair = (Basic::Pair*) symbols[i]->getSymbolPair(); BasicGL::Graphic* oldG = (BasicGL::Graphic*) (oldPair->object()); // Clone the new graphical component from the template Basic::Pair* newPair = tpair->clone(); // Set the new graphical component's select name using the old's BasicGL::Graphic* newGraph = (BasicGL::Graphic*) newPair->object(); GLuint mySelName = oldG->getSelectName(); newGraph->setSelectName(mySelName); // Add the new and remove the old components from our subcomponent list { Basic::PairStream* comp = getComponents(); Basic::Component::processComponents(comp, typeid(BasicGL::Graphic), newPair, oldG); if (comp != 0) comp->unref(); } // Set the symbol's graphical component pointer symbols[i]->setSymbolPair( newPair ); newPair->unref(); // symbol[i] now owns it. // Set new type symbols[i]->setType( nType ); ok = true; } } } } } return ok; }
//------------------------------------------------------------------------------ // setSlotModeSingle() -- takes a single Mode and inits the mode list //------------------------------------------------------------------------------ bool RfSensor::setSlotModeSingle(RfSensor* const obj) { if (modes != 0) modes->unref(); modes = new Basic::PairStream(); Basic::Pair* p = new Basic::Pair("1",obj); modes->put( p ); p->unref(); return processModes(); }
void MultiActorAgent::setState(Basic::Ubf::State* const x) { if (x == nullptr) return; if (state != nullptr) state->unref(); state = x; state->ref(); state->container(this); Basic::Pair* p = new Basic::Pair("", state); addComponent(p); p->unref(); }
//------------------------------------------------------------------------------ // copyData() -- copy member data //------------------------------------------------------------------------------ void SlSymbol::copyData(const SlSymbol& org, const bool cc) { BaseClass::copyData(org); if (cc) initData(); visibility = org.visibility; llFlg = org.llFlg; acFlg = org.acFlg; scrnFlg = org.scrnFlg; type = org.type; lcStrcpy(id, sizeof(id), org.id); xPos = org.xPos; yPos = org.yPos; xScreenPos = org.xScreenPos; yScreenPos = org.yScreenPos; hdg = org.hdg; hdgValid = org.hdgValid; setHdgGraphics(0); setHdgAngleObj(0); { Basic::Object* copy = 0; if (org.value != 0) copy = org.value->clone(); setValue(copy); if (copy != 0) copy->unref(); } { Basic::Pair* copy = 0; if (org.pntr != 0) copy = org.pntr->clone(); setSymbolPair(copy); if (copy != 0) copy->unref(); } }
//------------------------------------------------------------------------------ // 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; }
// Set the stores bool Stores::setSlotStores(const Basic::PairStream* const msg) { // --- // Quick out if the number of stations hasn't been set. // --- if (ns == 0 && msg != 0) { std::cerr << "Stores::setSlotStation() Number of stations is not set!" << std::endl; return false; } // --- // Clear the previous stores and assigned weapons // --- storesList = 0; for (unsigned int s = 1; s <= ns; s++) { assignWeaponToStation(s,0); assignExtStoreToStation(s,0); } numWpn = 0; numEs = 0; // --- // Quick out if 'msg' is zero // --- if (msg == 0) return true; bool ok = true; // --- // Create the new external stores list // // For all items in the 'msg' list ... // -- Make sure that it's a weapon or other type of external store, and // that it has a valid station number. // -- Clone the store and if it's a weapon then assign it to the station. // --- Basic::PairStream* newStores = new Basic::PairStream(); const Basic::List::Item* item = msg->getFirstItem(); while (item != 0) { const Basic::Pair* pair = static_cast<const Basic::Pair*>(item->getValue()); const Basic::Component* p = static_cast<const Basic::Component*>(pair->object()); if (p != 0) { // get the station number from the stores' slot name int stationNumber = 0; const Basic::Identifier* stationName = pair->slot(); if (stationName->isInteger()) { stationNumber = stationName->getInteger(); } if (stationNumber > 0 && stationNumber <= static_cast<int>(ns)) { // check the type of component bool isWpn = p->isClassType(typeid(Weapon)); bool isEE = p->isClassType(typeid(ExternalStore)); if ( isWpn || isEE ) { // Clone the weapon pair and set us as its container Basic::Pair* cpair = pair->clone(); Component* cp = static_cast<Component*>(cpair->object()); cp->container(this); if ( isWpn ) { // Weapon types ... // Assign the weapon to the station Weapon* cwpn = static_cast<Weapon*>( cpair->object() ); assignWeaponToStation(stationNumber, cwpn); } if ( isEE ) { // External stores types ... // Assign the external store to the station ExternalStore* cwpn = static_cast<ExternalStore*>( cpair->object() ); assignExtStoreToStation(stationNumber, cwpn); } if (cpair != 0) { // Add to the new stores list newStores->put(cpair); cpair->unref(); // the new list has it. } } else { std::cerr << "Stores::setSlotStores(): invalid external stores type; use Weapon or Stores classes" << std::endl; ok = false; } } else { std::cerr << "Stores::setSlotStores(): invalid station number from the store's slot name." << std::endl; ok = false; } } item = item->getNext(); } // Make the new stores list the active list if (ok && newStores->entries() > 0) { storesList = newStores; } else { for (unsigned int s = 1; s <= ns; s++) { assignWeaponToStation(s,0); } numWpn = 0; } newStores->unref(); return ok; }