Пример #1
0
bool CrossingPaths::WillPathsCross(std::map<std::pair<int, int>, int>& pathMap, std::pair<int, int>& position, int changeX, int changeY)
{
	bool hasCrossed = false;
	bool isNegative = false;
	if (changeX != 0)
	{
		isNegative = changeX < 0;
		for (int i = 0; i < std::abs(changeX); i++)
		{
			position.first += isNegative ? -1 : 1;

			if (!hasCrossed)
			{
				hasCrossed = IsNodeInMap(pathMap, position);
			}
			pathMap.emplace(position, 1);
		}
	}

	else 
	{
		isNegative = changeY < 0;
		for (int i = 0; i < std::abs(changeY); i++)
		{
			position.second += isNegative ? -1 : 1;
			if (!hasCrossed)
			{
				hasCrossed = IsNodeInMap(pathMap, position);
			}
			pathMap.emplace(position, 1);
		}
	}

	return hasCrossed;
}
Пример #2
0
Файл: lib.cpp Проект: biotty/rmg
void
init_filters()
{
    filters.emplace("comb", std::make_unique<comb>());
    filters.emplace("echo", std::make_unique<echo>());
    filters.emplace("biquad", std::make_unique<biqd>());
}
Пример #3
0
static void emplaceString(std::map<std::string, Kdbx::XorredBuffer>& strings, const char* name, const QByteArray& data, bool protect, QWidget* widget){
	if (protect){
		std::vector<uint8_t> mask = getRandomBytes(data.size(), widget);
		strings.emplace(name, Kdbx::XorredBuffer::fromRaw(data.begin(), data.end(), mask.begin()));
	}else{
		strings.emplace(name, Kdbx::XorredBuffer(data.begin(), data.end()));
	}
}
static void
addRangeToDetails(std::map<std::string, std::string> &a, const char *minKey,
                  const char *maxKey,
                  const std::pair<uint16_t, uint16_t> &range)
{
    a.emplace(minKey, ring::to_string(range.first));
    a.emplace(maxKey, ring::to_string(range.second));
}
Пример #5
0
void add_color_info(const config& v, bool build_defaults)
{
	if(build_defaults) {
		default_colors.clear();
	}

	for(const config& teamC : v.child_range("color_range")) {
		const config::attribute_value* a1 = teamC.get("id"), *a2 = teamC.get("rgb");
		if(!a1 || !a2) {
			continue;
		}

		std::string id = *a1;
		std::vector<color_t> temp;

		for(const auto& s : utils::split(*a2)) {
			try {
				temp.push_back(color_t::from_hex_string(s));
			} catch(const std::invalid_argument&) {
				std::stringstream ss;
				ss << "can't parse color string:\n" << teamC.debug() << "\n";
				throw config::error(ss.str());
			}
		}

		team_rgb_range.emplace(id, color_range(temp));
		team_rgb_name.emplace(id, teamC["name"].t_str());

		LOG_NG << "registered color range '" << id << "': " << team_rgb_range[id].debug() << '\n';

		// Ggenerate palette of same name;
		std::vector<color_t> tp = palette(team_rgb_range[id]);
		if(!tp.empty()) {
			team_rgb_colors.emplace(id, tp);
		}

		if(build_defaults && teamC["default"].to_bool()) {
			default_colors.push_back(*a1);
		}
	}

	for(const config &cp : v.child_range("color_palette")) {
		for(const config::attribute& rgb : cp.attribute_range()) {
			std::vector<color_t> temp;
			for(const auto& s : utils::split(rgb.second)) {
				try {
					temp.push_back(color_t::from_hex_string(s));
				} catch(const std::invalid_argument&) {
					ERR_NG << "Invalid color in palette: " << s << std::endl;
				}
			}

			team_rgb_colors.emplace(rgb.first, temp);
			LOG_NG << "registered color palette: " << rgb.first << '\n';
		}
	}
}
Пример #6
0
Файл: lib.cpp Проект: biotty/rmg
void
init_orchestra()
{
    orchestra.emplace("beep", std::make_unique<beep>());
    orchestra.emplace("amp-mod", std::make_unique<amp_mod>());
    orchestra.emplace("freq-mod", std::make_unique<freq_mod>());
    orchestra.emplace("ks-string", std::make_unique<ks_string>());
    orchestra.emplace("diphthong", std::make_unique<diphthong>());
}
/** create a map of the workspaces corresponding to each bank
  * @param banks :: [input] list of bank IDs; must not be empty. must not have
 * duplicate entries.
  * @param workspaces :: [input] list of corresponding workspaces or empty
 * vector for default  MAY NEED TO BE size_t <int, size_t>
  * @param workspaceOfBank :: [output] map to indicate the workspace that a
 * bank's parameters will be put in
  */
