static double math_model_Pcw(double variable, Container<double> in_list) { double result=variable; result = (((*(in_list.getNextItem()))*sin(((6.283185307179586*(*(in_list.getNextItem())))*((*(in_list.getNextItem()))-(*(in_list.getNextItem()))))*0.016666666666666666))-(*(in_list.getNextItem())))*1.3565; return result; };
ContainerIterator Container::end() const { Container* evil = const_cast<Container*>(this); return evil->end(); }
Object* Analitza::removeDependencies(Object * o) const { Q_ASSERT(o); if(o->type()==Object::variable) { Ci* var=(Ci*) o; qDebug() << "Wanna remove" << var->name() << m_vars->value(var->name()); if(m_vars->contains(var->name()) && m_vars->value(var->name())) { Object *value=Expression::objectCopy(m_vars->value(var->name())); Object *no = removeDependencies(value); delete o; return no; } } else if(o->type()==Object::container) { Container *c = (Container*) o; Operator op(c->firstOperator()); if(c->containerType()==Object::apply && op.isBounded()) { //it is a function Container *cbody = c; QStringList bvars; if(op.operatorType()==Object::function) { Ci *func= (Ci*) c->m_params[0]; Object* body= (Object*) m_vars->value(func->name()); if(body->type()!=Object::container) return body; cbody = (Container*) body; } bvars = cbody->bvarList(); qDebug() << bvars; if(op.operatorType()==Object::function) { QStringList::const_iterator iBvars(bvars.constBegin()); int i=0; for(; iBvars!=bvars.constEnd(); ++iBvars) m_vars->stack(*iBvars, c->m_params[++i]); delete c; } QList<Object*>::iterator fval(cbody->firstValue()); qDebug() << "removing: " << (*fval)->toString(); Object *ret= removeDependencies(Expression::objectCopy(*fval)); QStringList::const_iterator iBvars(bvars.constBegin()); for(; iBvars!=bvars.constEnd(); ++iBvars) m_vars->destroy(*iBvars); if(op.operatorType()==Object::function) return ret; else { delete *fval; *fval=ret; return c; } } else { QList<Object*>::iterator it(c->m_params.begin()); for(; it!=c->m_params.end(); ++it) *it = removeDependencies(*it); } } return o; }
static double math_model_h_conc(double variable,Container<double> in_list){ double result = variable; result = ((*(in_list.getNextItem()))*((*(in_list.getNextItem()))-(*(in_list.getNextItem())))-(*(in_list.getNextItem()))*(*(in_list.getNextItem())))/(*(in_list.getNextItem())); return result; };
ContainerRangeReverse(Container &c) : IteratorRange<typename ContainerProperties<Container>::RBeginType>(c.rbegin(), c.rend()) {}
static bool eval(const Container& container, const typename Container::key_type& value) { return container.find(value) != container.end(); }
bool empty() const { return container_.empty(); }
void adjacent_for_each(Container & c, BinaryFunction func) { adjacent_for_each(c.begin(), c.end(), func); }
bool IOLoginData::loadPlayer(Player* player, DBResult_ptr result) { if (!result) { return false; } Database* db = Database::getInstance(); uint32_t accno = result->getNumber<uint32_t>("account_id"); Account acc = loadAccount(accno); player->setGUID(result->getNumber<uint32_t>("id")); player->name = result->getString("name"); player->accountNumber = accno; player->accountType = acc.accountType; player->coinBalance = acc.coinBalance; if (g_config.getBoolean(ConfigManager::FREE_PREMIUM)) { player->premiumDays = std::numeric_limits<uint16_t>::max(); } else { player->premiumDays = acc.premiumDays; } Group* group = g_game.groups.getGroup(result->getNumber<uint16_t>("group_id")); if (!group) { std::cout << "[Error - IOLoginData::loadPlayer] " << player->name << " has Group ID " << result->getNumber<uint16_t>("group_id") << " which doesn't exist" << std::endl; return false; } player->setGroup(group); player->bankBalance = result->getNumber<uint64_t>("balance"); player->setSex(static_cast<PlayerSex_t>(result->getNumber<uint16_t>("sex"))); player->level = std::max<uint32_t>(1, result->getNumber<uint32_t>("level")); uint64_t experience = result->getNumber<uint64_t>("experience"); uint64_t currExpCount = Player::getExpForLevel(player->level); uint64_t nextExpCount = Player::getExpForLevel(player->level + 1); if (experience < currExpCount || experience > nextExpCount) { experience = currExpCount; } player->experience = experience; if (currExpCount < nextExpCount) { player->levelPercent = Player::getPercentLevel(player->experience - currExpCount, nextExpCount - currExpCount); } else { player->levelPercent = 0; } player->soul = result->getNumber<uint16_t>("soul"); player->capacity = result->getNumber<uint32_t>("cap") * 100; player->blessings = result->getNumber<uint16_t>("blessings"); unsigned long conditionsSize; const char* conditions = result->getStream("conditions", conditionsSize); PropStream propStream; propStream.init(conditions, conditionsSize); Condition* condition = Condition::createCondition(propStream); while (condition) { if (condition->unserialize(propStream)) { player->storedConditionList.push_front(condition); } else { delete condition; } condition = Condition::createCondition(propStream); } if (!player->setVocation(result->getNumber<uint16_t>("vocation"))) { std::cout << "[Error - IOLoginData::loadPlayer] " << player->name << " has Vocation ID " << result->getNumber<uint16_t>("vocation") << " which doesn't exist" << std::endl; return false; } player->mana = result->getNumber<uint32_t>("mana"); player->manaMax = result->getNumber<uint32_t>("manamax"); player->magLevel = result->getNumber<uint32_t>("maglevel"); uint64_t nextManaCount = player->vocation->getReqMana(player->magLevel + 1); uint64_t manaSpent = result->getNumber<uint64_t>("manaspent"); if (manaSpent > nextManaCount) { manaSpent = 0; } player->manaSpent = manaSpent; player->magLevelPercent = Player::getPercentLevel(player->manaSpent, nextManaCount); player->health = result->getNumber<int32_t>("health"); player->healthMax = result->getNumber<int32_t>("healthmax"); player->defaultOutfit.lookType = result->getNumber<uint16_t>("looktype"); player->defaultOutfit.lookHead = result->getNumber<uint16_t>("lookhead"); player->defaultOutfit.lookBody = result->getNumber<uint16_t>("lookbody"); player->defaultOutfit.lookLegs = result->getNumber<uint16_t>("looklegs"); player->defaultOutfit.lookFeet = result->getNumber<uint16_t>("lookfeet"); player->defaultOutfit.lookAddons = result->getNumber<uint16_t>("lookaddons"); player->currentOutfit = player->defaultOutfit; if (g_game.getWorldType() != WORLD_TYPE_PVP_ENFORCED) { const time_t skullSeconds = result->getNumber<time_t>("skulltime") - time(nullptr); if (skullSeconds > 0) { //ensure that we round up the number of ticks player->skullTicks = (skullSeconds + 2) * 1000; uint16_t skull = result->getNumber<uint16_t>("skull"); if (skull == SKULL_RED) { player->skull = SKULL_RED; } else if (skull == SKULL_BLACK) { player->skull = SKULL_BLACK; } } } player->loginPosition.x = result->getNumber<uint16_t>("posx"); player->loginPosition.y = result->getNumber<uint16_t>("posy"); player->loginPosition.z = result->getNumber<uint16_t>("posz"); player->lastLoginSaved = result->getNumber<time_t>("lastlogin"); player->lastLogout = result->getNumber<time_t>("lastlogout"); player->offlineTrainingTime = result->getNumber<int32_t>("offlinetraining_time") * 1000; player->offlineTrainingSkill = result->getNumber<int32_t>("offlinetraining_skill"); Town* town = g_game.map.towns.getTown(result->getNumber<uint32_t>("town_id")); if (!town) { std::cout << "[Error - IOLoginData::loadPlayer] " << player->name << " has Town ID " << result->getNumber<uint32_t>("town_id") << " which doesn't exist" << std::endl; return false; } player->town = town; const Position& loginPos = player->loginPosition; if (loginPos.x == 0 && loginPos.y == 0 && loginPos.z == 0) { player->loginPosition = player->getTemplePosition(); } player->staminaMinutes = result->getNumber<uint16_t>("stamina"); static const std::string skillNames[] = {"skill_fist", "skill_club", "skill_sword", "skill_axe", "skill_dist", "skill_shielding", "skill_fishing"}; static const std::string skillNameTries[] = {"skill_fist_tries", "skill_club_tries", "skill_sword_tries", "skill_axe_tries", "skill_dist_tries", "skill_shielding_tries", "skill_fishing_tries"}; static const size_t size = sizeof(skillNames) / sizeof(std::string); for (uint8_t i = 0; i < size; ++i) { uint16_t skillLevel = result->getNumber<uint16_t>(skillNames[i]); uint64_t skillTries = result->getNumber<uint64_t>(skillNameTries[i]); uint64_t nextSkillTries = player->vocation->getReqSkillTries(i, skillLevel + 1); if (skillTries > nextSkillTries) { skillTries = 0; } player->skills[i].level = skillLevel; player->skills[i].tries = skillTries; player->skills[i].percent = Player::getPercentLevel(skillTries, nextSkillTries); } std::ostringstream query; query << "SELECT `guild_id`, `rank_id`, `nick` FROM `guild_membership` WHERE `player_id` = " << player->getGUID(); if ((result = db->storeQuery(query.str()))) { uint32_t guildId = result->getNumber<uint32_t>("guild_id"); uint32_t playerRankId = result->getNumber<uint32_t>("rank_id"); player->guildNick = result->getString("nick"); Guild* guild = g_game.getGuild(guildId); if (!guild) { query.str(std::string()); query << "SELECT `name` FROM `guilds` WHERE `id` = " << guildId; if ((result = db->storeQuery(query.str()))) { guild = new Guild(guildId, result->getString("name")); g_game.addGuild(guild); query.str(std::string()); query << "SELECT `id`, `name`, `level` FROM `guild_ranks` WHERE `guild_id` = " << guildId << " LIMIT 3"; if ((result = db->storeQuery(query.str()))) { do { guild->addRank(result->getNumber<uint32_t>("id"), result->getString("name"), result->getNumber<uint16_t>("level")); } while (result->next()); } } } if (guild) { player->guild = guild; GuildRank* rank = guild->getRankById(playerRankId); if (rank) { player->guildLevel = rank->level; } else { player->guildLevel = 1; } IOGuild::getWarList(guildId, player->guildWarList); query.str(std::string()); query << "SELECT COUNT(*) AS `members` FROM `guild_membership` WHERE `guild_id` = " << guildId; if ((result = db->storeQuery(query.str()))) { guild->setMemberCount(result->getNumber<uint32_t>("members")); } } } query.str(std::string()); query << "SELECT `player_id`, `name` FROM `player_spells` WHERE `player_id` = " << player->getGUID(); if ((result = db->storeQuery(query.str()))) { do { player->learnedInstantSpellList.emplace_front(result->getString("name")); } while (result->next()); } //load inventory items ItemMap itemMap; query.str(std::string()); query << "SELECT `pid`, `sid`, `itemtype`, `count`, `attributes` FROM `player_items` WHERE `player_id` = " << player->getGUID() << " ORDER BY `sid` DESC"; if ((result = db->storeQuery(query.str()))) { loadItems(itemMap, result); for (ItemMap::const_reverse_iterator it = itemMap.rbegin(), end = itemMap.rend(); it != end; ++it) { const std::pair<Item*, int32_t>& pair = it->second; Item* item = pair.first; int32_t pid = pair.second; if (pid >= 1 && pid <= 10) { player->internalAddThing(pid, item); } else { ItemMap::const_iterator it2 = itemMap.find(pid); if (it2 == itemMap.end()) { continue; } Container* container = it2->second.first->getContainer(); if (container) { container->internalAddThing(item); } } } } //load depot items itemMap.clear(); query.str(std::string()); query << "SELECT `pid`, `sid`, `itemtype`, `count`, `attributes` FROM `player_depotitems` WHERE `player_id` = " << player->getGUID() << " ORDER BY `sid` DESC"; if ((result = db->storeQuery(query.str()))) { loadItems(itemMap, result); for (ItemMap::const_reverse_iterator it = itemMap.rbegin(), end = itemMap.rend(); it != end; ++it) { const std::pair<Item*, int32_t>& pair = it->second; Item* item = pair.first; int32_t pid = pair.second; if (pid >= 0 && pid < 100) { DepotChest* depotChest = player->getDepotChest(pid, true); if (depotChest) { depotChest->internalAddThing(item); } } else { ItemMap::const_iterator it2 = itemMap.find(pid); if (it2 == itemMap.end()) { continue; } Container* container = it2->second.first->getContainer(); if (container) { container->internalAddThing(item); } } } } //load inbox items itemMap.clear(); query.str(std::string()); query << "SELECT `pid`, `sid`, `itemtype`, `count`, `attributes` FROM `player_inboxitems` WHERE `player_id` = " << player->getGUID() << " ORDER BY `sid` DESC"; if ((result = db->storeQuery(query.str()))) { loadItems(itemMap, result); for (ItemMap::const_reverse_iterator it = itemMap.rbegin(), end = itemMap.rend(); it != end; ++it) { const std::pair<Item*, int32_t>& pair = it->second; Item* item = pair.first; int32_t pid = pair.second; if (pid >= 0 && pid < 100) { player->getInbox()->internalAddThing(item); } else { ItemMap::const_iterator it2 = itemMap.find(pid); if (it2 == itemMap.end()) { continue; } Container* container = it2->second.first->getContainer(); if (container) { container->internalAddThing(item); } } } } //load storage map query.str(std::string()); query << "SELECT `key`, `value` FROM `player_storage` WHERE `player_id` = " << player->getGUID(); if ((result = db->storeQuery(query.str()))) { do { player->addStorageValue(result->getNumber<uint32_t>("key"), result->getNumber<int32_t>("value"), true); } while (result->next()); } //load vip query.str(std::string()); query << "SELECT `player_id` FROM `account_viplist` WHERE `account_id` = " << player->getAccount(); if ((result = db->storeQuery(query.str()))) { do { player->addVIPInternal(result->getNumber<uint32_t>("player_id")); } while (result->next()); } player->updateBaseSpeed(); player->updateInventoryWeight(); player->updateItemsLight(true); return true; }
static double math_model_Pcc(double variable, Container<double> in_list) { double result=variable; result = (*(in_list.getNextItem()))+(*(in_list.getNextItem())); return result; };
iterator insert(Container &container) { return __insert(container.begin(), container.end()); }
static double math_model_PplcFOL(double variable,Container<double> in_list) { double result = variable; result = ((*(in_list.getNextItem()))-(*(in_list.getNextItem())))/(0.001); return result; };
static double math_model_Pmouth(double variable, Container<double> in_list) { double result=variable; result = (*(in_list.getNextItem()))*1.3565; return result; };
static double math_model_PplmmHg(double variable, Container<double> in_list) { double result=variable; result = (*(in_list.getNextItem()))*.7371913011426465; return result; };
std::size_t RangeHash(Container c, std::size_t total_hash = 0) { return RangeHash(c.begin(), c.end(), total_hash); }
Range ( Container const& cont ) : begin_( cont.begin() ) , end_( cont.end() ) {}
static bool eval(const Container& container, const Value& value) { typename Container::const_iterator end = container.end(); return std::find(container.begin(), end, value) != end; }
template <class Container, class Function> Function for_each(Container &container, Function fn) { return for_each(container.begin(), container.end(), fn); }
void emplace( Args&&... args ) { container_.emplace_back( std::forward<Args>( args )... ); }
void MapTest::template_methods() { #if defined (STLPORT) && defined (_STLP_USE_CONTAINERS_EXTENSION) { typedef map<Key, int, KeyCmp> Container; typedef Container::value_type value; Container cont; cont.insert(value(Key(1), 1)); cont.insert(value(Key(2), 2)); cont.insert(value(Key(3), 3)); cont.insert(value(Key(4), 4)); CPPUNIT_ASSERT( cont.count(Key(1)) == 1 ); CPPUNIT_ASSERT( cont.count(1) == 1 ); CPPUNIT_ASSERT( cont.count(5) == 0 ); CPPUNIT_ASSERT( cont.find(2) != cont.end() ); CPPUNIT_ASSERT( cont.lower_bound(2) != cont.end() ); CPPUNIT_ASSERT( cont.upper_bound(2) != cont.end() ); CPPUNIT_ASSERT( cont.equal_range(2) != make_pair(cont.begin(), cont.end()) ); Container const& ccont = cont; CPPUNIT_ASSERT( ccont.find(2) != ccont.end() ); CPPUNIT_ASSERT( ccont.lower_bound(2) != ccont.end() ); CPPUNIT_ASSERT( ccont.upper_bound(2) != ccont.end() ); CPPUNIT_ASSERT( ccont.equal_range(2) != make_pair(ccont.end(), ccont.end()) ); } { typedef map<Key*, int, KeyCmpPtr> Container; typedef Container::value_type value; Container cont; Key key1(1), key2(2), key3(3), key4(4); cont.insert(value(&key1, 1)); cont.insert(value(&key2, 2)); cont.insert(value(&key3, 3)); cont.insert(value(&key4, 4)); CPPUNIT_ASSERT( cont.count(1) == 1 ); CPPUNIT_ASSERT( cont.count(5) == 0 ); CPPUNIT_ASSERT( cont.find(2) != cont.end() ); CPPUNIT_ASSERT( cont.lower_bound(2) != cont.end() ); CPPUNIT_ASSERT( cont.upper_bound(2) != cont.end() ); CPPUNIT_ASSERT( cont.equal_range(2) != make_pair(cont.begin(), cont.end()) ); Container const& ccont = cont; CPPUNIT_ASSERT( ccont.find(2) != ccont.end() ); CPPUNIT_ASSERT( ccont.lower_bound(2) != ccont.end() ); CPPUNIT_ASSERT( ccont.upper_bound(2) != ccont.end() ); CPPUNIT_ASSERT( ccont.equal_range(2) != make_pair(ccont.begin(), ccont.end()) ); } { typedef multimap<Key, int, KeyCmp> Container; typedef Container::value_type value; Container cont; cont.insert(value(Key(1), 1)); cont.insert(value(Key(2), 2)); cont.insert(value(Key(3), 3)); cont.insert(value(Key(4), 4)); CPPUNIT_ASSERT( cont.count(Key(1)) == 1 ); CPPUNIT_ASSERT( cont.count(1) == 1 ); CPPUNIT_ASSERT( cont.count(5) == 0 ); CPPUNIT_ASSERT( cont.find(2) != cont.end() ); CPPUNIT_ASSERT( cont.lower_bound(2) != cont.end() ); CPPUNIT_ASSERT( cont.upper_bound(2) != cont.end() ); CPPUNIT_ASSERT( cont.equal_range(2) != make_pair(cont.begin(), cont.end()) ); Container const& ccont = cont; CPPUNIT_ASSERT( ccont.find(2) != ccont.end() ); CPPUNIT_ASSERT( ccont.lower_bound(2) != ccont.end() ); CPPUNIT_ASSERT( ccont.upper_bound(2) != ccont.end() ); CPPUNIT_ASSERT( ccont.equal_range(2) != make_pair(ccont.end(), ccont.end()) ); } { typedef multimap<Key const volatile*, int, KeyCmpPtr> Container; typedef Container::value_type value; Container cont; Key key1(1), key2(2), key3(3), key4(4); cont.insert(value(&key1, 1)); cont.insert(value(&key2, 2)); cont.insert(value(&key3, 3)); cont.insert(value(&key4, 4)); CPPUNIT_ASSERT( cont.count(1) == 1 ); CPPUNIT_ASSERT( cont.count(5) == 0 ); CPPUNIT_ASSERT( cont.find(2) != cont.end() ); CPPUNIT_ASSERT( cont.lower_bound(2) != cont.end() ); CPPUNIT_ASSERT( cont.upper_bound(2) != cont.end() ); CPPUNIT_ASSERT( cont.equal_range(2) != make_pair(cont.begin(), cont.end()) ); Container const& ccont = cont; CPPUNIT_ASSERT( ccont.find(2) != ccont.end() ); CPPUNIT_ASSERT( ccont.lower_bound(2) != ccont.end() ); CPPUNIT_ASSERT( ccont.upper_bound(2) != ccont.end() ); CPPUNIT_ASSERT( ccont.equal_range(2) != make_pair(ccont.begin(), ccont.end()) ); } #endif }
size_type size() const { return container_.size(); }
void TestContainer(const std::string& name) { typedef ContainerType Container; // test empty container Container cont; if( cont.begin() != cont.end() ) { V3D_UNITTEST_ERROR_STATIC( (name + " Empty Container " "'s begin and end " " iterators did not match").c_str() ); } // add value to container int val = 3; cont.push_back(val); // test whether it was correctly added if( *cont.begin() != val ) { V3D_UNITTEST_ERROR_STATIC( (name + " Container::push_back did not insert element" ).c_str() ); } // empty container cont.clear(); if( cont.begin() != cont.end() ) { V3D_UNITTEST_ERROR_STATIC( (name + " Container::clear did not clear container: " " begin() and end() mismatch" ).c_str() ); } if( cont.size() != 0 ) { V3D_UNITTEST_ERROR_STATIC( (name + " Container::size() != 0 after clear()" ).c_str() ); } if( ! cont.empty() ) { V3D_UNITTEST_ERROR_STATIC( (name + "::empty() does not return true after clearing the " "container.").c_str() ); } // "complex" test: const int cnTestDataCount = 10; int naTestData[cnTestDataCount]; for(int i = 0; i < cnTestDataCount; ++i) { naTestData[i] = i; cont.push_back(i); } // test data if( ! std::equal(cont.begin(), cont.end(), naTestData) ) { V3D_UNITTEST_ERROR_STATIC( (name + " Filling with values and reading them back failed" ).c_str() ); } // test erasing: delete 3rd element typename Container::iterator it(cont.begin()); advance(it, 2); it = cont.erase(it); if( *it != 3 ) { V3D_UNITTEST_ERROR_STATIC( (name + "::erase did not return the correct iterator" ).c_str() ); } //cout << cont.size() << ": "; //for( Container::iterator iter = cont.begin(); iter != cont.end(); ++ iter) // cout << *iter << ","; //cout << endl; // test insert it = cont.begin(); advance(it, 2); it = cont.insert(it, 2); int t = *it; if( *it != 2 ) { V3D_UNITTEST_ERROR_STATIC( (name+ "::insert returned an invalid iterator" ).c_str() ); } //cout << cont.size() << ": "; //for( Container::iterator iter = cont.begin(); iter != cont.end(); ++ iter) // cout << *iter << ","; //cout << endl; if( ! std::equal(cont.begin(), cont.end(), naTestData) ) { V3D_UNITTEST_ERROR_STATIC( (name+ "::insert did not insert correctly").c_str() ); } }
ContainerRange(Container &c) : IteratorRange<typename ContainerProperties<Container>::BeginType>(c.begin(), c.end()) {}
void MapNodeHelper::parse(MapNode* mapNode, osg::ArgumentParser& args, osgViewer::View* view, osg::Group* root, Container* userContainer ) const { if ( !root ) root = mapNode; // options to use for the load osg::ref_ptr<osgDB::Options> dbOptions = Registry::instance()->cloneOrCreateOptions(); // parse out custom example arguments first: bool useSky = args.read("--sky"); bool useOcean = args.read("--ocean"); bool useMGRS = args.read("--mgrs"); bool useDMS = args.read("--dms"); bool useDD = args.read("--dd"); bool useCoords = args.read("--coords") || useMGRS || useDMS || useDD; bool useOrtho = args.read("--ortho"); bool useAutoClip = args.read("--autoclip"); bool useShadows = args.read("--shadows"); bool animateSky = args.read("--animate-sky"); bool showActivity = args.read("--activity"); bool useLogDepth = args.read("--logdepth"); bool useLogDepth2 = args.read("--logdepth2"); bool kmlUI = args.read("--kmlui"); bool inspect = args.read("--inspect"); if (args.read("--verbose")) osgEarth::setNotifyLevel(osg::INFO); if (args.read("--quiet")) osgEarth::setNotifyLevel(osg::FATAL); float ambientBrightness = 0.2f; args.read("--ambientBrightness", ambientBrightness); std::string kmlFile; args.read( "--kml", kmlFile ); std::string imageFolder; args.read( "--images", imageFolder ); std::string imageExtensions; args.read("--image-extensions", imageExtensions); // animation path: std::string animpath; if ( args.read("--path", animpath) ) { view->setCameraManipulator( new osgGA::AnimationPathManipulator(animpath) ); } // Install a new Canvas for our UI controls, or use one that already exists. ControlCanvas* canvas = ControlCanvas::getOrCreate( view ); Container* mainContainer; if ( userContainer ) { mainContainer = userContainer; } else { mainContainer = new VBox(); mainContainer->setAbsorbEvents( true ); mainContainer->setBackColor( Color(Color::Black, 0.8) ); mainContainer->setHorizAlign( Control::ALIGN_LEFT ); mainContainer->setVertAlign( Control::ALIGN_BOTTOM ); } canvas->addControl( mainContainer ); // look for external data in the map node: const Config& externals = mapNode->externalConfig(); const Config& skyConf = externals.child("sky"); const Config& oceanConf = externals.child("ocean"); const Config& annoConf = externals.child("annotations"); const Config& declutterConf = externals.child("decluttering"); // some terrain effects. // TODO: Most of these are likely to move into extensions. const Config& lodBlendingConf = externals.child("lod_blending"); const Config& vertScaleConf = externals.child("vertical_scale"); const Config& contourMapConf = externals.child("contour_map"); // Adding a sky model: if ( useSky || !skyConf.empty() ) { SkyOptions options(skyConf); if ( options.getDriver().empty() ) { if ( mapNode->getMapSRS()->isGeographic() ) options.setDriver("simple"); else options.setDriver("gl"); } SkyNode* sky = SkyNode::create(options, mapNode); if ( sky ) { sky->attach( view, 0 ); if ( mapNode->getNumParents() > 0 ) { osgEarth::insertGroup(sky, mapNode->getParent(0)); } else { sky->addChild( mapNode ); root = sky; } Control* c = SkyControlFactory().create(sky, view); if ( c ) mainContainer->addControl( c ); if (animateSky) { sky->setUpdateCallback( new AnimateSkyUpdateCallback() ); } } } // Adding an ocean model: if ( useOcean || !oceanConf.empty() ) { OceanNode* ocean = OceanNode::create(OceanOptions(oceanConf), mapNode); if ( ocean ) { // if there's a sky, we want to ocean under it osg::Group* parent = osgEarth::findTopMostNodeOfType<SkyNode>(root); if ( !parent ) parent = root; parent->addChild( ocean ); Control* c = OceanControlFactory().create(ocean); if ( c ) mainContainer->addControl(c); } } // Shadowing. if ( useShadows ) { ShadowCaster* caster = new ShadowCaster(); caster->setLight( view->getLight() ); caster->getShadowCastingGroup()->addChild( mapNode->getModelLayerGroup() ); if ( mapNode->getNumParents() > 0 ) { insertGroup(caster, mapNode->getParent(0)); } else { caster->addChild(mapNode); root = caster; } } // Loading KML from the command line: if ( !kmlFile.empty() ) { KMLOptions kml_options; kml_options.declutter() = true; // set up a default icon for point placemarks: IconSymbol* defaultIcon = new IconSymbol(); defaultIcon->url()->setLiteral(KML_PUSHPIN_URL); kml_options.defaultIconSymbol() = defaultIcon; osg::Node* kml = KML::load( URI(kmlFile), mapNode, kml_options ); if ( kml ) { if (kmlUI) { Control* c = AnnotationGraphControlFactory().create(kml, view); if ( c ) { c->setVertAlign( Control::ALIGN_TOP ); canvas->addControl( c ); } } root->addChild( kml ); } else { OE_NOTICE << "Failed to load " << kmlFile << std::endl; } } // Annotations in the map node externals: if ( !annoConf.empty() ) { osg::Group* annotations = 0L; AnnotationRegistry::instance()->create( mapNode, annoConf, dbOptions.get(), annotations ); if ( annotations ) { mapNode->addChild( annotations ); //root->addChild( annotations ); } } // Configure the de-cluttering engine for labels and annotations: if ( !declutterConf.empty() ) { Decluttering::setOptions( DeclutteringOptions(declutterConf) ); } // Configure the mouse coordinate readout: if ( useCoords ) { LabelControl* readout = new LabelControl(); readout->setBackColor( Color(Color::Black, 0.8) ); readout->setHorizAlign( Control::ALIGN_RIGHT ); readout->setVertAlign( Control::ALIGN_BOTTOM ); Formatter* formatter = useMGRS ? (Formatter*)new MGRSFormatter(MGRSFormatter::PRECISION_1M, 0L, MGRSFormatter::USE_SPACES) : useDMS ? (Formatter*)new LatLongFormatter(LatLongFormatter::FORMAT_DEGREES_MINUTES_SECONDS) : useDD ? (Formatter*)new LatLongFormatter(LatLongFormatter::FORMAT_DECIMAL_DEGREES) : 0L; MouseCoordsTool* mcTool = new MouseCoordsTool( mapNode ); mcTool->addCallback( new MouseCoordsLabelCallback(readout, formatter) ); view->addEventHandler( mcTool ); canvas->addControl( readout ); } // Configure for an ortho camera: if ( useOrtho ) { view->getCamera()->setProjectionMatrixAsOrtho(-1, 1, -1, 1, 0, 1); //EarthManipulator* manip = dynamic_cast<EarthManipulator*>(view->getCameraManipulator()); //if ( manip ) //{ // manip->getSettings()->setCameraProjection( EarthManipulator::PROJ_ORTHOGRAPHIC ); //} } // activity monitor (debugging) if ( showActivity ) { VBox* vbox = new VBox(); vbox->setBackColor( Color(Color::Black, 0.8) ); vbox->setHorizAlign( Control::ALIGN_RIGHT ); vbox->setVertAlign( Control::ALIGN_BOTTOM ); view->addEventHandler( new ActivityMonitorTool(vbox) ); canvas->addControl( vbox ); } // Install an auto clip plane clamper if ( useAutoClip ) { mapNode->addCullCallback( new AutoClipPlaneCullCallback(mapNode) ); } // Install logarithmic depth buffer on main camera if ( useLogDepth ) { OE_INFO << LC << "Activating logarithmic depth buffer (vertex-only) on main camera" << std::endl; osgEarth::Util::LogarithmicDepthBuffer logDepth; logDepth.setUseFragDepth( false ); logDepth.install( view->getCamera() ); } else if ( useLogDepth2 ) { OE_INFO << LC << "Activating logarithmic depth buffer (precise) on main camera" << std::endl; osgEarth::Util::LogarithmicDepthBuffer logDepth; logDepth.setUseFragDepth( true ); logDepth.install( view->getCamera() ); } // Scan for images if necessary. if ( !imageFolder.empty() ) { std::vector<std::string> extensions; if ( !imageExtensions.empty() ) StringTokenizer( imageExtensions, extensions, ",;", "", false, true ); if ( extensions.empty() ) extensions.push_back( "tif" ); OE_INFO << LC << "Loading images from " << imageFolder << "..." << std::endl; ImageLayerVector imageLayers; DataScanner scanner; scanner.findImageLayers( imageFolder, extensions, imageLayers ); if ( imageLayers.size() > 0 ) { mapNode->getMap()->beginUpdate(); for( ImageLayerVector::iterator i = imageLayers.begin(); i != imageLayers.end(); ++i ) { mapNode->getMap()->addImageLayer( i->get() ); } mapNode->getMap()->endUpdate(); } OE_INFO << LC << "...found " << imageLayers.size() << " image layers." << std::endl; } // Install elevation morphing if ( !lodBlendingConf.empty() ) { mapNode->getTerrainEngine()->addEffect( new LODBlending(lodBlendingConf) ); } // Install vertical scaler if ( !vertScaleConf.empty() ) { mapNode->getTerrainEngine()->addEffect( new VerticalScale(vertScaleConf) ); } // Install a contour map effect. if ( !contourMapConf.empty() ) { mapNode->getTerrainEngine()->addEffect( new ContourMap(contourMapConf) ); } // Generic named value uniform with min/max. VBox* uniformBox = 0L; while( args.find( "--uniform" ) >= 0 ) { std::string name; float minval, maxval; if ( args.read( "--uniform", name, minval, maxval ) ) { if ( uniformBox == 0L ) { uniformBox = new VBox(); uniformBox->setBackColor(0,0,0,0.5); uniformBox->setAbsorbEvents( true ); canvas->addControl( uniformBox ); } osg::Uniform* uniform = new osg::Uniform(osg::Uniform::FLOAT, name); uniform->set( minval ); root->getOrCreateStateSet()->addUniform( uniform, osg::StateAttribute::OVERRIDE ); HBox* box = new HBox(); box->addControl( new LabelControl(name) ); HSliderControl* hs = box->addControl( new HSliderControl(minval, maxval, minval, new ApplyValueUniform(uniform))); hs->setHorizFill(true, 200); box->addControl( new LabelControl(hs) ); uniformBox->addControl( box ); OE_INFO << LC << "Installed uniform controller for " << name << std::endl; } } if ( inspect ) { mapNode->addExtension( Extension::create("mapinspector", ConfigOptions()) ); } // Process extensions. for(std::vector<osg::ref_ptr<Extension> >::const_iterator eiter = mapNode->getExtensions().begin(); eiter != mapNode->getExtensions().end(); ++eiter) { Extension* e = eiter->get(); // Check for a View interface: ExtensionInterface<osg::View>* viewIF = ExtensionInterface<osg::View>::get( e ); if ( viewIF ) viewIF->connect( view ); // Check for a Control interface: ExtensionInterface<Control>* controlIF = ExtensionInterface<Control>::get( e ); if ( controlIF ) controlIF->connect( mainContainer ); } root->addChild( canvas ); }
ContainerIterator Container::begin() const { Container* evil = const_cast<Container*>(this); return evil->begin(); }
void print(Container& c) { typename Container::iterator it; for(it = c.begin(); it != c.end(); it++) cout << *it << " "; cout << endl; }
void Analitza::simpPolynomials(Container* c) { Q_ASSERT(c!=0 && c->type()==Object::container); QList<QPair<double, Object*> > monos; QList<Object*>::iterator it = c->m_params.begin(); Operator o(c->firstOperator()); for(; it!=c->m_params.end(); ++it) { Object *o2=*it; QPair<double, Object*> imono; bool ismono=false; if(o2->type() == Object::container) { Container *cx = (Container*) o2; if(cx->firstOperator()==Operator::multiplicityOperator(o.operatorType()) && cx->m_params.count()==3) { bool valid=false; int scalar=-1, var=-1; if(cx->m_params[1]->type()==Object::value) { scalar=1; var=2; valid=true; } else if(cx->m_params[2]->type()==Object::value) { scalar=2; var=1; valid=true; } if(valid) { Cn* sc= (Cn*) cx->m_params[scalar]; imono.first = sc->value(); imono.second = cx->m_params[var]; ismono = true; } } } if(!ismono) { imono.first = 1; imono.second = Expression::objectCopy(o2); } bool found = false; QList<QPair<double, Object*> >::iterator it1 = monos.begin(); for(; it1!=monos.end(); ++it1) { Object *o1=it1->second, *o2=imono.second; if(o2->type()!=Object::oper && Container::equalTree(o1, o2)) { found = true; break; } } if(found) it1->first += imono.first; else { imono.second = Expression::objectCopy(imono.second); monos.append(imono); } } qDeleteAll(c->m_params); c->m_params.clear(); if(o.operatorType()==Operator::plus) { QList<QPair<double, Object*> >::iterator it = monos.begin(); for(;it!=monos.end();++it) { if(it->first==1) { c->m_params.append(it->second); } else { Container *cint = new Container(Container::apply); cint->m_params.append(new Operator(Operator::times)); cint->m_params.append(new Cn(it->first)); cint->m_params.append(it->second); c->m_params.append(cint); } } } else if(o.operatorType()==Operator::times) { QList<QPair<double, Object*> >::iterator it = monos.begin(); for(;it!=monos.end();++it) { if(it->first==1) { c->m_params.append(it->second); } else { Container *cint = new Container(Container::apply); cint->m_params.append(new Operator(Operator::power)); cint->m_params.append(it->second); cint->m_params.append(new Cn(it->first)); c->m_params.append(cint); } } } else qDebug() << "wooooo, not implemented"; }
void test_sequence ( Container const &c ) { typedef typename Container::value_type value_type; std::vector<value_type> v; // Copy zero elements v.clear (); ba::copy_n ( c.begin (), 0, back_inserter ( v )); BOOST_CHECK ( v.size () == 0 ); ba::copy_n ( c.begin (), 0U, back_inserter ( v )); BOOST_CHECK ( v.size () == 0 ); if ( c.size () > 0 ) { // Just one element v.clear (); ba::copy_n ( c.begin (), 1, back_inserter ( v )); BOOST_CHECK ( v.size () == 1 ); BOOST_CHECK ( v[0] == *c.begin ()); v.clear (); ba::copy_n ( c.begin (), 1U, back_inserter ( v )); BOOST_CHECK ( v.size () == 1 ); BOOST_CHECK ( v[0] == *c.begin ()); // Half the elements v.clear (); ba::copy_n ( c.begin (), c.size () / 2, back_inserter ( v )); BOOST_CHECK ( v.size () == c.size () / 2); BOOST_CHECK ( std::equal ( v.begin (), v.end (), c.begin ())); // Half the elements + 1 v.clear (); ba::copy_n ( c.begin (), c.size () / 2 + 1, back_inserter ( v )); BOOST_CHECK ( v.size () == c.size () / 2 + 1 ); BOOST_CHECK ( std::equal ( v.begin (), v.end (), c.begin ())); // All the elements v.clear (); ba::copy_n ( c.begin (), c.size (), back_inserter ( v )); BOOST_CHECK ( v.size () == c.size ()); BOOST_CHECK ( std::equal ( v.begin (), v.end (), c.begin ())); } }
void *MsgEdit::processEvent(Event *e) { if (e->type() == EventMessageReceived){ Message *msg = (Message*)(e->param()); if ((msg->contact() == m_userWnd->id()) && (msg->type() != MessageStatus)){ if (CorePlugin::m_plugin->getContainerMode()){ bool bSetFocus = false; if (topLevelWidget() && topLevelWidget()->inherits("Container")){ Container *container = static_cast<Container*>(topLevelWidget()); if (container->wnd() == m_userWnd) bSetFocus = true; } setMessage(msg, bSetFocus); }else{ if (m_edit->isReadOnly()) QTimer::singleShot(0, this, SLOT(setupNext())); } } } if (e->type() == EventRealSendMessage){ MsgSend *s = (MsgSend*)(e->param()); if (s->edit == this){ sendMessage(s->msg); return e->param(); } } if (e->type() == EventCheckState){ CommandDef *cmd = (CommandDef*)(e->param()); if ((cmd->menu_id != MenuTextEdit) || (cmd->param != this)) return NULL; cmd->flags &= ~(COMMAND_CHECKED | COMMAND_DISABLED); switch (cmd->id){ case CmdUndo: if (m_edit->isReadOnly()) return NULL; if (!m_edit->isUndoAvailable()) cmd->flags |= COMMAND_DISABLED; return e->param(); case CmdRedo: if (m_edit->isReadOnly()) return NULL; if (!m_edit->isRedoAvailable()) cmd->flags |= COMMAND_DISABLED; return e->param(); case CmdCut: if (m_edit->isReadOnly()) return NULL; case CmdCopy: if (!m_edit->hasSelectedText()) cmd->flags |= COMMAND_DISABLED; return e->param(); case CmdPaste: if (m_edit->isReadOnly()) return NULL; if (QApplication::clipboard()->text().isEmpty()) cmd->flags |= COMMAND_DISABLED; return e->param(); case CmdClear: if (m_edit->isReadOnly()) return NULL; case CmdSelectAll: if (m_edit->text().isEmpty()) cmd->flags |= COMMAND_DISABLED; return e->param(); } return NULL; } if (e->type() == EventCommandExec){ CommandDef *cmd = (CommandDef*)(e->param()); if ((cmd->id == CmdSmile) && (cmd->param == this)){ Event eBtn(EventCommandWidget, cmd); QToolButton *btnSmile = (QToolButton*)(eBtn.process()); if (btnSmile){ SmilePopup *popup = new SmilePopup(this); connect(popup, SIGNAL(insert(int)), this, SLOT(insertSmile(int))); QPoint p = CToolButton::popupPos(btnSmile, popup); popup->move(p); popup->show(); } return e->param(); }
static double math_model_Pup(double variable, Container<double> in_list) { double result=variable; result = ((*(in_list.getNextItem()))*((*(in_list.getNextItem()))+(*(in_list.getNextItem()))))*9.999999999999998E-4; return result; };