bool findFab(std::multimap<int,int> pai, pair<int,int> couple)
{
std::multimap<int,int>::iterator it = pai.end();
if(pai.size() == 0) return false;
for ( it = pai.equal_range(couple.first).first; it != pai.equal_range(couple.first).second; ++it)
if( equals(couple, (*it)) )
return true;
return false;
}
bool
MAST::StructuralElementBase::side_external_force(bool request_jacobian,
DenseRealVector &f,
DenseRealMatrix &jac,
std::multimap<libMesh::boundary_id_type, MAST::BoundaryCondition*>& bc) {
// iterate over the boundary ids given in the provided force map
std::pair<std::multimap<libMesh::boundary_id_type, MAST::BoundaryCondition*>::const_iterator,
std::multimap<libMesh::boundary_id_type, MAST::BoundaryCondition*>::const_iterator> it;
const libMesh::BoundaryInfo& binfo = *_system.get_mesh().boundary_info;
// for each boundary id, check if any of the sides on the element
// has the associated boundary
bool calculate_jac = false;
for (unsigned short int n=0; n<_elem.n_sides(); n++) {
if (!binfo.n_boundary_ids(&_elem, n))
continue;
std::vector<libMesh::boundary_id_type> bc_ids = binfo.boundary_ids(&_elem, n);
std::vector<libMesh::boundary_id_type>::const_iterator bc_it = bc_ids.begin();
for ( ; bc_it != bc_ids.end(); bc_it++) {
// find the loads on this boundary and evaluate the f and jac
it =bc.equal_range(*bc_it);
for ( ; it.first != it.second; it.first++) {
// apply all the types of loading
switch (it.first->second->type()) {
case MAST::SURFACE_PRESSURE:
calculate_jac = (calculate_jac ||
surface_pressure_force(request_jacobian,
f, jac,
n,
*it.first->second));
break;
case MAST::SMALL_DISTURBANCE_MOTION:
calculate_jac = (calculate_jac ||
small_disturbance_surface_pressure_force<ValType>(request_jacobian,
f, jac,
n,
*it.first->second));
break;
case MAST::DISPLACEMENT_DIRICHLET:
// nothing to be done here
break;
default:
// not implemented yet
libmesh_error();
break;
}
}
}
}
return (request_jacobian && calculate_jac);
}
bool World::DeletePersistentData(const PersistentDataItem &item)
{
int id = item.raw_id();
if (id > -100)
return false;
if (!BuildPersistentCache())
return false;
stl::vector<df::historical_figure*> &hfvec = df::historical_figure::get_vector();
auto eqrange = persistent_index.equal_range(item.key());
for (auto it2 = eqrange.first; it2 != eqrange.second; )
{
auto it = it2; ++it2;
if (it->second != -id)
continue;
persistent_index.erase(it);
int idx = binsearch_index(hfvec, id);
if (idx >= 0) {
delete hfvec[idx];
hfvec.erase(hfvec.begin()+idx);
}
return true;
}
return false;
}
void World::GetPersistentData(std::vector<PersistentDataItem> *vec, const std::string &key, bool prefix)
{
vec->clear();
if (!BuildPersistentCache())
return;
auto eqrange = persistent_index.equal_range(key);
if (prefix)
{
if (key.empty())
{
eqrange.first = persistent_index.begin();
eqrange.second = persistent_index.end();
}
else
{
std::string bound = key;
if (bound[bound.size()-1] != '/')
bound += "/";
eqrange.first = persistent_index.lower_bound(bound);
bound[bound.size()-1]++;
eqrange.second = persistent_index.lower_bound(bound);
}
}
for (auto it = eqrange.first; it != eqrange.second; ++it)
{
auto hfig = df::historical_figure::find(-it->second);
if (hfig && hfig->name.has_name)
vec->push_back(dataFromHFig(hfig));
}
}
void CZMQAbstractPublishNotifier::Shutdown()
{
assert(psocket);
int count = mapPublishNotifiers.count(address);
// remove this notifier from the list of publishers using this address
typedef std::multimap<std::string, CZMQAbstractPublishNotifier*>::iterator iterator;
std::pair<iterator, iterator> iterpair = mapPublishNotifiers.equal_range(address);
for (iterator it = iterpair.first; it != iterpair.second; ++it)
{
if (it->second==this)
{
mapPublishNotifiers.erase(it);
break;
}
}
if (count == 1)
{
LogPrint("zmq", "Close socket at address %s\n", address);
int linger = 0;
zmq_setsockopt(psocket, ZMQ_LINGER, &linger, sizeof(linger));
zmq_close(psocket);
}
psocket = 0;
}
int countExampleHandlers(T eventName) {
int count = 0;
auto ret = map.equal_range(eventName);
for(auto it = ret.first;it != ret.second;++it)
count++;
return count;
}
virtual google::protobuf::Message* GetAddressMappingOperation(
const pbrpc::Auth& auth,
const pbrpc::UserCredentials& user_credentials,
const google::protobuf::Message& request,
const char* data,
uint32_t data_len,
boost::scoped_array<char>* response_data,
uint32_t* response_data_len) {
const addressMappingGetRequest* rq
= reinterpret_cast<const addressMappingGetRequest*>(&request);
AddressMappingSet* response = new AddressMappingSet();
pair<multimap<string,AddressMapping>::iterator,
multimap<string,AddressMapping>::iterator> ret;
ret = mappings_.equal_range(rq->uuid());
for (multimap<string,AddressMapping>::iterator it = ret.first;
it != ret.second;
++it) {
AddressMapping* mapping = response->add_mappings();
mapping->CopyFrom(it->second);
}
return response;
}
void PatternLink::GenerateConnections( const std::multimap<lem::UCString,const Word_Form*> & points, SynPatternResult * cur_result ) const
{
typedef std::multimap<lem::UCString,const Word_Form*>::const_iterator IT;
IT it_from = points.find( from_marker );
if( it_from==points.end() )
{
lem::MemFormatter mem;
mem.printf( "Can not find node %us.%us to create link head", from_marker.c_str(), from_node.c_str() );
throw lem::E_BaseException( mem.string() );
}
const Word_Form * node0 = it_from->second;
std::pair<IT,IT> pit = points.equal_range( to_marker );
if( pit.first==points.end() && !optional_to_node )
{
lem::MemFormatter mem;
mem.printf( "Can not find node %us to create link tail", to_marker.c_str() );
throw lem::E_BaseException( mem.string() );
}
for( IT it=pit.first; it!=pit.second; ++it )
{
const Solarix::Word_Form * node1 = it->second;
PatternLinkEdge new_edge( node0, link_type, node1 );
cur_result->AddLinkageEdge( new_edge );
}
return;
}
ISoundSource* getSound(const std::string& event)
{
auto iterators = events.equal_range(event);
int dis = std::distance(iterators.first, iterators.second);
std::advance(iterators.first, rand() % dis);
return iterators.first->second;
}
void AMQPAbstractPublishNotifier::Shutdown()
{
LogPrint("amqp", "amqp: Shutdown notifier %s at %s\n", GetType(), GetAddress());
int count = mapPublishNotifiers.count(address);
// remove this notifier from the list of publishers using this address
typedef std::multimap<std::string, AMQPAbstractPublishNotifier*>::iterator iterator;
std::pair<iterator, iterator> iterpair = mapPublishNotifiers.equal_range(address);
for (iterator it = iterpair.first; it != iterpair.second; ++it) {
if (it->second == this) {
mapPublishNotifiers.erase(it);
break;
}
}
// terminate the connection if this is the last publisher using this address
if (count == 1) {
handler_->terminate();
if (thread_.get() != nullptr) {
if (thread_->joinable()) {
thread_->join();
}
}
}
}
bool
MAST::HeatConductionElementBase::
volume_external_residual_sensitivity (bool request_jacobian,
RealVectorX& f,
RealMatrixX& jac,
std::multimap<libMesh::subdomain_id_type, MAST::BoundaryConditionBase*>& bc) {
typedef std::multimap<libMesh::subdomain_id_type, MAST::BoundaryConditionBase*> maptype;
// iterate over the boundary ids given in the provided force map
std::pair<maptype::const_iterator, maptype::const_iterator> it;
// for each boundary id, check if any of the sides on the element
// has the associated boundary
bool calculate_jac = false;
libMesh::subdomain_id_type sid = _elem.subdomain_id();
// find the loads on this boundary and evaluate the f and jac
it =bc.equal_range(sid);
for ( ; it.first != it.second; it.first++) {
// apply all the types of loading
switch (it.first->second->type()) {
case MAST::HEAT_FLUX:
calculate_jac = (calculate_jac ||
surface_flux_residual_sensitivity(request_jacobian,
f, jac,
*it.first->second));
break;
case MAST::CONVECTION_HEAT_FLUX:
calculate_jac = (calculate_jac ||
surface_convection_residual_sensitivity(request_jacobian,
f, jac,
*it.first->second));
break;
case MAST::SURFACE_RADIATION_HEAT_FLUX:
calculate_jac = (calculate_jac ||
surface_radiation_residual_sensitivity(request_jacobian,
f, jac,
*it.first->second));
break;
case MAST::HEAT_SOURCE:
calculate_jac = (calculate_jac ||
volume_heat_source_residual_sensitivity(request_jacobian,
f, jac,
*it.first->second));
break;
default:
// not implemented yet
libmesh_error();
break;
}
}
return (request_jacobian && calculate_jac);
}
void AudioOutputDeviceManager::removeDeviceEventProc(
int _card
, std::multimap< int, const AudioOutputDevice * > & _devices
)
{
auto iterators = _devices.equal_range( _card );
if( iterators.first == _devices.end() ) {
return;
}
DevicesDeleter deleter(
_devices
, iterators
);
std::for_each(
iterators.first
, iterators.second
, [
this
]
(
std::pair< const int, const AudioOutputDevice * > & _pair
)
{
const auto DEVICE = _pair.second;
this->callDisconnectEventHandler(
*DEVICE
);
}
);
}
void updateOperandOrder()
{
/*Steps:
* get all routing nodes.
* for each routing node, get all the outgoing edges
* for each outgoing edge, get the operand order from the source of this
* routing node to the destination of the edge.
* update the operand order map with
*/
for(int i=0;i<routingNodes.size();++i)
{
int node = routingNodes[i];
int src = getRouteSrc(node);
std::pair <std::multimap<int,int>::iterator, std::multimap<int,int>::iterator> ret;
ret = out_edge.equal_range(node);
for (std::multimap<int,int>::iterator it=ret.first; it!=ret.second; ++it)
{
//edge from route to dest
std::pair<int,int> edge1(node,it->second);
//edge from src to dest
std::pair<int,int> edge2(src,it->second);
int operandOrder = operand_order_map[edge2];
operand_order_map.insert(std::pair< std::pair<int,int>,int >(edge1,operandOrder));
}
}
}
void SBTarget::resolveVCProjectDependecies(VCProject* proj, std::multimap<SBTarget*, VCProject*>& vcProjects)
{
// Get the VCProject's platforms
StringSet platforms;
proj->getPlatforms(platforms);
// Iterate over the target's dependencies
for (auto dep : m_dependencies) {
// Find all VCProjects generated from the SBTarget
auto possibleDeps = vcProjects.equal_range(dep);
// Look for the best-matching VCProject
// BIG ASSUMPTION: Projects will have distinct platform sets, so only one match exists
VCProject* match = NULL;
for (auto it = possibleDeps.first; it != possibleDeps.second; ++it) {
VCProject* depVCProject = it->second;
StringSet depPlatforms;
depVCProject->getPlatforms(depPlatforms);
if (isSubset(platforms, depPlatforms)) {
match = depVCProject;
break;
}
}
sbAssert(match);
proj->addProjectReference(match);
}
}
void ApplyHashMap() {
UpdateHashToFunctionMap();
for (auto mf = hashMap.begin(), end = hashMap.end(); mf != end; ++mf) {
auto range = hashToFunction.equal_range(mf->hash);
if (range.first == range.second) {
continue;
}
// Yay, found a function.
for (auto iter = range.first; iter != range.second; ++iter) {
AnalyzedFunction &f = *iter->second;
if (f.hash == mf->hash && f.size == mf->size) {
strncpy(f.name, mf->name, sizeof(mf->name) - 1);
std::string existingLabel = g_symbolMap->GetLabelString(f.start);
char defaultLabel[256];
// If it was renamed, keep it. Only change the name if it's still the default.
if (existingLabel.empty() || existingLabel == DefaultFunctionName(defaultLabel, f.start)) {
g_symbolMap->SetLabelName(mf->name, f.start);
}
}
}
}
}
static MDFNCS *FindSetting(const char *name, bool dref_alias, bool dont_freak_out_on_fail)
{
MDFNCS *ret = NULL;
uint32 name_hash;
//printf("Find: %s\n", name);
name_hash = MakeNameHash(name);
std::pair<std::multimap <uint32, MDFNCS>::iterator, std::multimap <uint32, MDFNCS>::iterator> sit_pair;
std::multimap <uint32, MDFNCS>::iterator sit;
sit_pair = CurrentSettings.equal_range(name_hash);
for(sit = sit_pair.first; sit != sit_pair.second; sit++)
{
//printf("Found: %s\n", sit->second.name);
if(!strcmp(sit->second.name, name))
{
if(dref_alias && sit->second.desc->type == MDFNST_ALIAS)
return(FindSetting(sit->second.value, dref_alias, dont_freak_out_on_fail));
ret = &sit->second;
}
}
if(!ret && !dont_freak_out_on_fail)
{
printf("\n\nINCONCEIVABLE! Setting not found: %s\n\n", name);
exit(1);
}
return(ret);
}
void CommandAddRefs::mark_rel_ids(const std::multimap<osmium::object_id_type, osmium::object_id_type>& rel_in_rel, osmium::object_id_type id) {
auto range = rel_in_rel.equal_range(id);
for (auto it = range.first; it != range.second; ++it) {
if (m_relation_ids.count(it->second) == 0) {
m_relation_ids.insert(it->second);
mark_rel_ids(rel_in_rel, it->second);
}
}
}
void GameDB::deleteGame(std::multimap<Reference<Team>, Reference<Game>>& map, Reference<Team> team, Reference<Game> game) {
auto range = map.equal_range(team);
for (auto i = range.first; i != range.second; ++i) {
if (i->second == game) {
map.erase(i);
return;
}
}
}
TimingConstraints::mutable_io_constraint_iterator TimingConstraints::find_io_constraint(const NodeId node_id, const DomainId domain_id, std::multimap<NodeId,IoConstraint>& io_constraints) {
auto range = io_constraints.equal_range(node_id);
for(auto iter = range.first; iter != range.second; ++iter) {
if(iter->second.domain == domain_id) return iter;
}
//Not found
return io_constraints.end();
}
bool removeExampleHandler (T eventName, Handle handler) {
auto ret = map.equal_range(eventName);
for(auto it = ret.first;it != ret.second;++it) {
if(it->second == handler) {
it = map.erase(it);
return true;
}
}
return false;
}
typename std::multimap<K, V>::iterator
find_pair(std::multimap<K, V>& map, const typename std::multimap<K, V>::value_type& pair)
{
typedef typename std::multimap<K, V>::iterator it;
std::pair<it,it> range = map.equal_range(pair.first);
for (it p = range.first; p != range.second; ++p)
if (p->second == pair.second)
return p;
return map.end();
}
void getAverageNormal(
PackedVertexWithTangents2 & packed,
std::multimap<PackedVertexWithTangents2,unsigned int> & vertexToOutIndex,
PackedVertexWithTangents2 & result)
{
result.position = packed.position;
result.uv = packed.uv;
std::multimap<PackedVertexWithTangents2,unsigned int>::iterator it;
int count = vertexToOutIndex.count(packed);
for(it = vertexToOutIndex.equal_range(packed).first; it != vertexToOutIndex.equal_range(packed).second; ++it)
{
result.normal += it->first.normal;
result.tangent += it->first.tangent;
result.biTangent += it->first.biTangent;
}
result.normal = glm::normalize(result.normal);
result.biTangent = glm::normalize(result.biTangent);
result.tangent = glm::normalize(result.tangent);
}
/// Check if a BuiltinType::Kind matches the MPI datatype.
///
/// \param MultiMap datatype group
/// \param Kind buffer type kind
/// \param MPIDatatype name of the MPI datatype
///
/// \returns true if the pair matches
static bool
isMPITypeMatching(const std::multimap<BuiltinType::Kind, std::string> &MultiMap,
const BuiltinType::Kind Kind,
const std::string &MPIDatatype) {
auto ItPair = MultiMap.equal_range(Kind);
while (ItPair.first != ItPair.second) {
if (ItPair.first->second == MPIDatatype)
return true;
++ItPair.first;
}
return false;
}
// private method for getting a subset of ValidationResult's in a vector
std::vector<sbx::ValidationResult> ValidationResults::_getSubSet(const std::multimap<sbx::productelement_oid, sbx::ValidationResult>& map, sbx::productelement_oid peOid)
{
std::vector<sbx::ValidationResult> v {};
const auto& pairs = map.equal_range(peOid); // std::pair <std::multimap<unsigned short,std::string>::iterator, std::multimap<unsigned short,std::string>::iterator> pairs = _validationResults.equal_range(peOid);
for ( auto it = pairs.first; it != pairs.second; it++ )
{
v.push_back(it->second);
}
return v;
}
std::vector<int> getOperands(int nodeID)
{
std::vector<int> result;
//we cant have more than 3 operands
int temp[3];
int nodeType = getNodeType(nodeID);
if(nodeType != st_data && nodeType != ld_data)
{
std::pair <std::multimap<int,int>::iterator, std::multimap<int,int>::iterator> ret;
ret = in_edge.equal_range(nodeID);
int ctr = 0;
for (std::multimap<int,int>::iterator it=ret.first; it!=ret.second; ++it)
{
std::pair<int,int> edge(it->second,nodeID);
if(operand_order_map.count(edge) > 0)
{
temp[operand_order_map[edge]] = it->second;
ctr++;
}
}
for(int j =0;j<ctr;j++)
result.push_back(temp[j]);
}
else
{
std::pair <std::multimap<int,int>::iterator, std::multimap<int,int>::iterator> ret;
ret = in_edge.equal_range(nodeID);
for (std::multimap<int,int>::iterator it=ret.first; it!=ret.second; ++it)
{
result.push_back(it->second);
}
}
return result;
}
bool
MAST::StructuralElementBase::volume_external_force(bool request_jacobian,
DenseRealVector &f,
DenseRealMatrix &jac,
std::multimap<libMesh::subdomain_id_type, MAST::BoundaryCondition*>& bc) {
// iterate over the boundary ids given in the provided force map
std::pair<std::multimap<libMesh::subdomain_id_type, MAST::BoundaryCondition*>::const_iterator,
std::multimap<libMesh::subdomain_id_type, MAST::BoundaryCondition*>::const_iterator> it;
// for each boundary id, check if any of the sides on the element
// has the associated boundary
bool calculate_jac = false;
libMesh::subdomain_id_type sid = _elem.subdomain_id();
// find the loads on this boundary and evaluate the f and jac
it =bc.equal_range(sid);
for ( ; it.first != it.second; it.first++) {
// apply all the types of loading
switch (it.first->second->type()) {
case MAST::SURFACE_PRESSURE:
calculate_jac = (calculate_jac ||
surface_pressure_force(request_jacobian,
f, jac,
*it.first->second));
break;
case MAST::TEMPERATURE:
calculate_jac = (calculate_jac ||
thermal_force(request_jacobian,
f, jac,
*it.first->second));
break;
case MAST::SMALL_DISTURBANCE_MOTION:
calculate_jac = (calculate_jac ||
small_disturbance_surface_pressure_force<ValType>(request_jacobian,
f, jac,
*it.first->second));
break;
default:
// not implemented yet
libmesh_error();
break;
}
}
return (request_jacobian && calculate_jac);
}
/* A chain can extend across multiple atom blocks. Must segment the chain to fit in an atom
* block by identifying the actual atom that forms the root of the new chain.
* Returns AtomBlockId::INVALID() if this block_index doesn't match up with any chain
*
* Assumes that the root of a chain is the primitive that starts the chain or is driven from outside the logic block
* block_index: index of current atom
* list_of_pack_pattern: ptr to current chain pattern
*/
static AtomBlockId find_new_root_atom_for_chain(const AtomBlockId blk_id, const t_pack_patterns *list_of_pack_pattern,
const std::multimap<AtomBlockId,t_pack_molecule*>& atom_molecules) {
AtomBlockId new_root_blk_id;
t_pb_graph_pin *root_ipin;
t_pb_graph_node *root_pb_graph_node;
t_model_ports *model_port;
VTR_ASSERT(list_of_pack_pattern->is_chain == true);
root_ipin = list_of_pack_pattern->chain_root_pin;
root_pb_graph_node = root_ipin->parent_node;
if(primitive_type_feasible(blk_id, root_pb_graph_node->pb_type) == false) {
return AtomBlockId::INVALID();
}
/* Assign driver furthest up the chain that matches the root node and is unassigned to a molecule as the root */
model_port = root_ipin->port->model_port;
AtomPortId port_id = g_atom_nl.find_port(blk_id, model_port);
if(!port_id) {
//There is no port with the chain connection on this block, it must be the furthest
//up the chain, so return it as root
return blk_id;
}
AtomNetId driving_net_id = g_atom_nl.port_net(port_id, root_ipin->pin_number);
if(!driving_net_id) {
//There is no net associated with the chain connection on this block, it must be the furthest
//up the chain, so return it as root
return blk_id;
}
auto driver_pin_id = g_atom_nl.net_driver(driving_net_id);
AtomBlockId driver_blk_id = g_atom_nl.pin_block(driver_pin_id);
auto rng = atom_molecules.equal_range(driver_blk_id);
bool rng_empty = (rng.first == rng.second);
if(!rng_empty) {
/* Driver is used/invalid, so current block is the furthest up the chain, return it */
return blk_id;
}
new_root_blk_id = find_new_root_atom_for_chain(driver_blk_id, list_of_pack_pattern, atom_molecules);
if(!new_root_blk_id) {
return blk_id;
} else {
return new_root_blk_id;
}
}
ExampleEventDispatcherTpl() {
ExampleEventEmitter<T, Rest...>::onExample([&](T eventName, Rest... fargs) {
auto ret = map.equal_range(eventName);
for(auto it = ret.first;it != ret.second;) {
(it->second)(fargs...);
if(eraseLast) {
it = map.erase(it);
eraseLast = false;
}
else {
++it;
}
}
});
}
int getMoveForPosition(ChessBoard * board) {
std::pair<std::multimap<HASHKEY, Coord>::iterator,
std::multimap<HASHKEY, Coord>::iterator> positionStartEnd;
cerr << board_to_string(board) << endl;
positionStartEnd = openingBook.equal_range(board->zobristHashKey);
std::vector<Coord> coords;
int totalWeight = 0;
for(std::multimap<HASHKEY, Coord>::iterator itPosition = positionStartEnd.first;
itPosition != positionStartEnd.second;
++itPosition) {
coords.push_back(itPosition->second);
totalWeight += itPosition->second.weight;
}
// select a move given the weights
if (coords.empty())
return -1;
Coord theCoord;
if (coords.size() == 1)
theCoord = coords.front();
else {
int whichOne = rand() % totalWeight;
int weightSoFar = 0;
for(std::vector<Coord>::iterator itCoords = coords.begin(); itCoords != coords.end(); ++itCoords) {
if (itCoords->weight + weightSoFar > whichOne) {
theCoord = *itCoords;
break;
}
weightSoFar += itCoords->weight;
}
// convert it to a move
}
if (!MoveIsLegal(board, theCoord.move)) {
cerr << "move from opening book: " << MoveToString(theCoord.move) << " is not legal!" << endl;
return -1;
}
LOG4CPLUS_DEBUG(logger, "book move " << MoveToString(theCoord.move));
return theCoord.move;
}
/**
* @param name A string containing the algorithm name
* @param version The version to remove. -1 indicates all instances
* @param typedLoaders A map of names to version numbers
**/
void FileLoaderRegistryImpl::removeAlgorithm(
const std::string &name, const int version,
std::multimap<std::string, int> &typedLoaders) {
if (version == -1) // remove all
{
typedLoaders.erase(name);
} else // find the right version
{
auto range = typedLoaders.equal_range(name);
for (auto ritr = range.first; ritr != range.second; ++ritr) {
if (ritr->second == version) {
typedLoaders.erase(ritr);
break;
}
}
}
}