Chapter::Chapter(const int chapter_number) : m_ball_game_chapter{*this}, m_bye_text{}, m_consequence{}, m_chapter_number{chapter_number}, m_chapter_type{ChapterType::normal}, m_dice_game_chapter{*this}, m_fighting_chapter{FightingChapter(*this)}, m_game_lost_chapter{this}, m_game_won_chapter{this}, m_luck_chapter(*this), m_observer{nullptr}, m_options_chapter{}, m_pawn_shop_chapter(this), m_pill_game_chapter{*this}, m_shop_chapter{this}, m_skill_chapter{*this}, m_text{}, m_verbose{false} { if (m_verbose) { std::clog << __func__ << std::endl; } Helper h; if (m_verbose) { std::clog << __func__ << std::endl; } #ifdef USE_TEXT_FILES_FOR_INPUT const std::string filename{h.GetFilesFolder() + h.ToStr(chapter_number) + ".txt"}; if (!h.IsRegularFile(filename)) { std::stringstream msg; msg << __func__ << ": ERROR: File " << filename << " does not exist"; Helper().Cout(msg.str()); throw std::runtime_error(msg.str()); } const std::vector<std::string> lines{h.FileToVector(filename)}; #else const std::vector<std::string> lines(1,GetFile(h.ToStr(chapter_number))); #endif std::stringstream s; std::copy(std::begin(lines),std::end(lines),std::ostream_iterator<std::string>(s," ")); m_text = h.ReadText(s); m_chapter_type = ReadChapterType(s); switch (m_chapter_type) { case ChapterType::game_lost: return; case ChapterType::game_won: return; default: break; } while (!s.eof()) { const std::string str{h.ReadString(s)}; if (str.empty()) { break; } else if (str == "Bye" || str == "bye") { m_bye_text = h.ReadText(s); } else if (str == "Change" || str == "change") { m_consequence.Add(ParseConsequence(s)); } else if (str == "Escape" || str == "escape") { GetFighting().SetRoundsToEscape(h.ReadInt(s)); GetFighting().SetEscapeToChapter(h.ReadInt(s)); } else if (str == "Fight_both" || str == "fight_both") { GetFighting().SetFightSequentially(false); } else if (str == "Luck" || str == "luck") { assert(this->m_chapter_type == ChapterType::test_your_luck); const std::string luck_text{h.ReadText(s)}; assert(!luck_text.empty()); GetLuck().SetLuckText(luck_text); const std::string goto_str{h.ReadString(s)}; assert(goto_str == "goto"); const int luck_chapter{h.ReadInt(s)}; assert(luck_chapter > 1); GetLuck().SetLuckChapter(luck_chapter); } else if (str == "Monster" || str == "monster") { this->m_chapter_type = ChapterType::fight; const Monster monster{ParseMonster(s)}; GetFighting().AddMonster(monster); } else if (str == "Next_chapter" || str == "goto") { m_consequence.SetNextChapter(h.ReadInt(s)); } else if (str == "No_luck" || str == "no_luck") { assert(this->m_chapter_type == ChapterType::test_your_luck); //s << std::noskipws; //Obligatory //Parse(s,' '); //You expect a space after a word const std::string no_luck_text{h.ReadText(s)}; assert(!no_luck_text.empty()); GetLuck().SetNoLuckText(no_luck_text); const std::string then{h.ReadString(s)}; if (then == "change") { const Consequence no_luck_consequence{ParseConsequence(s)}; GetLuck().SetNoLuckConsequence(no_luck_consequence); const std::string goto_str{h.ReadString(s)}; assert(goto_str == "goto"); } else { assert(then == "goto"); } const int no_luck_chapter{h.ReadInt(s)}; assert(no_luck_chapter > 1); GetLuck().SetNoLuckChapter(no_luck_chapter); } else if (str == "No_skill" || str == "no_skill") { assert(this->m_chapter_type == ChapterType::test_your_skill); //Parse(s,' '); //You expect a space after a word const std::string no_skill_text{h.ReadText(s)}; assert(!no_skill_text.empty()); GetSkill().SetNoSkillText(no_skill_text); const std::string then_str{h.ReadString(s)}; Consequence consequence; if (then_str == "goto") { consequence.SetNextChapter(h.ReadInt(s)); } else if (then_str == "change") { consequence = ParseConsequence(s); //Also read goto const std::string goto_str{h.ReadString(s)}; assert(goto_str == "goto"); consequence.SetNextChapter(h.ReadInt(s)); } else { assert(!"Should not get here"); } GetSkill().SetNoSkillConsequence(consequence); } else if (str == "Option" || str == "option") { const std::string option_text{h.ReadText(s)}; const std::string t{h.ReadString(s)}; if (t == "if") { const Condition condition{ParseCondition(s)}; const std::string then_str{h.ReadString(s)}; Consequence consequence; if (then_str == "goto") { consequence.SetNextChapter(h.ReadInt(s)); } else if (then_str == "change") { consequence = ParseConsequence(s); //Also read goto const std::string goto_str{h.ReadString(s)}; assert(goto_str == "goto"); consequence.SetNextChapter(h.ReadInt(s)); } else { assert(!"Should not get here"); } Option option(option_text,consequence); option.SetCondition(condition); GetOptions().AddOption(option); } else if (t == "ifnot") { Condition condition; const std::string what{h.ReadString(s)}; if (IsItem(what)) { const Item item_not_needed{ToItem(what)}; condition.AddItemNotNeeded(item_not_needed); } else { std::cerr << "Unknown item " << what << " in chapter " << chapter_number << std::endl; assert(!"Should not get here"); } const std::string str_goto{h.ReadString(s)}; assert(str_goto == "goto"); Consequence consequence; consequence.SetNextChapter(h.ReadInt(s)); Option option(option_text,consequence); option.SetCondition(condition); GetOptions().AddOption(option); } else if (t == "goto") { Consequence consequence; consequence.SetNextChapter(h.ReadInt(s)); const Option option(option_text,consequence); GetOptions().AddOption(option); } else if (h.IsInt(t)) { std::clog << "WARNING: goto omitted in chapter " << chapter_number << std::endl; //If no goto, just parse the number Consequence consequence; consequence.SetNextChapter(h.ToInt(t)); const Option option(option_text,consequence); GetOptions().AddOption(option); } else { std::cerr << "Unknown option " << t << " in chapter " << chapter_number <<std::endl; assert(!"Should not get here"); } } else if (str == "Random_monsters" || str == "random_monsters") { std::vector<Monster> monsters{ParseMonsters(s)}; m_chapter_type = ChapterType::fight; const int which_monster_index{Dice::Get()->Throw() - 1}; assert(which_monster_index >= 0); assert(which_monster_index < static_cast<int>(monsters.size())); const Monster monster{monsters[which_monster_index]}; m_fighting_chapter.AddMonster(monster); } else if (str == "Sell_items" || str == "sell_items") { assert(this->m_chapter_type == ChapterType::pawn_shop); //m_chapter_type = ChapterType::pawn_shop; m_pawn_shop_chapter = ParsePawnShopChapter(s,this); } else if (str == "Shop_items" || str == "shop_items") { assert(this->m_chapter_type == ChapterType::shop); //m_chapter_type = ChapterType::shop; m_shop_chapter = ParseShopChapter(s,this); } else if (str == "Skill" || str == "skill") { assert(this->m_chapter_type == ChapterType::test_your_skill); this->m_chapter_type = ChapterType::test_your_skill; //Parse(s,' '); //You expect a space after a word const std::string skill_text{h.ReadText(s)}; assert(!skill_text.empty()); GetSkill().SetSkillText(skill_text); const std::string then_str{h.ReadString(s)}; Consequence consequence; if (then_str == "goto") { consequence.SetNextChapter(h.ReadInt(s)); } else if (then_str == "change") { consequence = ParseConsequence(s); //Also read goto const std::string goto_str{h.ReadString(s)}; assert(goto_str == "goto"); consequence.SetNextChapter(h.ReadInt(s)); } else { assert(!"Should not get here"); } GetSkill().SetSkillConsequence(consequence); } else { std::cerr << "Chapter cannot parse chapter " << chapter_number << '\n' << "Unknown string: " << str << '\n' ; assert(!"Should not get here"); } } }
void ribi::fw::Helper::Test() noexcept { { static bool is_tested {false}; if (is_tested) return; is_tested = true; } //CreateTally { const std::vector<std::string> v = { "A"}; const std::vector<std::pair<std::string,int>> m{Helper().CreateTally(v)}; assert(m.size() == 1); assert(m[0].first == "A"); assert(m[0].second == 1); } { const std::vector<std::string> v = { "A", "A" }; const std::vector<std::pair<std::string,int>> m{Helper().CreateTally(v)}; assert(m.size() == 1); assert(m[0].first == "A"); assert(m[0].second == 2); } { const std::vector<std::string> v = { "A", "B" }; const std::vector<std::pair<std::string,int>> m{Helper().CreateTally(v)}; assert(m.size() == 2); assert(m[0].first == "A"); assert(m[0].second == 1); assert(m[1].first == "B"); assert(m[1].second == 1); } { const std::vector<std::string> v = { "B", "A", "B" }; const std::vector<std::pair<std::string,int>> m{Helper().CreateTally(v)}; assert(m.size() == 2); assert(m[0].first == "B"); assert(m[0].second == 2); assert(m[1].first == "A"); assert(m[1].second == 1); } { assert(Helper().GetFileBasenameBoostFilesystem("") == std::string("")); assert(Helper().GetFileBasenameBoostFilesystem("tmp.txt") == std::string("tmp")); assert(Helper().GetFileBasenameBoostFilesystem("test_output.fas") == std::string("test_output")); assert(Helper().GetFileBasenameBoostFilesystem("test_output_0.fas") == std::string("test_output_0")); assert(Helper().GetFileBasenameBoostFilesystem("tmp") == std::string("tmp")); assert(Helper().GetFileBasenameBoostFilesystem("MyFolder/tmp") == std::string("tmp")); assert(Helper().GetFileBasenameBoostFilesystem("MyFolder/tmp.txt") == std::string("tmp")); //assert(Helper().GetFileBasenameBoostFilesystem("MyFolder\\tmp.txt") == std::string("tmp")); assert(Helper().GetFileBasenameBoostFilesystem("MyFolder/MyFolder/tmp") == std::string("tmp")); assert(Helper().GetFileBasenameBoostFilesystem("MyFolder/MyFolder/tmp.txt") == std::string("tmp")); //assert(Helper().GetFileBasenameBoostFilesystem("MyFolder/MyFolder\\tmp.txt") == std::string("tmp")); assert(Helper().GetFileBasenameBoostXpressive("") == std::string("")); assert(Helper().GetFileBasenameBoostXpressive("tmp.txt") == std::string("tmp")); assert(Helper().GetFileBasenameBoostXpressive("test_output.fas") == std::string("test_output")); assert(Helper().GetFileBasenameBoostXpressive("test_output_0.fas") == std::string("test_output_0")); assert(Helper().GetFileBasenameBoostXpressive("tmp") == std::string("tmp")); assert(Helper().GetFileBasenameBoostXpressive("MyFolder/tmp") == std::string("tmp")); assert(Helper().GetFileBasenameBoostXpressive("MyFolder/tmp.txt") == std::string("tmp")); assert(Helper().GetFileBasenameBoostXpressive("MyFolder\\tmp.txt") == std::string("tmp")); assert(Helper().GetFileBasenameBoostXpressive("MyFolder/MyFolder/tmp") == std::string("tmp")); assert(Helper().GetFileBasenameBoostXpressive("MyFolder/MyFolder/tmp.txt") == std::string("tmp")); assert(Helper().GetFileBasenameBoostXpressive("MyFolder/MyFolder\\tmp.txt") == std::string("tmp")); } //ShowPhylogeny { } }
void CLoginSession::CmdRegister (void) // CmdRegister // // Handle register command { CUIHelper Helper(m_HI); // Get the fields CString sUsername = GetPropertyString(ID_CTRL_USERNAME, PROP_TEXT); CString sPassword = GetPropertyString(ID_CTRL_PASSWORD, PROP_TEXT); CString sPasswordConfirm = GetPropertyString(ID_CTRL_PASSWORD_CONFIRM, PROP_TEXT); CString sEmail = GetPropertyString(ID_CTRL_EMAIL, PROP_TEXT); bool bAutoSignIn = GetPropertyBool(ID_CTRL_AUTO_SIGN_IN, PROP_CHECKED); // Get the text for the username. If blank, then we have an error. if (sUsername.IsBlank()) { Helper.CreateInputErrorMessage(this, m_rcInputError, CONSTLIT("Username Missing"), CONSTLIT("You must have a username to register.")); return; } // Make sure the passwords match else if (!strEquals(sPassword, sPasswordConfirm)) { Helper.CreateInputErrorMessage(this, m_rcInputError, CONSTLIT("Password Does Not Match"), CONSTLIT("The password you entered does not match the confirmation password.")); return; } // Validate password complexity CString sError; if (!CHexarc::ValidatePasswordComplexity(sPassword, &sError)) { Helper.CreateInputErrorMessage(this, m_rcInputError, CONSTLIT("Password Is Too Easy"), sError); return; } // If email is blank, explain why we need it if (!m_bBlankEmailWarning && sEmail.IsBlank()) { Helper.CreateInputErrorMessage(this, m_rcInputError, CONSTLIT("Email Address Is Optional, but..."), CONSTLIT("If you provide your email address we will be able to reset your password if you request it.")); m_bBlankEmailWarning = true; return; } // Register the name m_HI.AddBackgroundTask(new CRegisterUserTask(m_HI, m_Service, sUsername, sPassword, sEmail, bAutoSignIn), this, CMD_REGISTER_COMPLETE); // Disable controls SetPropertyBool(ID_CTRL_USERNAME, PROP_ENABLED, false); SetPropertyBool(ID_CTRL_PASSWORD, PROP_ENABLED, false); SetPropertyBool(ID_CTRL_PASSWORD_CONFIRM, PROP_ENABLED, false); SetPropertyBool(ID_CTRL_MAIN_ACTION, PROP_ENABLED, false); SetPropertyBool(ID_CTRL_EMAIL, PROP_ENABLED, false); SetPropertyBool(ID_CTRL_AUTO_SIGN_IN, PROP_ENABLED, false); SetPropertyBool(CMD_SWITCH_TO_LOGIN, PROP_ENABLED, false); SetPropertyBool(CMD_TOS, PROP_ENABLED, false); }
E e(10, c); // expected-warning{{cannot pass object of non-POD type 'C' through variadic constructor; call will abort at runtime}} \ // expected-error{{calling a private constructor of class 'E'}} (void)E(10, c); // expected-warning{{cannot pass object of non-POD type 'C' through variadic constructor; call will abort at runtime}} \ // expected-error{{calling a private constructor of class 'E'}} } // PR5761: unevaluated operands and the non-POD warning class Foo { public: Foo() {} }; int Helper(...); const int size = sizeof(Helper(Foo())); namespace std { class type_info { }; } struct Base { virtual ~Base(); }; Base &get_base(...); int eat_base(...); void test_typeid(Base &base) { (void)typeid(get_base(base)); // expected-warning{{cannot pass object of non-POD type 'Base' through variadic function; call will abort at runtime}} expected-warning{{expression with side effects will be evaluated despite being used as an operand to 'typeid'}} (void)typeid(eat_base(base)); // okay }
int sumNumbers(TreeNode* root) { if(!root) return 0; return Helper(root, 0); }
void ribi::bm::Process::Test() noexcept { { static bool is_tested{false}; if (is_tested) return; is_tested = true; } { Helper(); } const TestTimer test_timer(__func__,__FILE__,1.0); const bool verbose{false}; //Create a Brownian motion with volatility { const auto volatility = 1.0 / boost::units::si::second; bm::Process b(volatility); double x{0.0}; std::vector<double> v = {x}; for (int i=0; i!=100; ++i) { x = b.CalcNext(x); v.push_back(x); } //Are the likelihoods best at the true volatility? const auto good_likelihood = Helper().CalcLogLikelihood(v,volatility * volatility); const auto bad_likelihood = Helper().CalcLogLikelihood(v,volatility * volatility * 0.5); const auto worse_likelihood = Helper().CalcLogLikelihood(v,volatility * volatility * 1.5); assert(good_likelihood > worse_likelihood); assert(good_likelihood > bad_likelihood); //Is the max likelihood truly the max likelihood? auto volatility_hat = 0.0 / boost::units::si::second; Helper().CalcMaxLikelihood(v,volatility_hat); const auto max_likelihood = Helper().CalcLogLikelihood(v,volatility_hat * volatility_hat); assert(max_likelihood >= good_likelihood); } //Run a Brownian motion process { const std::vector<double> noises = { -1.0268, -0.4985, 0.3825, -0.8102, -0.1206, -1.9604, 0.2079, 0.9134, 2.1375, 0.5461, 1.4335, 0.4414, -2.2912, 0.3249, -1.3019, -0.8995, 0.0281, -1.0959, -0.8118, -1.3890 }; const std::vector<double> xs_expected = { 0.0, -10.268, -15.253, -11.428, -19.53, -20.736, -40.34, -38.261, -29.127, -7.752, -2.291, 12.044, 16.458, -6.454, -3.205, -16.224, -25.219, -24.938, -35.897, -44.015, -57.905 }; const auto volatility = 10.0 / boost::units::si::second; const double init_x{0.0}; const ribi::bm::Parameters parameters(volatility); ribi::bm::Process sim(parameters); double x = init_x; std::vector<double> xs = {x}; for (const double noise: noises) { x = sim.CalcNext(x,noise); xs.push_back(x); } assert(xs.size() == xs_expected.size()); const int sz{static_cast<int>(xs.size())}; for (int i=0; i!=sz; ++i) { assert(std::abs(xs[i]-xs_expected[i]) < 0.000000001); } } //Worked example { const auto volatility = 0.5 / boost::units::si::second; const double init_x{0.0}; const int seed{83}; std::normal_distribution<double> normal_distribution; std::mt19937 rng(seed); const ribi::bm::Parameters parameters( volatility, seed ); ribi::bm::Process sim(parameters); double x = init_x; std::vector<double> xs = {x}; std::vector<double> random_normals(10); std::generate(begin(random_normals),end(random_normals), [&normal_distribution,&rng]() { return normal_distribution(rng); } ); if (!"Show randoms") { std::copy(begin(random_normals),end(random_normals), std::ostream_iterator<double>(std::cout,"\n") ); } for (int i=0; i!=10; ++i) { const double random_normal{random_normals[i]}; if (verbose) { std::cout << i << ": " << x << '\n'; } x = sim.CalcNext(x,random_normal); xs.push_back(x); } if (verbose) { std::cout << "10: " << x << '\n'; } //CalcMaxLikelihood: find best parameters auto cand_volatility = 0.0 / boost::units::si::second; Helper().CalcMaxLikelihood(xs,cand_volatility); const auto expected_cand_volatility = 0.38056299195796983 / boost::units::si::second; assert(std::abs(cand_volatility.value() - expected_cand_volatility.value()) < 0.0001); //CalcLogLikelihood: use parameters const double max_log_likelihood{ Helper().CalcLogLikelihood(xs,cand_volatility * cand_volatility) }; if (verbose) { std::cout << std::setprecision(20) << "cand_volatility: " << cand_volatility << '\n' << "max_log_likelihood: " << max_log_likelihood << '\n' ; } const double expected_max_log_likelihood{-4.9811786934375552605}; assert(std::abs(max_log_likelihood - expected_max_log_likelihood) < 0.0001); assert(!std::isnan(cand_volatility.value())); //CalcMaxLogLikelihood: find best parameters and use them in one step const double max_log_likelihood_too{ Helper().CalcMaxLogLikelihood(xs) }; assert(std::abs(max_log_likelihood_too - expected_max_log_likelihood) < 0.0001); } }
void ribi::tictactoe::Board::Test() noexcept { { static bool is_tested{false}; if (is_tested) return; is_tested = true; } const TestTimer test_timer(__func__,__FILE__,1.0); { //Check empty board state { Board t; const int s = t.GetSummarizedState(); Board u(s); assert(u == t); } //Check one-move states for (int i=0; i!=9; ++i) { Board t; t.DoMove(i/3,i%3,Player::player1); const int s = t.GetSummarizedState(); Board u(s); assert(u == t); } //Check two-move states for (int i=0; i!=8; ++i) { Board t; t.DoMove(i/3,i%3,Player::player1); t.DoMove(i/3,(i+1)%3,Player::player2); const int s = t.GetSummarizedState(); Board u(s); assert(u == t); } //Check draw detection { Board t; t.DoMove(1,1,Player::player1); t.DoMove(0,0,Player::player2); t.DoMove(1,2,Player::player1); t.DoMove(1,0,Player::player2); t.DoMove(2,0,Player::player1); t.DoMove(0,2,Player::player2); t.DoMove(0,1,Player::player1); t.DoMove(2,1,Player::player2); t.DoMove(2,2,Player::player1); assert(t.GetWinner() == Winner::draw); } //Check player1 wins horizontally detection { Board t; assert(t.GetWinner() == Winner::no_winner); t.DoMove(0,0,Player::player1); assert(t.GetWinner() == Winner::no_winner); t.DoMove(1,0,Player::player2); assert(t.GetWinner() == Winner::no_winner); t.DoMove(0,1,Player::player1); assert(t.GetWinner() == Winner::no_winner); t.DoMove(1,1,Player::player2); assert(t.GetWinner() == Winner::no_winner); t.DoMove(0,2,Player::player1); assert(t.GetWinner() == Winner::player1); } //Check player2 wins vertically detection { Board t; assert(t.GetWinner() == Winner::no_winner); t.DoMove(0,0,Player::player1); assert(t.GetWinner() == Winner::no_winner); t.DoMove(1,0,Player::player2); assert(t.GetWinner() == Winner::no_winner); t.DoMove(0,1,Player::player1); assert(t.GetWinner() == Winner::no_winner); t.DoMove(1,1,Player::player2); assert(t.GetWinner() == Winner::no_winner); t.DoMove(2,2,Player::player1); assert(t.GetWinner() == Winner::no_winner); t.DoMove(1,2,Player::player2); assert(t.GetWinner() == Winner::player2); } //Check player1 wins diagonally detection { Board t; assert(t.GetWinner() == Winner::no_winner); t.DoMove(0,0,Player::player1); assert(t.GetWinner() == Winner::no_winner); t.DoMove(1,0,Player::player2); assert(t.GetWinner() == Winner::no_winner); t.DoMove(1,1,Player::player1); assert(t.GetWinner() == Winner::no_winner); t.DoMove(1,2,Player::player2); assert(t.GetWinner() == Winner::no_winner); t.DoMove(2,2,Player::player1); assert(t.GetWinner() == Winner::player1); } //Check no-winner detection { Board t; t.DoMove(1,1,Player::player1); t.DoMove(0,0,Player::player2); t.DoMove(1,2,Player::player1); t.DoMove(1,0,Player::player2); t.DoMove(2,0,Player::player1); t.DoMove(0,2,Player::player2); t.DoMove(0,1,Player::player1); t.DoMove(2,1,Player::player2); //t.DoMove(2,2); //Final move to make a draw assert(t.GetWinner() == Winner::no_winner); } //Check CanDoMove for (int i=0; i!=9; ++i) { Board t; t.DoMove(i/3,i%3,Player::player1); assert(!t.CanDoMove(i/3,i%3)); } //Check all states for (int i=0; i!=Helper().IntPower(3,9); ++i) { try { Board t(i); assert(t.GetSummarizedState() == i); } catch (std::exception&) { //No problem } } } }
AboutDlg* createAboutDlg(QWidget* parent) { AboutDlg* dlg = new AboutDlg(parent); dlg->setWindowTitle(QObject::tr("About")); dlg->setProgramName(AppInfo::name() + " v" + AppInfo::version()); QString text = QString(" %1 <br><br>").arg(QObject::tr("Advanced text editor")); text += " Copyright © 2007-2010 Mikhail Murzin <br><br>"; text += "<a href=\"http://juffed.com/\">http://juffed.com</a><br><br>"; text += "<a href=\"http://sourceforge.net/tracker/?group_id=205470&atid=993768\">Report a bug</a><br><br>"; text += "<a href=\"http://sourceforge.net/tracker/?group_id=205470&atid=993771\">Request a feature</a>"; QString auth("<br> Mikhail Murzin a.k.a. Mezomish<br> <a href='mailto:[email protected]'>[email protected]</a>"); QList<Helper> pluginDevs; pluginDevs << Helper("Alexander Sokoloff", "*****@*****.**", "mailto:[email protected]", QObject::tr("SymbolBrowser plugin")) << Helper("Petr Vanek", "*****@*****.**", "mailto:[email protected]", QObject::tr("XML Formatter plugin")) << Helper("Alexey Romanenko", "*****@*****.**", "mailto:[email protected]", QObject::tr("Sort plugin")) ; QList<Helper> translators; translators << Helper("Michael Gangolf", "*****@*****.**", "mailto:[email protected]", QObject::tr("German translation")) << Helper("Pavel Fric", "http://fripohled.blogspot.com/", "http://fripohled.blogspot.com/", QObject::tr("Czech translation")) << Helper("Slavko (slavkozn)", "http://slavkozn.users.sourceforge.net/", "http://slavkozn.users.sourceforge.net/", QObject::tr("Slovak translation")) << Helper("Marc Dumoulin", "*****@*****.**", "mailto:[email protected]", QObject::tr("French translation")) << Helper("Jarek", "*****@*****.**", "mailto:[email protected]", QObject::tr("Polish translation")) << Helper("Giuliano S. Nascimento", "*****@*****.**", "mailto:[email protected]", QObject::tr("Brazilian Portuguese translation")) << Helper("YANG Weichun", "*****@*****.**", "mailto:[email protected]", QObject::tr("Chinese Simplified translation")) ; QList<Helper> thanksTo; thanksTo << Helper("Eugene Pivnev", "*****@*****.**", "mailto:[email protected]", QObject::tr("Packaging, testing")) << Helper("Alexander Sokoloff", "*****@*****.**", "mailto:[email protected]", QObject::tr("Testing, design ideas, feature requests")) << Helper("Petr Vanek", "*****@*****.**", "mailto:[email protected]", QObject::tr("Patches, Mac OS X port")) << Helper("David Stegbauer", "*****@*****.**", "mailto:[email protected]", QObject::tr("Patches")) << Helper("\"SoftIcon\"", "http://softicon.ru/", "http://softicon.ru/", QObject::tr("Application icon")) << Helper("Evgeny Muravjev Studio", "http://emuravjev.ru/", "http://emuravjev.ru/", QObject::tr("Website")) ; QString thanks("<br>"); foreach(Helper helper, thanksTo) { thanks += QString(" %1<br>").arg(helper.name); thanks += QString(" <a href='%1'>%2</a><br>").arg(helper.urlHref).arg(helper.urlTitle); thanks += QString(" %1<br><br>").arg(helper.contribution); }
ALERROR CNewGameSession::OnInit (CString *retsError) // OnInit // // Initialize { ALERROR error; int i; const CVisualPalette &VI = m_HI.GetVisuals(); // The main pane is divided into three columns. Compute the size and // position here. RECT rcCenter; VI.GetWidescreenRect(m_HI.GetScreen(), &rcCenter); m_cxLeftCol = RectWidth(rcCenter) / 3; m_cxRightCol = m_cxLeftCol; m_cxCenterCol = RectWidth(rcCenter) - (m_cxLeftCol + m_cxRightCol); m_xLeftCol = 0; m_xCenterCol = m_cxLeftCol; m_xRightCol = m_cxLeftCol + m_cxCenterCol; // Compute the location of various elements (relative to the upper-left of // the root vscroller). m_xPlayerName = m_xLeftCol; m_yPlayerName = MAJOR_PADDING_TOP; m_cxPlayerName = m_cxLeftCol; m_xPlayerGenome = m_xRightCol; m_yPlayerGenome = MAJOR_PADDING_TOP; m_cxPlayerGenome = m_cxRightCol; m_xShipClass = m_xLeftCol; m_yShipClass = MAJOR_PADDING_TOP; m_cxShipClass = RectWidth(rcCenter); // Generate a list of ship classes CAdventureDesc *pAdventure = g_pUniverse->GetCurrentAdventureDesc(); if (pAdventure == NULL) { *retsError = ERR_NO_ADVENTURE; return ERR_FAIL; } if (error = pAdventure->GetStartingShipClasses(&m_ShipClasses, retsError)) return error; if (m_ShipClasses.GetCount() == 0) { *retsError = ERR_NO_SHIP_CLASSES; return ERR_FAIL; } // Find the default ship class in the list m_iCurShipClass = 0; for (i = 0; i < m_ShipClasses.GetCount(); i++) if (m_ShipClasses[i]->GetUNID() == m_Settings.dwPlayerShip) { m_iCurShipClass = i; break; } // Create the title CUIHelper Helper(m_HI); IAnimatron *pTitle; Helper.CreateSessionTitle(this, m_Service, pAdventure->GetName(), CUIHelper::OPTION_SESSION_OK_BUTTON, &pTitle); StartPerformance(pTitle, ID_CTRL_TITLE, CReanimator::SPR_FLAG_DELETE_WHEN_DONE); // Create a scroller to hold all the settings m_pRoot = new CAniVScroller; m_pRoot->SetPropertyVector(PROP_POSITION, CVector(rcCenter.left, rcCenter.top)); m_pRoot->SetPropertyMetric(PROP_VIEWPORT_HEIGHT, (Metric)RectHeight(rcCenter)); m_pRoot->SetPropertyMetric(PROP_FADE_EDGE_HEIGHT, 0.0); m_pRoot->SetPropertyMetric(PROP_PADDING_BOTTOM, (Metric)MAJOR_PADDING_BOTTOM); // Create the player name CreatePlayerName(m_Settings.sPlayerName, m_xPlayerName, m_yPlayerName, m_cxPlayerName); m_bEditingName = false; // Create the player genome CreatePlayerGenome(m_Settings.iPlayerGenome, m_xPlayerGenome, m_yPlayerGenome, m_cxPlayerGenome); // Create the ship class CreateShipClass(m_ShipClasses[m_iCurShipClass], m_xShipClass, m_yShipClass, m_cxShipClass); // Start the settings pane StartPerformance(m_pRoot, ID_SETTINGS, CReanimator::SPR_FLAG_DELETE_WHEN_DONE); // Done return NOERROR; }
std::vector<boost::shared_ptr<ribi::trim::Cell>> ribi::trim::CellsCreator::CreateCells( const boost::shared_ptr<const Template> t, const int n_face_layers, const boost::units::quantity<boost::units::si::length> layer_height, const CreateVerticalFacesStrategy strategy, const bool verbose ) noexcept { assert(t); if (n_face_layers < 2 || t->GetPoints().empty() ) { std::vector<boost::shared_ptr<ribi::trim::Cell>> no_cells; return no_cells; } assert(n_face_layers >= 2); if (verbose) { std::clog << __FILE__ << "(" << (__LINE__) << ") : " << "Create points" << std::endl ; } const std::vector<boost::shared_ptr<Point>> all_points = CreatePoints(t,n_face_layers,layer_height); if (verbose) { std::clog << __FILE__ << "(" << (__LINE__) << ") : " << "Create horizontal faces" << std::endl ; } const std::vector<boost::shared_ptr<Face>> hor_faces = CreateHorizontalFaces(t,all_points,n_face_layers); if (verbose) { std::clog << __FILE__ << "(" << (__LINE__) << ") : " << "Create vertical faces" << std::endl ; } const std::vector<boost::shared_ptr<Face>> ver_faces = CreateVerticalFaces(t,all_points,n_face_layers,layer_height,strategy,verbose); if (verbose) { std::clog << __FILE__ << "(" << (__LINE__) << ") : " << "Created " << ver_faces.size() << " vertical faces" << std::endl ; } if (ver_faces.empty()) { std::vector<boost::shared_ptr<ribi::trim::Cell>> no_cells; return no_cells; } #ifndef NDEBUG for(const auto f:ver_faces) { assert(f); } #endif const int n_hor_faces_per_layer = static_cast<int>(t->GetFaces().size()); const int n_cells_per_layer = n_hor_faces_per_layer; if (verbose) { std::clog << __FILE__ << "(" << (__LINE__) << ") : " << "Creating cells" << std::endl ; } std::vector<boost::shared_ptr<Cell>> cells; for (int layer=0; layer!=n_face_layers-1; ++layer) //-1 because there are no points above the top layer { if (verbose) { std::clog << "."; } for (int i=0; i!=n_cells_per_layer; ++i) { const int bottom_face_index = ((layer + 0) * n_hor_faces_per_layer) + i; const int top_face_index = ((layer + 1) * n_hor_faces_per_layer) + i; assert(bottom_face_index >= 0); assert(top_face_index >= 0); assert(bottom_face_index < static_cast<int>(hor_faces.size())); assert(top_face_index < static_cast<int>(hor_faces.size())); const std::vector<boost::shared_ptr<Face>> these_ver_faces { FindKnownFacesBetween( hor_faces[bottom_face_index], hor_faces[top_face_index] ) }; if (strategy == CreateVerticalFacesStrategy::one_face_per_square ) { #ifndef NDEBUG if (these_ver_faces.size() != 3) { TRACE("BREAK"); } #endif assert(these_ver_faces.size() == 3); assert(hor_faces[bottom_face_index]); assert(hor_faces[top_face_index]); assert(these_ver_faces[0]); assert(these_ver_faces[1]); assert(these_ver_faces[2]); const boost::shared_ptr<Cell> cell( CellFactory().Create( { hor_faces[bottom_face_index], hor_faces[top_face_index], these_ver_faces[0], these_ver_faces[1], these_ver_faces[2] }, strategy ) ); assert(hor_faces[bottom_face_index]); assert(hor_faces[top_face_index]); assert(Helper().IsHorizontal(*hor_faces[bottom_face_index])); assert(Helper().IsHorizontal(*hor_faces[top_face_index])); assert(Helper().IsVertical(*these_ver_faces[0])); assert(Helper().IsVertical(*these_ver_faces[1])); assert(Helper().IsVertical(*these_ver_faces[2])); cells.push_back(cell); } else { assert(these_ver_faces.size() == 6); const boost::shared_ptr<Cell> cell { CellFactory().Create( { hor_faces[bottom_face_index], hor_faces[top_face_index], these_ver_faces[0], these_ver_faces[1], these_ver_faces[2], these_ver_faces[3], these_ver_faces[4], these_ver_faces[5] }, strategy ) }; assert(hor_faces[bottom_face_index]); assert(hor_faces[top_face_index]); assert(Helper().IsHorizontal(*hor_faces[bottom_face_index])); assert(Helper().IsHorizontal(*hor_faces[top_face_index])); assert(Helper().IsVertical(*these_ver_faces[0])); assert(Helper().IsVertical(*these_ver_faces[1])); assert(Helper().IsVertical(*these_ver_faces[2])); assert(Helper().IsVertical(*these_ver_faces[3])); assert(Helper().IsVertical(*these_ver_faces[4])); assert(Helper().IsVertical(*these_ver_faces[5])); cells.push_back(cell); } } } #ifndef NDEBUG if (verbose) { std::clog << __FILE__ << "(" << (__LINE__) << ") : " << "Checking cells" << std::endl ; } CheckCells(cells); #endif // NDEBUG if (verbose) { std::clog << __FILE__ << "(" << (__LINE__) << ") : " << "Done creating cells" << std::endl ; } return cells; }
void ribi::trim::CellsCreator::Test() noexcept { { static bool is_tested{false}; if (is_tested) return; is_tested = true; } CellFactory(); FaceFactory(); const TestTimer test_timer(__func__,__FILE__,1.0); const bool verbose{false}; /* if (testing_depth > 1) { if (verbose) { TRACE("Trying out to build cells from the hardest testing templates"); } { //This is the longest test by far //const TestTimer test_timer(boost::lexical_cast<std::string>(__LINE__),__FILE__,1.0); for (CreateVerticalFacesStrategy strategy: CreateVerticalFacesStrategies().GetAll()) { const boost::shared_ptr<Template> my_template { Template::CreateTest(3) }; const int n_cell_layers = 2; const boost::shared_ptr<CellsCreator> cells_creator { CellsCreatorFactory().Create( my_template, n_cell_layers, 1.0 * boost::units::si::meter, strategy, verbose ) }; const std::vector<boost::shared_ptr<Cell>> cells { cells_creator->GetCells() }; assert(cells.size() > 0); } } } */ if (verbose) { TRACE("Specific: check if a Face really loses its neighbour: remove a prism from a cube"); } { //const TestTimer test_timer(boost::lexical_cast<std::string>(__LINE__),__FILE__,1.0); for (CreateVerticalFacesStrategy strategy: CreateVerticalFacesStrategies().GetAll()) { //Create a 2x1 cell block const boost::shared_ptr<Template> my_template { Template::CreateTest(1) }; assert(my_template->CountFaces() == 2); const int n_cell_layers = 1; const boost::shared_ptr<CellsCreator> cells_creator { CellsCreatorFactory().Create( my_template, n_cell_layers, 1.0 * boost::units::si::meter, strategy, verbose ) }; const std::vector<boost::shared_ptr<Cell>> cells { cells_creator->GetCells() }; assert(cells.size() == 2); const std::vector<boost::shared_ptr<Face>> faces_1 { cells[0]->GetFaces() }; const std::vector<boost::shared_ptr<Face>> faces_2 { cells[1]->GetFaces() }; //Find the one/two Faces that have a neighbour { const int n_faces_with_neighbour { static_cast<int>( std::count_if(faces_1.begin(),faces_1.end(), [](const boost::shared_ptr<Face> face) { return face->GetNeighbour().get(); } ) ) }; assert( (strategy == CreateVerticalFacesStrategy::one_face_per_square && n_faces_with_neighbour == 1) || (strategy == CreateVerticalFacesStrategy::two_faces_per_square && n_faces_with_neighbour == 2) ); } { const int n_faces_with_neighbour { static_cast<int>( std::count_if(faces_2.begin(),faces_2.end(), [](const boost::shared_ptr<Face> face) { return face->GetNeighbour().get(); } ) ) }; assert( (strategy == CreateVerticalFacesStrategy::one_face_per_square && n_faces_with_neighbour == 1) || (strategy == CreateVerticalFacesStrategy::two_faces_per_square && n_faces_with_neighbour == 2) ); } if (verbose) { TRACE("Creating internal faces 1"); } Helper::FaceSet internal_faces_1 = Helper().CreateEmptyFaceSet(); if (verbose) { TRACE("Creating internal faces 1, std::copy_if"); } std::copy_if( faces_1.begin(),faces_1.end(), std::inserter(internal_faces_1,internal_faces_1.begin()), [](const boost::shared_ptr<Face> face) { assert(face); const bool do_copy = face->GetNeighbour().get(); return do_copy; } ); if (verbose) { TRACE("Creating internal faces 2"); } Helper::FaceSet internal_faces_2 = Helper().CreateEmptyFaceSet(); std::copy_if(faces_2.begin(),faces_2.end(),std::inserter(internal_faces_2,internal_faces_2.begin()), [](const boost::shared_ptr<Face> face) { return face->GetNeighbour().get(); } ); if (verbose) { TRACE("Creating internal faces 1"); } assert( std::equal( internal_faces_1.begin(),internal_faces_1.end(), internal_faces_2.begin(), [](boost::shared_ptr<Face> lhs, boost::shared_ptr<Face> rhs) { return *lhs == *rhs; } ) ); } } if (verbose) { TRACE("Create Face, from bug"); } { //const TestTimer test_timer(boost::lexical_cast<std::string>(__LINE__),__FILE__,1.0); /* (1.17557,2.35781,5.0) (2.35114,3.23607,5.0) (1.17557,2.35781,6.0) (2.35114,3.23607,6.0) */ //Ordering cannot be known for sure to be convex from these indices typedef boost::geometry::model::d2::point_xy<double> Coordinat2D; std::vector<boost::shared_ptr<Point>> face_points { PointFactory().Create(boost::make_shared<Coordinat2D>(1.17557,2.35781)), PointFactory().Create(boost::make_shared<Coordinat2D>(2.35114,3.23607)), PointFactory().Create(boost::make_shared<Coordinat2D>(1.17557,2.35781)), PointFactory().Create(boost::make_shared<Coordinat2D>(2.35114,3.23607)) }; face_points[0]->SetZ(5.0 * boost::units::si::meter); face_points[1]->SetZ(5.0 * boost::units::si::meter); face_points[2]->SetZ(6.0 * boost::units::si::meter); face_points[3]->SetZ(6.0 * boost::units::si::meter); //Order face_points if (!Helper().IsConvex(face_points)) { Helper().MakeConvex(face_points); } #ifndef NDEBUG if (!Helper().IsConvex(face_points)) { TRACE("ERROR"); for (const auto& p: face_points) { TRACE(*p); } TRACE("BREAK"); } #endif assert(Helper().IsConvex(face_points)); //Cannot order face winding yet, need Cells for this const boost::shared_ptr<Face> face { FaceFactory().Create( face_points, FaceOrientation::vertical, verbose ) }; } //From bug { //const TestTimer test_timer(boost::lexical_cast<std::string>(__LINE__),__FILE__,1.0); typedef boost::geometry::model::d2::point_xy<double> Coordinat2D; const double x1 = 0.0004035051226622692510832834944523028752882964909076690673828125; const double y1 = 0.00023296416881187433805568132161312178141088224947452545166015625; const double z1 = 0; //left out the '.0' intentionally const double x2 = 0.000403505141811931846741734464245610070065595209598541259765625; const double y2 = 0.00023296414405748076185791173298156309101614169776439666748046875; const double z2 = 0; //left out the '.0' intentionally const double x3 = 0.0004035051226622692510832834944523028752882964909076690673828125; const double y3 = 0.00023296416881187433805568132161312178141088224947452545166015625; const double z3 = 0.00025000000000000000520417042793042128323577344417572021484375; const double x4 = 0.000403505141811931846741734464245610070065595209598541259765625; const double y4 = 0.00023296414405748076185791173298156309101614169776439666748046875; const double z4 = 0.00025000000000000000520417042793042128323577344417572021484375; const auto c1 = boost::make_shared<Coordinat2D>(x1,y1); const auto c2 = boost::make_shared<Coordinat2D>(x2,y2); const auto c3 = boost::make_shared<Coordinat2D>(x3,y3); const auto c4 = boost::make_shared<Coordinat2D>(x4,y4); const auto p1 = PointFactory().Create(c1); const auto p2 = PointFactory().Create(c2); const auto p3 = PointFactory().Create(c3); const auto p4 = PointFactory().Create(c4); p1->SetZ(z1 * boost::units::si::meter); p2->SetZ(z2 * boost::units::si::meter); p3->SetZ(z3 * boost::units::si::meter); p4->SetZ(z4 * boost::units::si::meter); std::vector<boost::shared_ptr<Point>> face_points; face_points.push_back(p1); face_points.push_back(p2); face_points.push_back(p3); face_points.push_back(p4); assert(IsPlane(face_points)); } }
std::vector<boost::shared_ptr<ribi::trim::Face>> ribi::trim::CellsCreator::CreateVerticalFaces( const boost::shared_ptr<const Template> t, const std::vector<boost::shared_ptr<Point>>& all_points, const int n_face_layers, const boost::units::quantity<boost::units::si::length> layer_height, const CreateVerticalFacesStrategy strategy, const bool verbose ) noexcept { assert(t); assert(n_face_layers > 0); if (n_face_layers < 2) { if (verbose) { std::clog << __FILE__ << "(" << (__LINE__) << ") : " << "Too few layers to create vertical faces" << std::endl ; } std::vector<boost::shared_ptr<ribi::trim::Face>> no_faces; return no_faces; } #ifndef NDEBUG const FaceFactory face_factory; if (verbose) { std::clog << __FILE__ << "(" << (__LINE__) << ") : " << "Checking points" << std::endl ; } for (const auto& point: all_points) { assert(point); } if (verbose) { std::clog << __FILE__ << "(" << (__LINE__) << ") : " << "Get edges" << std::endl ; } #endif const std::vector<std::pair<int,int>> edges = t->GetEdges(); assert(!edges.empty()); const int n_edges = static_cast<int>(edges.size()); const int n_points_per_layer = static_cast<int>(t->GetPoints().size()); assert(n_points_per_layer > 0); const int n_ver_faces = strategy == CreateVerticalFacesStrategy::one_face_per_square ? 1 * n_edges : 2 * n_edges //For every horizontal edge, two triangles are used instead ; std::vector<boost::shared_ptr<Face>> v; #ifndef NDEBUG const int n_reserve = n_ver_faces * (n_face_layers - 1); #endif assert(n_reserve > 0); assert(n_reserve < static_cast<int>(v.max_size())); v.reserve(n_ver_faces * (n_face_layers - 1)); assert(n_face_layers > 0); if (n_face_layers == 1) { std::vector<boost::shared_ptr<ribi::trim::Face>> no_faces; return no_faces; } if (verbose) { std::clog << __FILE__ << "(" << (__LINE__) << ") : " << "Start building " << (n_face_layers-1) //Number of cell layers << " layers" << std::endl ; } for (int layer=0; layer!=n_face_layers-1; ++layer) //-1 because there are no points above the top layer { if (verbose) { std::clog << __FILE__ << "(" << (__LINE__) << ") : " << (layer+1) //Human-based << "/" << (n_face_layers-1) //Number of cell layers << std::endl ; } const int points_offset = n_points_per_layer * layer; assert(points_offset >= 0); const auto z_here = static_cast<double>(layer + 0) * layer_height; const auto z_above = static_cast<double>(layer + 1) * layer_height; for (const std::pair<int,int>& edge: edges) { assert(edge.first < edge.second); assert(points_offset + edge.first < static_cast<int>(all_points.size())); assert(points_offset + edge.second < static_cast<int>(all_points.size())); assert(points_offset + edge.first + n_points_per_layer < static_cast<int>(all_points.size())); assert(points_offset + edge.second + n_points_per_layer < static_cast<int>(all_points.size())); if (strategy == CreateVerticalFacesStrategy::one_face_per_square) { //Ordering cannot be known for sure to be convex from these indices assert(all_points[points_offset + edge.first]); assert(all_points[points_offset + edge.second]); assert(all_points[points_offset + edge.first + n_points_per_layer]); assert(all_points[points_offset + edge.second + n_points_per_layer]); std::vector<boost::shared_ptr<Point>> face_points; face_points.push_back(all_points[points_offset + edge.first]); face_points.push_back(all_points[points_offset + edge.second]); face_points.push_back(all_points[points_offset + edge.first + n_points_per_layer]); face_points.push_back(all_points[points_offset + edge.second + n_points_per_layer]); assert(face_points.size() == 4); assert(face_points[0]); assert(face_points[1]); assert(face_points[2]); assert(face_points[3]); assert(face_points[0] != face_points[1]); assert(face_points[0] != face_points[2]); assert(face_points[0] != face_points[3]); assert(face_points[1] != face_points[2]); assert(face_points[1] != face_points[3]); assert(face_points[2] != face_points[3]); face_points[0]->SetZ(z_here); face_points[1]->SetZ(z_here); face_points[2]->SetZ(z_above); face_points[3]->SetZ(z_above); #ifndef NDEBUG if(!IsPlane(face_points)) { TRACE("ERROR"); std::stringstream s; s << face_points.size() << '\n' << std::setprecision(99) ; for (const auto& point: face_points) { s << (*point) << " "; } TRACE(s.str()); TRACE("BREAK"); } #endif assert(IsPlane(face_points)); //Order face_points if (!Helper().IsConvex(face_points)) { Helper().MakeConvex(face_points); } assert(Helper().IsConvex(face_points)); //Cannot order face winding yet, need Cells for this const boost::shared_ptr<Face> face { FaceFactory().Create( face_points, FaceOrientation::vertical, verbose ) }; assert(face); v.push_back(face); } else { assert(all_points[points_offset + edge.first]); assert(all_points[points_offset + edge.second]); assert(all_points[points_offset + edge.first + n_points_per_layer]); const std::vector<boost::shared_ptr<Point>> face_points_1 { all_points[points_offset + edge.first], all_points[points_offset + edge.second], all_points[points_offset + edge.first + n_points_per_layer] }; assert(face_points_1[0] != face_points_1[1]); assert(face_points_1[0] != face_points_1[2]); assert(face_points_1[1] != face_points_1[2]); face_points_1[0]->SetZ(z_here); face_points_1[1]->SetZ(z_here); face_points_1[2]->SetZ(z_above); assert(Helper().IsConvex(face_points_1) && "FaceFactory expects convex ordered points"); //Cannot order face winding yet, need Cells for this const boost::shared_ptr<Face> face_1 { FaceFactory().Create( face_points_1, FaceOrientation::vertical, verbose ) }; assert(face_1); v.push_back(face_1); assert(all_points[points_offset + edge.second]); assert(all_points[points_offset + edge.second + n_points_per_layer]); assert(all_points[points_offset + edge.first + n_points_per_layer]); std::vector<boost::shared_ptr<Point>> face_points_2 { all_points[points_offset + edge.second], all_points[points_offset + edge.second + n_points_per_layer], all_points[points_offset + edge.first + n_points_per_layer] }; assert(face_points_2[0] != face_points_2[1]); assert(face_points_2[0] != face_points_2[2]); assert(face_points_2[1] != face_points_2[2]); face_points_2[0]->SetZ(z_here ); face_points_2[1]->SetZ(z_above); face_points_2[2]->SetZ(z_above); #ifndef NDEBUG if (!Helper().IsConvex(face_points_2)) { TRACE("ERROR"); for (const auto& point:face_points_2) { TRACE(Geometry().ToStr(point->GetCoordinat3D())); } } #endif assert(Helper().IsConvex(face_points_2) && "FaceFactory expects convex ordered points"); const boost::shared_ptr<Face> face_2 { FaceFactory().Create( face_points_2, FaceOrientation::vertical, verbose ) }; assert(face_2); v.push_back(face_2); } } } assert(n_ver_faces * (n_face_layers - 1) == static_cast<int>(v.size())); if (verbose) { std::clog << __FILE__ << "(" << (__LINE__) << ") : " << "Done building " << (n_face_layers-1) //Number of cell layers << " layers" << std::endl ; } return v; }
std::vector<boost::shared_ptr<ribi::trim::Face>> ribi::trim::CellsCreator::CreateHorizontalFaces( const boost::shared_ptr<const Template> t, const std::vector<boost::shared_ptr<Point>>& all_points, const int n_face_layers ) { const bool verbose{false}; std::vector<boost::shared_ptr<Face>> v; assert(t); #ifndef NDEBUG if (all_points.empty()) { TRACE("ERROR"); TRACE("BREAK"); } #endif assert(!all_points.empty()); const int n_points_per_layer{static_cast<int>(t->GetPoints().size())}; #ifndef NDEBUG const int n_faces_per_layer{static_cast<int>(t->GetFaces().size())}; assert(n_face_layers > 0); #endif v.reserve(n_face_layers * n_points_per_layer); for (int layer=0; layer!=n_face_layers; ++layer) { const int point_offset{n_points_per_layer * layer}; for (const std::vector<int>& face_point_indices: t->GetFacePointIndices()) { #ifndef NDEBUG const int face_index{static_cast<int>(v.size())}; assert(face_point_indices.size() == 3); //Triangulation #endif std::vector<boost::shared_ptr<Point>> face_points; for (int point_index: face_point_indices) { assert(point_index + point_offset < static_cast<int>(all_points.size())); face_points.push_back(all_points[point_index + point_offset]); #ifndef NDEBUG if (face_points.size() >= 2 && face_points[0]->CanGetZ()) { assert(face_points.front()->GetZ() == face_points.back()->GetZ()); } #endif } assert(layer == 0 || face_index - n_faces_per_layer >= 0); assert(layer == 0 || face_index - n_faces_per_layer < static_cast<int>(v.size())); if ( (layer % 2 == 0 && !Helper().IsClockwiseHorizontal(face_points)) || (layer % 2 == 1 && Helper().IsClockwiseHorizontal(face_points)) ) { std::reverse(face_points.begin(),face_points.end()); } if(!Helper().IsConvex(face_points)) { Helper().MakeConvex(face_points); } assert(Helper().IsConvex(face_points)); //const FaceFactory face_factory; const boost::shared_ptr<Face> face { FaceFactory().Create( face_points, FaceOrientation::horizontal, verbose ) }; v.push_back(face); } } return v; }
void UFindSessionsCallbackProxyAdvanced::OnCompleted(bool bSuccess) { FOnlineSubsystemBPCallHelperAdvanced Helper(TEXT("FindSessionsCallback"), GEngine->GetWorldFromContextObject(WorldContextObject)); Helper.QueryIDFromPlayerController(PlayerControllerWeakPtr.Get()); if (Helper.IsValid()) { auto Sessions = Helper.OnlineSub->GetSessionInterface(); if (Sessions.IsValid()) { Sessions->ClearOnFindSessionsCompleteDelegate_Handle(DelegateHandle); } } TArray<FBlueprintSessionResult> Results; if (bSuccess && SearchObject.IsValid()) { // Just log the results for now, will need to add a blueprint-compatible search result struct for (auto& Result : SearchObject->SearchResults) { /* bool bAddResult = true; // Filter results if (SearchSettings.Num() > 0) { FOnlineSessionSetting * setting; for (int i = 0; i < SearchSettings.Num(); i++) { setting = Result.Session.SessionSettings.Settings.Find(SearchSettings[i].PropertyKeyPair.Key); // Couldn't find this key if (!setting) continue; if (!CompareVariants(setting->Data, SearchSettings[i].PropertyKeyPair.Data, SearchSettings[i].ComparisonOp)) { bAddResult = false; break; } } }*/ //if (bAddResult) //{ FString ResultText = FString::Printf(TEXT("Found a session. Ping is %d"), Result.PingInMs); FFrame::KismetExecutionMessage(*ResultText, ELogVerbosity::Log); FBlueprintSessionResult BPResult; BPResult.OnlineResult = Result; Results.Add(BPResult); //} } OnSuccess.Broadcast(Results); } else { OnFailure.Broadcast(Results); } }
// For each entry, find the independent group reachable by it. The independent group is // the entry itself, plus all the blocks it can reach that cannot be directly reached by another entry. Note that we // ignore directly reaching the entry itself by another entry. void FindIndependentGroups(BlockSet &Blocks, BlockSet &Entries, BlockBlockSetMap& IndependentGroups) { typedef std::map<Block*, Block*> BlockBlockMap; struct HelperClass { BlockBlockSetMap& IndependentGroups; BlockBlockMap Ownership; // For each block, which entry it belongs to. We have reached it from there. HelperClass(BlockBlockSetMap& IndependentGroupsInit) : IndependentGroups(IndependentGroupsInit) {} void InvalidateWithChildren(Block *New) { // TODO: rename New BlockList ToInvalidate; // Being in the list means you need to be invalidated ToInvalidate.push_back(New); while (ToInvalidate.size() > 0) { Block *Invalidatee = ToInvalidate.front(); ToInvalidate.pop_front(); Block *Owner = Ownership[Invalidatee]; if (IndependentGroups.find(Owner) != IndependentGroups.end()) { // Owner may have been invalidated, do not add to IndependentGroups! IndependentGroups[Owner].erase(Invalidatee); } if (Ownership[Invalidatee]) { // may have been seen before and invalidated already Ownership[Invalidatee] = NULL; for (BlockBranchMap::iterator iter = Invalidatee->BranchesOut.begin(); iter != Invalidatee->BranchesOut.end(); iter++) { Block *Target = iter->first; BlockBlockMap::iterator Known = Ownership.find(Target); if (Known != Ownership.end()) { Block *TargetOwner = Known->second; if (TargetOwner) { ToInvalidate.push_back(Target); } } } } } } }; HelperClass Helper(IndependentGroups); // We flow out from each of the entries, simultaneously. // When we reach a new block, we add it as belonging to the one we got to it from. // If we reach a new block that is already marked as belonging to someone, it is reachable by // two entries and is not valid for any of them. Remove it and all it can reach that have been // visited. BlockList Queue; // Being in the queue means we just added this item, and we need to add its children for (BlockSet::iterator iter = Entries.begin(); iter != Entries.end(); iter++) { Block *Entry = *iter; Helper.Ownership[Entry] = Entry; IndependentGroups[Entry].insert(Entry); Queue.push_back(Entry); } while (Queue.size() > 0) { Block *Curr = Queue.front(); Queue.pop_front(); Block *Owner = Helper.Ownership[Curr]; // Curr must be in the ownership map if we are in the queue if (!Owner) continue; // we have been invalidated meanwhile after being reached from two entries // Add all children for (BlockBranchMap::iterator iter = Curr->BranchesOut.begin(); iter != Curr->BranchesOut.end(); iter++) { Block *New = iter->first; BlockBlockMap::iterator Known = Helper.Ownership.find(New); if (Known == Helper.Ownership.end()) { // New node. Add it, and put it in the queue Helper.Ownership[New] = Owner; IndependentGroups[Owner].insert(New); Queue.push_back(New); continue; } Block *NewOwner = Known->second; if (!NewOwner) continue; // We reached an invalidated node if (NewOwner != Owner) { // Invalidate this and all reachable that we have seen - we reached this from two locations Helper.InvalidateWithChildren(New); } // otherwise, we have the same owner, so do nothing } } // Having processed all the interesting blocks, we remain with just one potential issue: // If a->b, and a was invalidated, but then b was later reached by someone else, we must // invalidate b. To check for this, we go over all elements in the independent groups, // if an element has a parent which does *not* have the same owner, we must remove it // and all its children. for (BlockSet::iterator iter = Entries.begin(); iter != Entries.end(); iter++) { BlockSet &CurrGroup = IndependentGroups[*iter]; BlockList ToInvalidate; for (BlockSet::iterator iter = CurrGroup.begin(); iter != CurrGroup.end(); iter++) { Block *Child = *iter; for (BlockSet::iterator iter = Child->BranchesIn.begin(); iter != Child->BranchesIn.end(); iter++) { Block *Parent = *iter; if (Helper.Ownership[Parent] != Helper.Ownership[Child]) { ToInvalidate.push_back(Child); } } } while (ToInvalidate.size() > 0) { Block *Invalidatee = ToInvalidate.front(); ToInvalidate.pop_front(); Helper.InvalidateWithChildren(Invalidatee); } } // Remove empty groups for (BlockSet::iterator iter = Entries.begin(); iter != Entries.end(); iter++) { if (IndependentGroups[*iter].size() == 0) { IndependentGroups.erase(*iter); } } #if DEBUG PrintDebug("Investigated independent groups:\n"); for (BlockBlockSetMap::iterator iter = IndependentGroups.begin(); iter != IndependentGroups.end(); iter++) { DebugDump(iter->second, " group: "); } #endif }
ribi::trim::Template::Template( const std::string& filename_node, const std::string& filename_ele, const bool verbose ) : m_edges{}, m_faces{}, m_face_point_indices{}, m_points{} { #ifndef NDEBUG Test(); #endif if (verbose) { TRACE("Load the points and faces created by Triangle"); } { const std::vector<std::string> v { ribi::fileio::FileIo().FileToVector( filename_node ) }; const int sz = v.size(); const int percent = sz / 100 ? sz / 100: 1; for(int n=0; n!=sz; ++n) { if (verbose) { if (n % percent == 0) std::clog << '%'; } const std::string line = v[n]; if(n==0) continue; //No idea why this has to be skipped const std::vector<std::string> w { CleanAndSplitString(ConvertNumbersToEnglish(line)) }; if (w.empty() || w[0].empty() || w[0] == "#") { //The final comment line continue; } assert(w.size() == 4); assert(CanLexicalCast<int>(w[0])); assert(CanLexicalCast<double>(w[1])); #ifndef NDEBUG if (!CanLexicalCast<double>(w[2])) { TRACE("ERROR"); TRACE(line); TRACE(w[0]); TRACE(w[1]); TRACE(w[2]); TRACE(w[3]); TRACE("BREAK"); } #endif assert(CanLexicalCast<double>(w[2])); assert(CanLexicalCast<int>(w[3])); const double x = boost::lexical_cast<double>(w[1]); const double y = boost::lexical_cast<double>(w[2]); const boost::shared_ptr<const ConstCoordinat2D> bottom( new ConstCoordinat2D(x,y) ); const boost::shared_ptr<Point> node { PointFactory().Create(bottom) }; m_points.push_back(node); } } if (verbose) { TRACE("Load and translate faces"); } { const std::vector<std::string> v = ribi::fileio::FileIo().FileToVector(filename_ele); const int sz = v.size(); const int percent = sz / 100 ? sz / 100: 1; for(int n=0; n!=sz; ++n) { if (verbose) { if (n % percent == 0) { std::clog << '%'; } } const std::string line = v[n]; if(n==0) continue; const std::vector<std::string> w { CleanAndSplitString(line) }; if (w.empty() || w[0].empty() || w[0] == "#") { //The final comment line continue; } assert(w.size() == 4); assert(CanLexicalCast<int>(w[0])); assert(CanLexicalCast<int>(w[1])); assert(CanLexicalCast<int>(w[2])); assert(CanLexicalCast<int>(w[3])); //I hope that I made the Triangle.exe output start at index 0.. const int point1 = boost::lexical_cast<int>(w[1]); const int point2 = boost::lexical_cast<int>(w[2]); const int point3 = boost::lexical_cast<int>(w[3]); assert(point1 >= 0); //Start at index 0 assert(point2 >= 0); //Start at index 0 assert(point3 >= 0); //Start at index 0 assert(point1 - 0 < static_cast<int>(m_points.size())); assert(point2 - 0 < static_cast<int>(m_points.size())); assert(point3 - 0 < static_cast<int>(m_points.size())); const std::vector<int> face_point_indices { point1-0, //Start at index 0 point2-0, //Start at index 0 point3-0 //Start at index 0 }; m_edges.push_back(std::make_pair(face_point_indices[0],face_point_indices[1])); m_edges.push_back(std::make_pair(face_point_indices[0],face_point_indices[2])); m_edges.push_back(std::make_pair(face_point_indices[1],face_point_indices[2])); std::vector<boost::shared_ptr<Point>> face_points { m_points[point1-0], //Start at index 0 m_points[point2-0], //Start at index 0 m_points[point3-0] //Start at index 0 }; if (!Helper().IsClockwiseHorizontal(face_points)) { std::reverse(face_points.begin(),face_points.end()); } assert(Helper().IsClockwiseHorizontal(face_points)); if (!Helper().IsConvex(face_points)) { Helper().MakeConvex(face_points); } assert(Helper().IsConvex(face_points) && "FaceFactory only accepts convex ordered points"); const boost::shared_ptr<Face> face { FaceFactory().Create( face_points, FaceOrientation::horizontal, verbose ) }; m_faces.push_back(face); m_face_point_indices.push_back(face_point_indices); assert(std::unique(m_face_point_indices.begin(),m_face_point_indices.end()) == m_face_point_indices.end() && "Every face should have unique point indices"); } } #ifndef NDEBUG if (verbose) { TRACE("Checking the result"); } const int n_faces = static_cast<int>(m_faces.size()); assert(m_faces.size() == m_face_point_indices.size()); for (int i=0; i!=n_faces; ++i) { const auto face = m_faces[i]; const auto indices = m_face_point_indices[i]; assert(face->GetPoints().size() == indices.size()); } #endif for (auto& p: m_edges) { if (p.first > p.second) std::swap(p.first,p.second); assert(p.first < p.second); } std::sort(m_edges.begin(),m_edges.end()); auto new_end = std::unique(m_edges.begin(),m_edges.end()); m_edges.erase(new_end,m_edges.end()); if (verbose) { TRACE("Done checking the result"); } }
TreeNode* sortedArrayToBST(vector<int>& nums) { return Helper(nums, 0, nums.size()); }
boost::shared_ptr<ribi::trim::Template> ribi::trim::Template::CreateTestTriangle2x2() noexcept { std::vector<boost::shared_ptr<Face>> faces; std::vector<std::vector<int>> face_point_indices; std::vector<boost::shared_ptr<Point>> points; const int width{2}; //const int height = 2; const int n_points{3}; //Triangle const bool verbose{false}; points.reserve(n_points); //Create points { for(int i=0; i!=n_points; ++i) { const double x = static_cast<double>(i % width); const double y = static_cast<double>(i / width); const std::string boundary_type{"two_times_two"}; const boost::shared_ptr<const ConstCoordinat2D> bottom { new ConstCoordinat2D(x,y) }; const boost::shared_ptr<Point> point { PointFactory().Create(bottom) }; points.push_back(point); } } #ifndef NDEBUG //Check that there is no coordinat present twice { for (int i=0; i!=n_points; ++i) { const boost::shared_ptr<const ConstCoordinat2D> a { points[i]->GetCoordinat() }; for (int j=0; j!=n_points; ++j) { const boost::shared_ptr<const ConstCoordinat2D> b { points[j]->GetCoordinat() }; if (a == b) { assert(boost::geometry::distance(*a,*b) < 0.001); } else { assert(boost::geometry::distance(*a,*b) > 0.001); } } } } #endif //Load and translate faces face_point_indices = { { 0,1,2 } }; const std::vector<std::pair<int,int>> edges { { 0,1 }, { 0,2 }, { 1,2 } }; { for(const auto v: face_point_indices) { assert(v.size() == 3); //I do not correct for one-base Triangle.exe output assert(v[0] >= 0); assert(v[1] >= 0); assert(v[2] >= 0); std::vector<boost::shared_ptr<Point>> face_points { points[ v[0] ], points[ v[1] ], points[ v[2] ] }; if (!Helper().IsClockwiseHorizontal(face_points)) { std::reverse(face_points.begin(),face_points.end()); } #ifndef NDEBUG if (!Helper().IsClockwiseHorizontal(face_points)) { TRACE("ERROR"); TRACE(*face_points[0]); TRACE(*face_points[1]); TRACE(*face_points[2]); TRACE("BREAK"); } #endif assert(Helper().IsClockwiseHorizontal(face_points)); const boost::shared_ptr<Face> face { FaceFactory().Create( face_points, FaceOrientation::horizontal, verbose ) }; faces.push_back(face); } } #ifndef NDEBUG const int n_faces = static_cast<int>(faces.size()); assert(faces.size() == face_point_indices.size()); for (int i=0; i!=n_faces; ++i) { const auto face = faces[i]; const auto indices = face_point_indices[i]; assert(face->GetPoints().size() == indices.size()); } #endif assert(faces.size() == 1 && "A triangle is only 1 triangle"); assert(edges.size() == 3 && "A triangle has 3 edges"); assert(points.size() == 3 && "A triangle has 3 nodes"); const boost::shared_ptr<Template> my_template { new Template( edges, faces, face_point_indices, points ) }; assert(my_template); return my_template; }
bool SortedAggregator::Advance(AbstractTuple *next_tuple) { bool start_new_agg = false; // Check if we are starting a new aggregate tuple if (delegate_tuple_values_.empty()) { // No current group LOG_TRACE("Current group keys are empty!"); start_new_agg = true; } else { // Current group exists PL_ASSERT(delegate_tuple_values_.size() == num_input_columns_); // Check whether crossed group boundary for (oid_t grpColOffset = 0; grpColOffset < node->GetGroupbyColIds().size(); grpColOffset++) { common::Value lval = ( next_tuple->GetValue(node->GetGroupbyColIds()[grpColOffset])); common::Value rval = ( delegate_tuple_.GetValue(node->GetGroupbyColIds()[grpColOffset])); common::Value cmp = (lval.CompareNotEquals(rval)); bool not_equal = cmp.IsTrue(); if (not_equal) { LOG_TRACE("Group-by columns changed."); // Call helper to output the current group result if (!Helper(node, aggregates, output_table, &delegate_tuple_, this->executor_context)) { return false; } start_new_agg = true; break; } } } // If we have started a new aggregate tuple if (start_new_agg) { LOG_TRACE("Started a new group!"); // Create aggregate for (oid_t aggno = 0; aggno < node->GetUniqueAggTerms().size(); aggno++) { // Clean up previous aggregate delete aggregates[aggno]; aggregates[aggno] = GetAggInstance(node->GetUniqueAggTerms()[aggno].aggtype); bool distinct = node->GetUniqueAggTerms()[aggno].distinct; aggregates[aggno]->SetDistinct(distinct); } // Update delegate tuple values delegate_tuple_values_.clear(); for (oid_t col_id = 0; col_id < num_input_columns_; col_id++) { // delegate_tuple_values_ has the ownership common::Value val = next_tuple->GetValue(col_id); delegate_tuple_values_.push_back(val); } } // Update the aggregation calculation for (oid_t aggno = 0; aggno < node->GetUniqueAggTerms().size(); aggno++) { auto predicate = node->GetUniqueAggTerms()[aggno].expression; common::Value value = common::ValueFactory::GetIntegerValue(1); if (predicate) { value = node->GetUniqueAggTerms()[aggno].expression->Evaluate( next_tuple, nullptr, this->executor_context); } aggregates[aggno]->Advance(value); } return true; }
boost::shared_ptr<ribi::trim::Template> ribi::trim::Template::CreateTest3x3() noexcept { std::vector<boost::shared_ptr<Face>> faces; std::vector<std::vector<int>> face_point_indices; std::vector<boost::shared_ptr<Point>> points; const int width{3}; const int height{3}; const int n_points{width * height}; const bool verbose{false}; points.reserve(n_points); //Create points { for(int i=0; i!=n_points; ++i) { const double x{static_cast<double>(i % width)}; const double y{static_cast<double>(i / width)}; const std::string boundary_type = "three_times_three"; const boost::shared_ptr<const ConstCoordinat2D> bottom{ new ConstCoordinat2D(x,y) }; const auto point = PointFactory().Create(bottom); points.push_back(point); } } #ifndef NDEBUG //Check that there is no coordinat present twice { for (int i=0; i!=n_points; ++i) { const boost::shared_ptr<const ConstCoordinat2D> a { points[i]->GetCoordinat() }; for (int j=0; j!=n_points; ++j) { const boost::shared_ptr<const ConstCoordinat2D> b { points[j]->GetCoordinat() }; if (a == b) { assert(boost::geometry::distance(*a,*b) < 0.001); } else { assert(boost::geometry::distance(*a,*b) > 0.001); } } } } #endif //Load and translate faces face_point_indices = { { 0,1,3 }, { 1,2,4 }, { 1,3,4 }, { 2,4,5 }, { 3,4,6 }, { 4,5,7 }, { 4,6,7 }, { 5,7,8 } }; const std::vector<std::pair<int,int>> edges { { 0,1 }, { 0,3 }, { 1,2 }, { 1,3 }, { 1,4 }, { 2,4 }, { 2,5 }, { 3,4 }, { 3,6 }, { 4,5 }, { 4,6 }, { 4,7 }, { 5,7 }, { 5,8 }, { 6,7 }, { 7,8 } }; { for(const auto v: face_point_indices) { assert(v.size() == 3); //I do not correct for one-base Triangle.exe output const int point1 = v[0]; const int point2 = v[1]; const int point3 = v[2]; assert(point1 >= 0); assert(point2 >= 0); assert(point3 >= 0); const std::vector<int> face_point_indices { point1, point2, point3 }; std::vector<boost::shared_ptr<Point>> face_points { points[point1], points[point2], points[point3] }; if (!Helper().IsClockwiseHorizontal(face_points)) { std::reverse(face_points.begin(),face_points.end()); } assert(Helper().IsClockwiseHorizontal(face_points)); const boost::shared_ptr<Face> face { FaceFactory().Create( face_points, FaceOrientation::horizontal, verbose ) }; faces.push_back(face); } } #ifndef NDEBUG const int n_faces = static_cast<int>(faces.size()); assert(faces.size() == face_point_indices.size()); for (int i=0; i!=n_faces; ++i) { const auto face = faces[i]; const auto indices = face_point_indices[i]; assert(face->GetPoints().size() == indices.size()); /* const int n_points = static_cast<int>(indices.size()); for (int j=0; j!=n_points; ++j) { //Only true when points are not reversed assert(face->GetPoints()[j] == points[ indices[j] ]); } */ } #endif assert(faces.size() == 8 && "2x2 adjacent squares consist of 8 triangles"); assert(edges.size() == 16 && "2x2 adjacent squares (with diagonals) have 16 edges"); assert(points.size() == 9 && "2x2 adjacent squares have 9 nodes"); const boost::shared_ptr<Template> my_template { new Template( edges, faces, face_point_indices, points ) }; assert(my_template); return my_template; }
int findPeakElement(const vector<int> &num) { return Helper(num, 0, num.size()-1); }
void ribi::trim::Template::Test() noexcept { { static bool is_tested{false}; if (is_tested) return; is_tested = true; } PointFactory(); FaceFactory(); const TestTimer test_timer(__func__,__FILE__,1.0); const bool verbose{false}; if (verbose) { TRACE("IsClockWise, confirmation"); } { /* Cartesian plane | | A = (0,1) /|\ / | \ ---+--+--+---- / | \ C----+----B | | */ //12 o'clock const boost::shared_ptr<const ConstCoordinat2D> a { new ConstCoordinat2D(0.0,1.0) }; //4 o'clock const boost::shared_ptr<const ConstCoordinat2D> b { new ConstCoordinat2D(0.83,-0.5) }; //8 o'clock const boost::shared_ptr<const ConstCoordinat2D> c { new ConstCoordinat2D(-0.83,-0.5) }; std::vector<boost::shared_ptr<Point>> points { PointFactory().Create(a), PointFactory().Create(b), PointFactory().Create(c) }; points[0]->SetZ(1.0 * boost::units::si::meter); points[1]->SetZ(1.0 * boost::units::si::meter); points[2]->SetZ(1.0 * boost::units::si::meter); assert( Helper().IsClockwiseHorizontal(points)); std::reverse(points.begin(),points.end()); assert(!Helper().IsClockwiseHorizontal(points)); } if (verbose) { TRACE("IsClockWise, rejection"); } { /* Cartesian plane | | A = (0,1) /|\ / | \ ---+--+--+---- / | \ B----+----C | | */ //12 o'clock const boost::shared_ptr<const ConstCoordinat2D> a { new ConstCoordinat2D(0.0,1.0) }; //8 o'clock const boost::shared_ptr<const ConstCoordinat2D> b { new ConstCoordinat2D(-0.83,-0.5) }; //4 o'clock const boost::shared_ptr<const ConstCoordinat2D> c { new ConstCoordinat2D(0.83,-0.5) }; std::vector<boost::shared_ptr<Point>> points { PointFactory().Create(a), PointFactory().Create(b), PointFactory().Create(c) }; points[0]->SetZ(1.0 * boost::units::si::meter); points[1]->SetZ(1.0 * boost::units::si::meter); points[2]->SetZ(1.0 * boost::units::si::meter); assert(!Helper().IsClockwiseHorizontal(points)); std::reverse(points.begin(),points.end()); assert(Helper().IsClockwiseHorizontal(points)); } for (int i=0; i!=4; ++i) { const boost::shared_ptr<Template> my_template { CreateTest(i) }; assert(my_template); for (const auto& face: my_template->GetFaces()) { if (!Helper().IsClockwiseHorizontal(face->GetPoints())) { TRACE("BREAK"); } assert(Helper().IsClockwiseHorizontal(face->GetPoints())); } } }
int t9(int n) { // Make sure the error works in potentially-evaluated sizeof return (int)sizeof(*(Helper(Foo()), (int (*)[n])0)); // expected-warning{{cannot pass object of non-POD type}} }
vector<vector<int>> permuteUnique(vector<int>& nums) { vector<vector<int>> res; Helper(nums, 0, res); return res; }