void LoadFullprofResolution::createBankToWorkspaceMap(
    const std::vector<int> &banks, const std::vector<int> &workspaces,
    std::map<int, size_t> &workspaceOfBank) {
  if (workspaces.size() == 0) {
    for (size_t i = 0; i < banks.size(); i++) {
      workspaceOfBank.emplace(banks[i], i + 1);
    }
  } else {
    for (size_t i = 0; i < banks.size(); i++) {
      workspaceOfBank.emplace(banks[i], workspaces[i]);
    }
  }
}
Пример #8
0
unsigned int getTextura(const char *path) {
	auto it = texturas.find(path);
	if(it != texturas.end())
		return it->second;
	else {
		GLuint textureID;
		unsigned int t[2], tw, th;
		unsigned char *texData;
		ilGenImages(2,t);
		ilBindImage(t[0]);
		ilLoadImage((ILstring)path);
		tw = ilGetInteger(IL_IMAGE_WIDTH);
		th = ilGetInteger(IL_IMAGE_HEIGHT);
		ilConvertImage(IL_RGBA, IL_UNSIGNED_BYTE);
		texData = ilGetData();
	
		glGenTextures(1,&textureID); // unsigned int texID  - variavel global;
	
		glBindTexture(GL_TEXTURE_2D,textureID);
		glTexParameteri(GL_TEXTURE_2D,	GL_TEXTURE_WRAP_S,		GL_REPEAT);
		glTexParameteri(GL_TEXTURE_2D,	GL_TEXTURE_WRAP_T,		GL_REPEAT);

		glTexParameteri(GL_TEXTURE_2D,	GL_TEXTURE_MAG_FILTER,   	GL_LINEAR);
		glTexParameteri(GL_TEXTURE_2D,	GL_TEXTURE_MIN_FILTER,    	GL_LINEAR);
		
		glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, tw, th, 0, GL_RGBA, GL_UNSIGNED_BYTE, texData);

		texturas.emplace(path, textureID);
		return textureID;
	}
}
Пример #9
0
 void pre_generation(std::array<TERRAIN_FEATURES, 6> & ambient_relief)
 {
     std::random_device rd;
     std::mt19937 gen(rd());
     std::vector<std::pair<TERRAIN_FEATURES, int>> features_and_frequencies = {std::make_pair(TERRAIN_FEATURES::WATER, 1)};
     for (size_t i = 0; i < 6; i++)
     {
         auto it = find_if(features_and_frequencies.begin(), features_and_frequencies.end(),
                         [&ambient_relief, i](std::pair<TERRAIN_FEATURES, int> & p){return p.first == ambient_relief[i];});
         if(it == features_and_frequencies.end())
             features_and_frequencies.push_back(std::make_pair(ambient_relief[i], 1));
         else
             it->second++;
     }
     std::vector<int> frequencies;
     for (size_t i = 0; i < features_and_frequencies.size(); i++)
         frequencies.push_back(features_and_frequencies[i].second);
     std::discrete_distribution<> d(frequencies.begin(), frequencies.end());
     for (int i = -SIDE_SIZE + 1; i < SIDE_SIZE; i++)
     {
         for (int j = -SIDE_SIZE + 1; j < SIDE_SIZE; j++)
         {
             for (int k = -SIDE_SIZE + 1; k < SIDE_SIZE; k++)
             {
                 if (i + j + k != 0)
                     continue;
                 TERRAIN_FEATURES feature = features_and_frequencies[d(gen)].first;
                 std::array<grid_tile *, 6> neighbours =
                         {nullptr, nullptr, nullptr, nullptr, nullptr, nullptr};
                 battleground.emplace(std::make_tuple(i, j, k), grid_tile(neighbours, i, j, k, nullptr, feature));
                 //battleground[14*i + j] = grid_tile(neighbours, i, j, nullptr, feature);
             }
         }
     }
 }
