void WeakMapData::DeadKeyCleaner::finalizeUnconditionally()
{
if (m_liveKeyCount > m_target->m_map.size() / 2) {
RELEASE_ASSERT(m_liveKeyCount <= m_target->m_map.size());
int deadCount = m_target->m_map.size() - m_liveKeyCount;
if (!deadCount)
return;
Vector<JSObject*> deadEntries;
deadEntries.reserveCapacity(deadCount);
for (auto it = m_target->m_map.begin(), end = m_target->m_map.end(); it != end; ++it) {
if (Heap::isMarked(it->key))
continue;
deadEntries.uncheckedAppend(it->key);
}
for (size_t i = 0; i < deadEntries.size(); i++)
m_target->m_map.remove(deadEntries[i]);
} else {
MapType newMap;
for (auto it = m_target->m_map.begin(), end = m_target->m_map.end(); it != end; ++it) {
if (!Heap::isMarked(it->key))
continue;
newMap.add(it->key, it->value);
}
m_target->m_map.swap(newMap);
}
}
std::string LLEventDetail::listenerNameForCoroImpl(const void* self_id)
{
// First, if this coroutine was launched by LLCoros::launch(), find that name.
std::string name(LLCoros::instance().getNameByID(self_id));
if (! name.empty())
{
return name;
}
// Apparently this coroutine wasn't launched by LLCoros::launch(). Check
// whether we have a memo for this self_id.
typedef std::map<const void*, std::string> MapType;
static MapType memo;
MapType::const_iterator found = memo.find(self_id);
if (found != memo.end())
{
// this coroutine instance has called us before, reuse same name
return found->second;
}
// this is the first time we've been called for this coroutine instance
name = LLEventPump::inventName("coro");
memo[self_id] = name;
LL_INFOS("LLEventCoro") << "listenerNameForCoroImpl(" << self_id << "): inventing coro name '"
<< name << "'" << LL_ENDL;
return name;
}
int main(/*int argc, char *argv[]*/) {
ios::sync_with_stdio(false);
int n, m;
MapType data;
vector<unsigned> paths;
cin >> n >> m;
data.resize(n);
for (int i = 0; i < n; i++) {
data[i].resize(i + 1);
for (int j = 0; j <= i; j++) { cin >> data[i][j]; } // for
} // for
unsigned path;
unsigned end = 0U;
for (unsigned i = 0; i < n - 1; i++) { end = (end << 1) + 1U; } // for
for (path = 0U; path <= end; path++) { paths.push_back(path); } // for
for (auto p : paths) {
if (ComputePath(p, n, data, m)) {
PrintPath(p, n, data);
cout << endl;
}
} // foreach in paths
return 0;
} // function main
// Find the given object ID, or return NULL if not found.
const X* search(const std::string &id) const
{
std::string id2 = toLower (id);
if(list.find(id2) == list.end())
return NULL;
return &list.find(id2)->second;
}
int Location::readFromMessage(const MapType & msg)
{
try {
MapType::const_iterator I = msg.find("pos");
MapType::const_iterator Iend = msg.end();
if (I != Iend) {
const Element & pos = I->second;
if (pos.isList() && pos.List().size() == 3) {
m_pos.fromAtlas(pos);
} else {
log(ERROR, "Malformed POS data");
}
}
I = msg.find("orientation");
if (I != Iend) {
const Element & orientation = I->second;
if (orientation.isList() && orientation.List().size() == 4) {
m_orientation.fromAtlas(orientation);
} else {
log(ERROR, "Malformed ORIENTATION data");
}
}
}
catch (Atlas::Message::WrongTypeException&) {
log(ERROR, "Location::readFromMessage: Bad location data");
return -1;
}
return 0;
}
typename MapType::const_iterator findInTable(const MapType& map, const std::wstring& name, const SourcePos& pos, const ErrorCode notFoundError, const ErrorCode misspelledError)
{
typename MapType::const_iterator it(map.find(name));
if (it == map.end())
{
const unsigned maxDist(3);
std::wstring bestName;
unsigned bestDist(std::numeric_limits<unsigned>::max());
for (typename MapType::const_iterator jt(map.begin()); jt != map.end(); ++jt)
{
const std::wstring thatName(jt->first);
const unsigned d(editDistance<std::wstring>(name, thatName, maxDist));
if (d < bestDist && d < maxDist)
{
bestDist = d;
bestName = thatName;
}
}
if (bestDist < maxDist)
throw TranslatableError(pos, misspelledError).arg(name).arg(bestName);
else
throw TranslatableError(pos, notFoundError).arg(name);
}
return it;
}
void adjustRetentionTimes_(MapType& map, const String& trafo_out,
bool first_file)
{
map.updateRanges();
TransformationDescription trafo;
if (first_file) // no transformation necessary
{
rt_offset_ = map.getMax()[0] + rt_gap_;
trafo.fitModel("identity");
}
else // subsequent file -> apply transformation
{
TransformationDescription::DataPoints points(2);
double rt_min = map.getMin()[0], rt_max = map.getMax()[0];
points[0] = make_pair(rt_min, rt_offset_);
rt_offset_ += rt_max - rt_min;
points[1] = make_pair(rt_max, rt_offset_);
trafo.setDataPoints(points);
trafo.fitModel("linear");
MapAlignmentTransformer::transformRetentionTimes(map, trafo, true);
rt_offset_ += rt_gap_;
}
if (!trafo_out.empty())
{
TransformationXMLFile().store(trafo_out, trafo);
}
}
int main() {
while (true) {
unsigned size;
vector<string> mapData;
size = RequireInput<unsigned>(">");
if (size == SIGNAL_EXIT) { break; }
cin.ignore();
for (unsigned i = 0; i != size; i++) { mapData.push_back(RequireInput<string>(">")); } // for
MapType map;
for (unsigned x = 0; x != size; x++) {
map.push_back(LineType());
for (unsigned y = 0; y != size; y++) {
switch (mapData[x][y]) {
case ElementSafe: map[x].push_back(ElementType::Safe); break;
case ElementWall: map[x].push_back(ElementType::Wall); break;
} // switch to mapData[x][y]
} // for
} // for
Output(GetMaxNumberOfCastles(map, size));
// PrintMap(map);
}
return 0;
} // function main
void printMap(MapType const& m)
{
int originX = 0;
int originY = 0;
int dx = 0;
int dy = 0;
m.boundingBox(originX, originY, dx, dy);
MapType::TileMap const& tiles = m.tileMap();
std::vector<char> bigMap(dx * dy, ' ');
MapType::TileMap::const_iterator first, last = tiles.end();
for (first = tiles.begin(); first != last; ++first) {
TileType& tile = *first->second;
for (unsigned int x = 0; x < TileType::TileSize; ++x) {
for (unsigned int y = 0; y < TileType::TileSize; ++y) {
int xIndex = x + tile.originX() - originX;
int yIndex = y + tile.originY() - originY;
bigMap[xIndex + dx * yIndex] = tile.cell(x, y).a;
}
}
}
int index = 0;
for (int y = originY; y < originY + dy; ++y) {
for (int x = originX; x < originX + dx; ++x) {
cout << bigMap[index] << flush;
++index;
}
cout << endl;
}
}
// Routine to compute optimal tic-tac-toe move.
int TicTacToe::chooseMove( Side s, int & bestRow, int & bestColumn,
int alpha, int beta, int depth )
{
Side opp; // The other side
int reply; // Value of opponent's reply
int dc; // Placeholder
int simpleEval; // Result of an immediate evaluation
Position thisPosition = board;
int value;
static const int TABLE_DEPTH = 5; // Max depth placed in Trans. table
if( ( simpleEval = positionValue( ) ) != UNCLEAR )
return simpleEval;
if( depth == 0 )
transpositions = MapType( ); // makeEmpty
else if( depth >= 3 && depth <= TABLE_DEPTH )
{
MapItr itr = transpositions.find( thisPosition );
if( itr != transpositions.end( ) )
return (*itr).second;
}
if( s == COMPUTER )
{
opp = HUMAN; value = alpha;
}
else
{
opp = COMPUTER; value = beta;
}
for( int row = 0; row < 3; row++ )
for( int column = 0; column < 3; column++ )
if( squareIsEmpty( row, column ) )
{
place( row, column, s );
reply = chooseMove( opp, dc, dc, alpha, beta, depth + 1 );
place( row, column, EMPTY );
if( s == COMPUTER && reply > value ||
s == HUMAN && reply < value )
{
if( s == COMPUTER )
alpha = value = reply;
else
beta = value = reply;
bestRow = row; bestColumn = column;
if( alpha >= beta )
goto Done; // Refutation
}
}
Done:
if( depth <= TABLE_DEPTH )
transpositions[ thisPosition ] = value;
return value;
}
static inline typename MapType::mapped_type GetItem(const MapType& map, const typename MapType::key_type& key)
{
typename MapType::const_iterator mapIt = map.find(key);
if (mapIt != map.end())
return mapIt->second;
else
return typename MapType::mapped_type();
}
void CableCompany::deleteCustomer(const string& name)
{
auto it = mCustomers.find(name);
if(it != mCustomers.end())
{
mCustomers.erase(name);
}
}
void CableCompany::removeChannel(const string& name, int channel)
{
auto it = mPackages.find(name);
if(it != mPackages.end())
{
it->second.reset(channel);
}
}
static typename MapType::MappedType valueForKey(const MapType& map, const typename MapType::KeyType& key)
{
typename MapType::const_iterator it = map.find(key);
if (it != map.end())
return it->second;
return defaultValueForKey<typename MapType::MappedType>(key);
}
MapType CyPy_Element::dictAsElement(const Py::Dict& dict)
{
MapType map;
for (auto key : dict.keys()) {
map.emplace(key.str(), asElement(dict.getItem(key)));
}
return map;
}
const_iterator find_checked(const K& k) const
{
const_iterator ret = map_.find(k);
if (ret == map_.end())
{
gu_throw_fatal << "element " << k << " not found";
}
return ret;
}
void Admintest::test_addToMessage()
{
MapType data;
m_account->addToMessage(data);
ASSERT_NOT_EQUAL(data.find("character_types"), data.end());
ASSERT_EQUAL(data["character_types"], ListType());
}
void Encoder::streamMessageElement(const MapType& obj)
{
m_b.streamMessage();
MapType::const_iterator I;
for (I = obj.begin(); I != obj.end(); I++) {
mapElementItem((*I).first, (*I).second);
}
m_b.mapEnd();
}
void Encoder::listElementMapItem(const MapType& obj)
{
m_b.listMapItem();
MapType::const_iterator I;
for (I = obj.begin(); I != obj.end(); I++) {
mapElementItem(I->first, I->second);
}
m_b.mapEnd();
}
void MapAlignmentAlgorithmIdentification::getRetentionTimes_(
MapType & features, SeqToList & rt_data)
{
bool use_feature_rt = param_.getValue("use_feature_rt").toBool();
for (typename MapType::Iterator feat_it = features.begin();
feat_it != features.end(); ++feat_it)
{
if (use_feature_rt)
{
// find the peptide ID closest in RT to the feature centroid:
String sequence;
DoubleReal rt_distance = numeric_limits<DoubleReal>::max();
bool any_good_hit = false;
for (vector<PeptideIdentification>::iterator pep_it =
feat_it->getPeptideIdentifications().begin(); pep_it !=
feat_it->getPeptideIdentifications().end(); ++pep_it)
{
if (hasGoodHit_(*pep_it))
{
any_good_hit = true;
DoubleReal current_distance =
abs(double(pep_it->getMetaValue("RT")) - feat_it->getRT());
if (current_distance < rt_distance)
{
sequence = pep_it->getHits()[0].getSequence().toString();
rt_distance = current_distance;
}
}
}
if (any_good_hit)
rt_data[sequence] << feat_it->getRT();
}
else
{
getRetentionTimes_(feat_it->getPeptideIdentifications(), rt_data);
}
}
if (!use_feature_rt && param_.getValue("use_unassigned_peptides").toBool())
{
getRetentionTimes_(features.getUnassignedPeptideIdentifications(),
rt_data);
}
// remove duplicates (can occur if a peptide ID was assigned to several
// features due to overlap or annotation tolerance):
for (SeqToList::iterator rt_it = rt_data.begin();
rt_it != rt_data.end(); ++rt_it)
{
DoubleList & rt_values = rt_it->second;
sort(rt_values.begin(), rt_values.end());
DoubleList::iterator it = unique(rt_values.begin(), rt_values.end());
rt_values.resize(it - rt_values.begin());
}
}
// Find the given object ID, or return NULL if not found.
const X* search (int id) const
{
typename MapType::const_iterator iter = list.find (id);
if (iter == list.end())
return NULL;
return &iter->second;
}
void Encoder::mapElementMapItem(const std::string& name, const MapType& obj)
{
m_b.mapMapItem(name);
MapType::const_iterator I;
for (I = obj.begin(); I != obj.end(); I++) {
mapElementItem((*I).first, (*I).second);
}
m_b.mapEnd();
}
// Find the given object ID, or return NULL if not found.
const X* search(const std::string &id) const
{
std::string id2 = toLower (id);
typename MapType::const_iterator iter = list.find (id2);
if (iter == list.end())
return NULL;
return &iter->second;
}
/// \brief Read attributes from an Atlas element
///
/// @param ent The Atlas map element containing the attribute values
void LocatedEntity::merge(const MapType & ent)
{
const std::set<std::string> & imm = immutables();
MapType::const_iterator Iend = ent.end();
for (MapType::const_iterator I = ent.begin(); I != Iend; ++I) {
const std::string & key = I->first;
if (imm.find(key) != imm.end()) continue;
setAttr(key, I->second);
}
}
void ConfigFile::writeGroup( std::ofstream& out, const MapType& map ) const
{
MapType::const_iterator it = map.begin();
const MapType::const_iterator end = map.end();
while( it != end ){
out << it->first << " = " << it->second << std::endl;
it++;
}
}
Appearance::MapType& Appearance::GetFonts(void)
{
static MapType s_Fonts;
if (s_Fonts.empty())
{
s_Fonts["font.listing"] = Information("Listing", "");
}
return s_Fonts;
}
inline AtomType operator()( MapType const & arg ) const
{
AtomType obj;
typedef typename MapType::const_iterator IT;
IT it = arg.begin();
for( ; arg.end() != it; ++it ) {
obj.push( nativeToAtom( *it ) );
}
return obj;
}
void LoadDefaultsDecoder::messageArrived(const MapType& o)
{
MessageElementMap::const_iterator I = o.find("id");
if (I == o.end()) {
return;
}
std::string id(I->second.asString());
m_objects[id] = o;
}
sensor_msgs::JointState getJointStatesMessage()
{
sensor_msgs::JointState msg;
msg.header.stamp = ros::Time::now();
msg.name.resize(jointpositions.size());
msg.position.resize(jointpositions.size());
msg.velocity.resize(jointvelocities.size());
msg.effort.resize(jointvelocities.size());
MapType::const_iterator end = jointpositions.end();
MapType::iterator iter = jointvelocities.begin();
int count = 0;
for (MapType::const_iterator it = jointpositions.begin(); it != end; ++it)
{
msg.name[count] = it->first;
msg.position[count] = it->second;
iter = jointvelocities.find(it->first);
if (iter != jointvelocities.end() )
msg.velocity[count] = iter->second;
msg.effort[count] = 0;
count++;
}
return msg;
}
void AtlasStreamClient::output(const Root & ent) const
{
MapType entmap = ent->asMessage();
MapType::const_iterator Iend = entmap.end();
for (MapType::const_iterator I = entmap.begin(); I != Iend; ++I) {
const Element & item = I->second;
std::cout << std::string(spacing(), ' ') << I->first << ": ";
output(item, 1);
std::cout << std::endl;
}
}