static bool SlowRekey(IntMap* m) {
IntMap tmp;
for (auto iter = m->iter(); !iter.done(); iter.next()) {
if (NewKeyFunction::shouldBeRemoved(iter.get().key())) {
continue;
}
uint32_t hi = NewKeyFunction::rekey(iter.get().key());
if (tmp.has(hi)) {
return false;
}
if (!tmp.putNew(hi, iter.get().value())) {
return false;
}
}
m->clear();
for (auto iter = tmp.iter(); !iter.done(); iter.next()) {
if (!m->putNew(iter.get().key(), iter.get().value())) {
return false;
}
}
return true;
}
TEST(ThreadLocalStorage, ThreadLocalPtrCount)
{
// Create multiple objects in this thread
// Only 1 ID should be added to the list
TLSObject* o1 = new TLSObject();
TLSObject* o2 = new TLSObject();
TLSObject* o3 = new TLSObject();
// Spawn a thread to create a new TLS int
// This should add another ID to the list
Thread thread1(JustAThread);
thread1.join();
// Spawn another thread
// This should add another ID to the list
Thread thread2(JustAThread);
thread2.join();
// Now, only 3 IDs should be added to the list
typedef map<string, int> IntMap;
IntMap map = ObjectManager::sIntMap;
for(auto&& t : map)
{
std::cout << t.first << " : " << t.second << "\n";
}
ASSERT_EQ(3, map.size());
}
void TeletextBrowser::ChannelSwitched(int ChannelNumber) {
cChannel *chan=Channels.GetByNumber(ChannelNumber);
if (!chan)
return;
tChannelID chid=chan->GetChannelID();
if (chid==channel || chid==tChannelID::InvalidID)
return;
channel=chid;
//store page number of current channel
IntMap::iterator it;
channelPageMap[currentChannelNumber] = currentPage;
currentChannelNumber=ChannelNumber;
currentPage=0x100;
currentSubPage=0;
//see if last page number on this channel was stored
it=channelPageMap.find(ChannelNumber);
if (it != channelPageMap.end()) { //found
currentPage=(*it).second;
}
//on the one hand this must work in background mode, when the plugin is not active.
//on the other hand, if active, the page should be shown.
//so this self-Pointer.
if (self) {
self->ShowPage();
}
}
// L speedboosters
// t time to boost
// N stars
// C repeat
LL solve(int L, LL t, int N, int C, IntVec &v) {
LL result = 0;
IntMap cnt;
int i;
for (i = 0; i < C; ++i) {
cnt[v[i]] += (N / C) + ((N % C) >= (i+1));
}
for (i = 0; result < t && i < N; ++i) {
int d = v[i % C];
result += d;
cnt[d] -= 1;
if (result > t) {
d = (int)(result - t);
cnt[d] += 1;
result = t;
}
}
IntMap::reverse_iterator it;
for (it = cnt.rbegin(); it != cnt.rend(); ++it) {
int can = min(L, it->second);
result += it->first * can / 2;
it->second -= can;
L -= can;
}
for (it = cnt.rbegin(); it != cnt.rend(); ++it) {
result += it->first * it->second;
}
return result;
}
int find(int a, int b, int jLen, int bLen) {
int result = 0;
IntMap Brus;
int j;
int jm = b - jLen + 1;
for (j = a; j <= jm; ++j) {
int BrusScore = 9999;
int k;
int km = j + jLen - bLen;
for (k = j; k <= km; ++k) {
IntMap::const_iterator bf = Brus.find(k);
if (bf == Brus.end()) {
// not calculated yet
int bs = 0;
int l;
int lm = k + bLen - 1;
for (l = k; l <= lm; ++l) {
bs += isLucky(l);
}
Brus[k] = bs;
BrusScore = min(BrusScore, bs);
} else {
BrusScore = min(BrusScore, bf->second);
}
}
result = max(result, BrusScore);
}
return result;
}
int rec(int mask) {
if (m.find(mask) != m.end()) {
return m[mask];
}
int &res = m[mask];
res = 0;
int i, prev, next;
prev = 0;
for (i = 1; i < (len-1); ++i) {
int b = (1<<i);
if (mask & b) {
int a = mask ^ b;
for (next = i+1; ; ++next) {
if (mask & (1<<next)) {
break;
}
}
res = max(res, x[prev]*x[next]+rec(a));
prev = i;
}
}
return res;
}
inline void AudioDataOutput::convertAndEmit(const QVector<qint16> &leftBuffer, const QVector<qint16> &rightBuffer)
{
//TODO: Floats
IntMap map;
map.insert(Phonon::AudioDataOutput::LeftChannel, leftBuffer);
map.insert(Phonon::AudioDataOutput::RightChannel, rightBuffer);
emit dataReady(map);
}
int getRating(const std::string &game)
{
int rate = -1;
if(ratings.find(game) != ratings.end())
rate = ratings[game];
if(rate < -1 || rate > 5) rate = -1;
return rate;
}
static void addInt(const string& name, int i)
{
ScopedLock<Mutex> l(mutex);
IntMap::iterator it = sIntMap.find(name);
if(it == sIntMap.end())
{
sIntMap.insert(IntMap::value_type(name, i));
}
}
IntMap multiplyMap(const IntMap& m, int f)
{
IntMap ret;
for (IntMap::const_iterator it = m.begin(); it != m.end(); ++it)
{
ret[it->first] = it->second * f;
}
return ret;
}
void test_erase_map() {
IntMap map;
for (int i = 0; i < 100; ++i) {
map[i] = i + 10000;
}
std::cout << "map_size: " << map.size() << std::endl;
for (IntMap::iterator it = map.begin(); it != map.end(); ++it) {
std::cout << it->first << ": " << it->second << std::endl;
if (it->first % 2 == 0) {
map.erase(it->first);
}
}
std::cout << "clean finish" << std::endl;
std::cout << map.size() << std::endl;
for (IntMap::iterator it = map.begin(); it != map.end(); ++it) {
std::cout << it->first << ": " << it->second << std::endl;
}
std::cout << map.size() << std::endl;
}
bool utl::renumber (int& num, int& runner, IntMap& old2new)
{
IntMap::iterator it = old2new.find(num);
if (it == old2new.end())
it = old2new.insert(std::make_pair(num,++runner)).first;
if (num == it->second) return false;
num = it->second;
return true;
}
void write()
{
Json::Value v;
for(IntMap::iterator it = ratings.begin();
it != ratings.end(); it++)
{
v[it->first] = it->second;
}
std::string filename = get.getPath("ratings.json");
writeJson(filename, v);
}
bool utl::renumber (int& num, const IntMap& old2new, bool msg)
{
IntMap::const_iterator it = old2new.find(num);
if (it == old2new.end())
{
if (msg)
std::cerr <<" *** utl::renumber: Old value "<< num
<<" does not exist in old2new mapping"<< std::endl;
return false;
}
num = it->second;
return true;
}
vector<int> topKFrequent(vector<int>& nums, int k) {
typedef std::map<int, int> IntMap;
typedef IntMap::iterator IMIter;
IntMap countMap;
for(size_t i = 0, sz = nums.size(); i < sz; ++i)
{
if(countMap.find(nums[i]) != countMap.end())
{
countMap[nums[i]] = countMap[nums[i]] + 1;
}
else
{
countMap[nums[i]] = 1;
}
}
typedef std::map<int, std::vector<int>* > OrderMap;
typedef OrderMap::iterator OMIter;
typedef OrderMap::reverse_iterator OMRter;
OrderMap orderMap;
for(IMIter itr = countMap.begin(), end = countMap.end(); itr != end; ++itr)
{
if(orderMap.find(itr->second) != orderMap.end())
{
orderMap[itr->second]->push_back(itr->first);
}
else
{
std::vector<int>* vec = new std::vector<int>();
vec->push_back(itr->first);
orderMap[itr->second] = vec;
}
}
std::vector<int> result;
int count = 0;
for(OMRter itr = orderMap.rbegin(), end = orderMap.rend(); itr != end && count != k; ++itr)
{
std::vector<int>* vec = itr->second;
for(size_t i = 0, sz = vec->size(); i < sz && count != k; ++i, ++count)
{
result.push_back((*vec)[i]);
}
}
return result;
}
/// Read comma separated list of integers representing a map. There must be an
/// an even number of integers - even numbers are keys, odd numbers are values.
/// For example the string "1,5,8,1" specifies a map where 1 -> 5 and 8 -> 1.
static IntMap read_map(std::istream &in)
{
IntMap map;
std::string contents;
while (1) {
auto c = in.get();
if (!in.good())
break;
if (std::isspace(c))
continue;
contents.push_back(c);
}
// Parse into a list of integers.
std::vector<long> values;
const char *p = contents.c_str();
while (*p != '\0') {
char *endp;
auto value = std::strtol(p, &endp, 10);
if (endp == p) {
std::cerr << "error: unexpected format\n";
std::exit(1);
}
values.push_back(value);
p = endp;
if (*p == ',') {
++p;
} else if (*p != '\0') {
std::cerr << "error: unexpected format\n";
std::exit(1);
}
}
if ((values.size() % 2) != 0) {
std::cerr << "error: odd number of values\n";
std::exit(1);
}
// Add values to map.
for (unsigned i = 0, e = values.size(); i != e; i += 2) {
map.insert(std::make_pair(values[i], values[i + 1]));
}
return map;
}
static bool
SlowRekey(IntMap *m) {
IntMap tmp;
tmp.init();
for (IntMap::Range r = m->all(); !r.empty(); r.popFront()) {
if (NewKeyFunction::shouldBeRemoved(r.front().key))
continue;
uint32_t hi = NewKeyFunction::rekey(r.front().key);
if (tmp.has(hi))
return false;
tmp.putNew(hi, r.front().value);
}
m->clear();
for (IntMap::Range r = tmp.all(); !r.empty(); r.popFront()) {
m->putNew(r.front().key, r.front().value);
}
return true;
}
void HashMapTest::testInsert()
{
const int N = 1000;
typedef HashMap<int, int> IntMap;
IntMap hm;
assert (hm.empty());
for (int i = 0; i < N; ++i)
{
std::pair<IntMap::Iterator, bool> res = hm.insert(IntMap::ValueType(i, i*2));
assert (res.first->first == i);
assert (res.first->second == i*2);
assert (res.second);
IntMap::Iterator it = hm.find(i);
assert (it != hm.end());
assert (it->first == i);
assert (it->second == i*2);
assert (hm.size() == i + 1);
}
assert (!hm.empty());
for (int i = 0; i < N; ++i)
{
IntMap::Iterator it = hm.find(i);
assert (it != hm.end());
assert (it->first == i);
assert (it->second == i*2);
}
for (int i = 0; i < N; ++i)
{
std::pair<IntMap::Iterator, bool> res = hm.insert(IntMap::ValueType(i, 0));
assert (res.first->first == i);
assert (res.first->second == i*2);
assert (!res.second);
}
}
void HashMapTest::testConstIterator()
{
const int N = 1000;
typedef HashMap<int, int> IntMap;
IntMap hm;
for (int i = 0; i < N; ++i)
{
hm.insert(IntMap::ValueType(i, i*2));
}
std::map<int, int> values;
IntMap::ConstIterator it = hm.begin();
while (it != hm.end())
{
assert (values.find(it->first) == values.end());
values[it->first] = it->second;
++it;
}
assert (values.size() == N);
}
// Add entries to a HashMap until either we get an OOM, or the table has been
// resized a few times.
static bool GrowUntilResize() {
IntMap m;
// Add entries until we've resized the table four times.
size_t lastCapacity = m.capacity();
size_t resizes = 0;
uint32_t key = 0;
while (resizes < 4) {
auto p = m.lookupForAdd(key);
if (!p && !m.add(p, key, 0)) {
return false; // OOM'd in lookupForAdd() or add()
}
size_t capacity = m.capacity();
if (capacity != lastCapacity) {
resizes++;
lastCapacity = capacity;
}
key++;
}
return true;
}
static void
reduce_using_and(IntMap &map, std::vector<std::unique_ptr<Step>> &steps)
{
IntPairs map_entries(begin(map), end(map));
IntMap tmp;
tmp.reserve(map_entries.size());
std::bitset<32> mask;
for (int bit = 31; bit >= 0; bit--) {
auto candidate_mask = mask;
candidate_mask.set(bit);
auto bitmask = ~static_cast<uint32_t>(candidate_mask.to_ulong());
auto hash = [=](uint32_t x) {
return x & bitmask;
};
if (apply_hash_to_map(map_entries, hash, tmp) &&
tmp.size() < map_entries.size()) {
std::swap(map, tmp);
mask = candidate_mask;
}
}
if (mask.any()) {
steps.push_back(std::unique_ptr<Step>(new AndNotStep(mask.to_ulong())));
}
}
void HashMapTest::testIndex()
{
typedef HashMap<int, int> IntMap;
IntMap hm;
hm[1] = 2;
hm[2] = 4;
hm[3] = 6;
assert (hm.size() == 3);
assert (hm[1] == 2);
assert (hm[2] == 4);
assert (hm[3] == 6);
try
{
const IntMap& im = hm;
int x = im[4];
fail("no such key - must throw");
}
catch (Poco::NotFoundException&)
{
}
}
void HashMapTest::testIterator()
{
const int N = 1000;
typedef HashMap<int, int> IntMap;
IntMap hm;
for (int i = 0; i < N; ++i)
{
hm.insert(IntMap::ValueType(i, i*2));
}
std::map<int, int> values;
IntMap::Iterator it; // do not initialize here to test proper behavior of uninitialized iterators
it = hm.begin();
while (it != hm.end())
{
assert (values.find(it->first) == values.end());
values[it->first] = it->second;
++it;
}
assert (values.size() == N);
}
// Add entries to a HashMap using lookupWithDefault until either we get an OOM,
// or the table has been resized a few times.
static bool
LookupWithDefaultUntilResize() {
IntMap m;
if (!m.init())
return false;
// Add entries until we've resized the table four times.
size_t lastCapacity = m.capacity();
size_t resizes = 0;
uint32_t key = 0;
while (resizes < 4) {
if (!m.lookupWithDefault(key++, 0))
return false;
size_t capacity = m.capacity();
if (capacity != lastCapacity) {
resizes++;
lastCapacity = capacity;
}
}
return true;
}
bool Init()
{
int nRandom = 0;
for (int i = 0; i < g_nMax; ++i)
{
nRandom = i;
g_nSummary += nRandom;
g_dInts.push_back(nRandom);
g_hmInts.insert(std::make_pair(nRandom, nRandom));
g_hsInts.insert(nRandom);
g_lInts.push_back(nRandom);
g_mInts.insert(std::make_pair(nRandom, nRandom));
g_mmInts.insert(std::make_pair(nRandom, nRandom));
g_msInts.insert(nRandom);
g_sInts.insert(nRandom);
g_vInts.push_back(nRandom);
}
return true;
}
static bool MapsAreEqual(IntMap& am, IntMap& bm) {
bool equal = true;
if (am.count() != bm.count()) {
equal = false;
fprintf(stderr, "A.count() == %u and B.count() == %u\n", am.count(),
bm.count());
}
for (auto iter = am.iter(); !iter.done(); iter.next()) {
if (!bm.has(iter.get().key())) {
equal = false;
fprintf(stderr, "B does not have %x which is in A\n", iter.get().key());
}
}
for (auto iter = bm.iter(); !iter.done(); iter.next()) {
if (!am.has(iter.get().key())) {
equal = false;
fprintf(stderr, "A does not have %x which is in B\n", iter.get().key());
}
}
return equal;
}
static bool
MapsAreEqual(IntMap& am, IntMap& bm)
{
bool equal = true;
if (am.count() != bm.count()) {
equal = false;
fprintf(stderr, "A.count() == %u and B.count() == %u\n", am.count(), bm.count());
}
for (IntMap::Range r = am.all(); !r.empty(); r.popFront()) {
if (!bm.has(r.front().key())) {
equal = false;
fprintf(stderr, "B does not have %x which is in A\n", r.front().key());
}
}
for (IntMap::Range r = bm.all(); !r.empty(); r.popFront()) {
if (!am.has(r.front().key())) {
equal = false;
fprintf(stderr, "A does not have %x which is in B\n", r.front().key());
}
}
return equal;
}
int maxEnergy(vector <int> weight) {
m.clear();
memset(x, 0, sizeof(x));
len = weight.size();
if (len < 3) {
return 0;
}
if (len == 3) {
return weight[0]*weight[2];
}
int i;
for (i = 0; i < len; ++i) {
x[i] = weight[i];
}
int all_mask = (1<<len)-1;
int mid_mask = ((1<<(len-2))-1)*2;
int end_mask = all_mask ^ mid_mask;
m[end_mask] = 0;
return rec(all_mask);
}
int utl::findKey (const IntMap& iMap, int iVal)
{
IntMap::const_iterator it = utl::findValue(iMap,iVal);
return it == iMap.end() ? iVal : it->first;
}
void HashMapTest::testErase()
{
const int N = 1000;
typedef HashMap<int, int> IntMap;
IntMap hm;
for (int i = 0; i < N; ++i)
{
hm.insert(IntMap::ValueType(i, i*2));
}
assert (hm.size() == N);
for (int i = 0; i < N; i += 2)
{
hm.erase(i);
IntMap::Iterator it = hm.find(i);
assert (it == hm.end());
}
assert (hm.size() == N/2);
for (int i = 0; i < N; i += 2)
{
IntMap::Iterator it = hm.find(i);
assert (it == hm.end());
}
for (int i = 1; i < N; i += 2)
{
IntMap::Iterator it = hm.find(i);
assert (it != hm.end());
assert (*it == i);
}
for (int i = 0; i < N; i += 2)
{
hm.insert(IntMap::ValueType(i, i*2));
}
for (int i = 0; i < N; ++i)
{
IntMap::Iterator it = hm.find(i);
assert (it != hm.end());
assert (it->first == i);
assert (it->second == i*2);
}
}