Пример #10
0
/** Fills the unit map and ordered vector with the same data
  * @param orderedVector the vector to fill
  * @param unitMap the map to fill
  * @param caption the caption of the unit
  * @param unit the unit of measure of the unit
  */
void ConvertAxesToRealSpace::fillUnitMap(
    std::vector<std::string> &orderedVector,
    std::map<std::string, std::string> &unitMap, const std::string &caption,
    const std::string &unit) {
  unitMap.emplace(caption, unit);
  orderedVector.push_back(caption);
}
Пример #11
0
static void FinishRead(u64 id, s64 cycles_late)
{
  // We can't simply pop s_result_queue and always get the ReadResult
  // we want, because the DVD thread may add ReadResults to the queue
  // in a different order than we want to get them. What we do instead
  // is to pop the queue until we find the ReadResult we want (the one
  // whose ID matches userdata), which means we may end up popping
  // ReadResults that we don't want. We can't add those unwanted results
  // back to the queue, because the queue can only have one writer.
  // Instead, we add them to a map that only is used by the CPU thread.
  // When this function is called again later, it will check the map for
  // the wanted ReadResult before it starts searching through the queue.
  ReadResult result;
  auto it = s_result_map.find(id);
  if (it != s_result_map.end())
  {
    result = std::move(it->second);
    s_result_map.erase(it);
  }
  else
  {
    while (true)
    {
      while (!s_result_queue.Pop(result))
        s_result_queue_expanded.Wait();

      if (result.first.id == id)
        break;
      else
        s_result_map.emplace(result.first.id, std::move(result));
    }
  }
  // We have now obtained the right ReadResult.

  const ReadRequest& request = result.first;
  const std::vector<u8>& buffer = result.second;

  DEBUG_LOG(DVDINTERFACE, "Disc has been read. Real time: %" PRIu64 " us. "
                          "Real time including delay: %" PRIu64 " us. "
                          "Emulated time including delay: %" PRIu64 " us.",
            request.realtime_done_us - request.realtime_started_us,
            Common::Timer::GetTimeUs() - request.realtime_started_us,
            (CoreTiming::GetTicks() - request.time_started_ticks) /
                (SystemTimers::GetTicksPerSecond() / 1000000));

  if (buffer.size() != request.length)
  {
    PanicAlertT("The disc could not be read (at 0x%" PRIx64 " - 0x%" PRIx64 ").",
                request.dvd_offset, request.dvd_offset + request.length);
  }
  else
  {
    if (request.copy_to_ram)
      Memory::CopyToEmu(request.output_address, buffer.data(), request.length);
  }

  // Notify the emulated software that the command has been executed
  DVDInterface::FinishExecutingCommand(request.reply_type, DVDInterface::INT_TCINT, cycles_late,
                                       buffer);
}
Пример #12
0
std::pair<MatVec*, bool>
SimpleMatrixVectorProvider::
get_(std::size_t& id,
     std::map<std::size_t, MatVec*>& unused_map,
     std::map<MatVec*, std::size_t>& used_map,
     Args&&... args)
{
    if (id >= _next_id) {
        OGS_FATAL("An obviously uninitialized id argument has been passed."
            " This might not be a serious error for the current implementation,"
            " but it might become one in the future."
            " Hence, I will abort now.");
    }

    if (do_search)
    {
        auto it = unused_map.find(id);
        if (it != unused_map.end()) // unused matrix/vector found
            return { ::detail::transfer(unused_map, used_map, it), false };
    }

    // not searched or not found, so create a new one
    id = _next_id++;
    auto res = used_map.emplace(
        MathLib::MatrixVectorTraits<MatVec>::newInstance(std::forward<Args>(args)...).release(),
        id);
    assert(res.second && "Emplacement failed.");
    return { res.first->first, true };
}
// "flood fill" a tile name to adjacent tiles of certain terrain
static void flood_name(const map_location& start, const std::string& name, std::map<map_location,std::string>& tile_names,
	const t_translation::ter_match& tile_types, const terrain_map& terrain,
	unsigned width, unsigned height,
	size_t label_count, std::map<map_location,std::string>* labels, const std::string& full_name) {
	map_location adj[6];
	get_adjacent_tiles(start,adj);
	size_t n;
	//if adjacent tiles are tiles and unnamed, name them
	for(n = 0; n < 6; n++) {
		//we do not care for tiles outside the middle part
		//cast to unsigned to skip x < 0 || y < 0 as well.
		if(unsigned(adj[n].x) >= width / 3 || unsigned(adj[n].y) >= height / 3) {
			continue;
		}

		const t_translation::terrain_code terr = terrain[adj[n].x + (width / 3)][adj[n].y + (height / 3)];
		const map_location loc(adj[n].x, adj[n].y);
		if((t_translation::terrain_matches(terr, tile_types)) && (tile_names.find(loc) == tile_names.end())) {
			tile_names.emplace(loc, name);
			//labeling decision: this is result of trial and error on what looks best in game
			if(label_count % 6 == 0) { //ensure that labels do not occur more often than every 6 recursions
				labels->emplace(loc, full_name);
				label_count++; //ensure that no adjacent tiles get labeled
			}
			flood_name(adj[n], name, tile_names, tile_types, terrain, width, height, label_count++, labels, full_name);
		}
	}
}
Пример #14
0
bool LockDirectory(const fs::path& directory, const std::string lockfile_name, bool probe_only)
{
    std::lock_guard<std::mutex> ulock(cs_dir_locks);
    fs::path pathLockFile = directory / lockfile_name;

    // If a lock for this directory already exists in the map, don't try to re-lock it
    if (dir_locks.count(pathLockFile.string())) {
        return true;
    }

    // Create empty lock file if it doesn't exist.
    FILE* file = fsbridge::fopen(pathLockFile, "a");
    if (file) fclose(file);

    try {
        auto lock = MakeUnique<boost::interprocess::file_lock>(pathLockFile.string().c_str());
        if (!lock->try_lock()) {
            return false;
        }
        if (!probe_only) {
            // Lock successful and we're not just probing, put it into the map
            dir_locks.emplace(pathLockFile.string(), std::move(lock));
        }
    } catch (const boost::interprocess::interprocess_exception& e) {
        return error("Error while attempting to lock directory %s: %s", directory.string(), e.what());
    }
    return true;
}
Пример #15
0
void cy::argp_register(const std::string& cmd, int32_t uid, argp_cmd_type cmd_type, argp_param_type param_type)
{
	// check arguments
	if(cmd.empty())
		throw std::runtime_error("no command given");
	if(cmd_type == ARGP_CT_SINGLE && cmd.size() != 1)
		throw std::runtime_error("command of type 'single' cannot contain multiple characters");

	// check for uid uniqueness
	if(g_cmd_registry.find(uid) != g_cmd_registry::end)
		throw std::runtime_error("given uid not unique");
	if(uid_is_reserved(uid))
		throw std::runtime_error("given uid is reserved!");
	
	// check for command uniqueness
	for(std::map<int32_t, cy::argp_arg_extra_info>::iterator it = g_cmd_registry.begin(); it != g_cmd_registry.end(); it++)
	{
		if(cmd == it->second.cmd && cmd_type == it->second.cmd_type)
			throw std::runtime_error("equivalent command already registered");
	}

	// construct the info struct
	cy::argp_arg_extra_info aaei = make_info_struct(cmd, cmd_type, param_type);

	// put in registry
	g_cmd_registry.emplace(uid, aaei);
}
Пример #16
0
void map_insert(std::map<RK,RV>& m, PK&& k, PV&& v) 
{
    static_assert(std::is_same<RK,typename std::decay<PK>::type>::value, "implicit conversions disallowed for the key!");
    m.emplace(std::piecewise_construct,
        std::forward_as_tuple(std::forward<PK>(k)),
        std::forward_as_tuple(std::forward<PV>(v)));
}
Пример #17
0
void Profiler::TimerStart(const std::string timerName, const char* sourceFile, const char* func, unsigned int line)
{
	std::pair<std::map<std::string,StopWatchItem>::iterator,bool> ret;
	Profiler::initLogger();

	StopWatchItem item = {sourceFile, func, line};

	ret = GlobalProfilerMap.emplace(timerName, item);
	if ( ! ret.second )
	{
		if ( ret.first->second.sourceFile == sourceFile && ret.first->second.func == func && ret.first->second.line == line )
		{
			_logger->Message(Logger::DEBUG, sourceFile, func, line, "restart timer '%s'", timerName.c_str() );
			ret.first->second.startTime = clock();
		}
		else
		{
			_logger->Message(Logger::DEBUG, sourceFile, func, line, "ERROR timer '%s' started in multiple locations. First occurence %s:%d:%s()",
			                 timerName.c_str(), profiler_getBaseName(ret.first->second.sourceFile).c_str(), ret.first->second.line, ret.first->second.func );
		}
	}
	else
	{
		_logger->Message(Logger::DEBUG, sourceFile, func, line, "start timer '%s'", timerName.c_str() );
	}
}
Пример #18
0
void
registerHleModule(const std::string &name,
                  HleModule *module)
{
   if (std::find(decaf::config::system::lle_modules.begin(),
                 decaf::config::system::lle_modules.end(),
                 name) != decaf::config::system::lle_modules.end()) {
      gLog->warn("Replacing HLE with LLE for module {}.", name);
      return;
   }

   // Register module
   decaf_check(sHleModules.find(name) == sHleModules.end());
   sHleModules.emplace(name, module);

   // Register every function symbol
   auto &symbolMap = module->getSymbolMap();

   for (auto &pair : symbolMap) {
      auto symbol = pair.second;

      if (symbol->type == HleSymbol::Function) {
         registerHleFunc(reinterpret_cast<HleFunction *>(symbol));
      }
   }
}
Пример #19
0
void setupSprites()
{
	// Serious hate.
	{
		PickupData p(Pickup::Food, Sprites::FOOD_TURKEY);
		p.Health = 10;
		pickups.emplace(
			p.Type,
			p
		);
	}
	{
		PickupData p(Pickup::Ammo, Sprites::GUN_AMMO);
		p.Ammo = 8;
		pickups.emplace(
			p.Type,
			p
		);
	}
	{
		PickupData p(Pickup::Smg, Sprites::GUN_SMG);
		p.Weapon = Weapon::Smg;
		pickups.emplace(
			p.Type,
			p
		);
	}
	{
		PickupData p(Pickup::Chest, Sprites::TREASURE_CHEST);
		p.Score = 1000;
		pickups.emplace(
			p.Type,
			p
		);
	}
	{
		PickupData p(Pickup::Chalice, Sprites::TREASURE_CHALICE);
		p.Score = 100;
		pickups.emplace(
			p.Type,
			p
		);
	}
	// gruel is 4hp
	// blood is 1hp if < 11hp
	// medkit is 25 hp
}
Пример #20
0
void RPCRunLater(const std::string& name, std::function<void(void)> func, int64_t nSeconds)
{
    if (!timerInterface)
        throw JSONRPCError(RPC_INTERNAL_ERROR, "No timer handler registered for RPC");
    deadlineTimers.erase(name);
    LogPrint(BCLog::RPC, "queue run of timer %s in %i seconds (using %s)\n", name, nSeconds, timerInterface->Name());
    deadlineTimers.emplace(name, std::unique_ptr<RPCTimerBase>(timerInterface->NewTimer(func, nSeconds*1000)));
}
Пример #21
0
 Detector & create_default(box2d<double> const & extent)
 {
     auto it = cache_.emplace(
         std::piecewise_construct,
         std::forward_as_tuple("default"),
         std::forward_as_tuple(extent)).first;
     return it->second;
 }
Пример #22
0
 inline void setDestinationOutStream(){
     TokenId ti;
     ti.setOutputStream();
     tOutput[dOutput] = OutputToken(NULL, ti);
     destinationsMap.emplace((Computable*) NULL, dOutput);
     ++dOutput;
     assert(dOutput <= MAX_INSTRUCTION_INPUTS);
 }
Пример #23
0
static void insertEntity(const QJsonValue &value, std::map<QString, Entity::Ptr> &map,
                         std::vector<QString> &texts)
{
    Entity::Ptr entity {new T(value.toObject())};
    if (!private_util::hasValue(map, entity->text())) {
        texts.push_back(entity->text());
    }
    map.emplace(entity->text(), entity);
}
Пример #24
0
void json_flag::load( JsonObject &jo )
{
    auto id = jo.get_string( "id" );
    auto &f = json_flags_all.emplace( id, json_flag( id ) ).first->second;

    jo.read( "info", f.info_ );
    jo.read( "conflicts", f.conflicts_ );
    jo.read( "inherit", f.inherit_ );
}
Пример #25
0
 inline void setSource(Computable* c = NULL){
     if(c){
         sourcesMap.emplace(c, dInput);
     }else{
         throw std::runtime_error("Impossible to set NULL source.");
     }
     ++dInput;
     assert(dInput <= MAX_INSTRUCTION_INPUTS);
 }
Пример #26
0
	bool validate_property(Command * object, unsigned int index)
	{
		const std::string & identifier = *object->payload.property_.identifier;
		if (structure_properties.find(identifier) != structure_properties.end())
			return false;
		structure_properties.emplace(identifier, index);
		return true;
		
	}
Пример #27
0
bool CppParser::addRenamedKeyword(const std::string& keyword, std::string renamedKeyword)
{
  extern int GetKeywordId(const std::string& keyword);
  auto       id = GetKeywordId(keyword);
  if (id == -1)
    return false;
  gRenamedKeywords.emplace(std::make_pair(std::move(renamedKeyword), id));

  return true;
}
Пример #28
0
void
registerHleModuleAlias(const std::string &module, const std::string &alias)
{
   auto itr = gHleModules.find(module);

   // TODO: Error if the module is missing!
   if (itr != gHleModules.end()) {
      gHleModules.emplace(alias, itr->second);
   }
}
Пример #29
0
static void load_replacement_mods( const std::string path )
{
    read_from_file_optional_json( path, [&]( JsonIn &jsin ) {
        jsin.start_array();
        while (!jsin.end_array()) {
            auto arr = jsin.get_array();
            mod_replacements.emplace( arr.get_string( 0 ), arr.size() > 1 ? arr.get_string( 1 ) : "" );
        }
    } );
}
Пример #30
0
 MemoryDB&
 open (std::string const& path)
 {
     std::lock_guard<std::mutex> _(mutex_);
     auto const result = map_.emplace (std::piecewise_construct,
         std::make_tuple(path), std::make_tuple());
     MemoryDB& db = result.first->second;
     if (db.open)
         throw std::runtime_error("already open");
     return db;
 }