void testAdd() {
Hash<int, int> h;
h.put(42, 11);
if (h.get(42) == h.end()) {
cout << "testAdd failed\n";
}
}
IntPair mode(const int *values, unsigned int size) {
Hash::iterator it;
Hash hash;
for (int i = 0; i < size; i++) {
it = hash.find(values[i]);
if(it == hash.end()) {
hash.insert( std::make_pair(values[i], 1));
} else {
it->second += 1;
}
}
unsigned int counts = 0;
Hash::iterator found;
for (it = hash.begin(); it != hash.end(); ++it) {
if(it->second > counts) {
counts = it->second;
found = it;
}
}
return *found;
}
void extract_hash(Hash const& hash){
Class hash_class(Hash().class_of());
Class array_class(Array().class_of());
Class string_class(String().class_of());
for(Hash::const_iterator i=hash.begin(), iend=hash.end(); i!=iend; ++i){
std::cout << i->key << ":\n";
Object obj(i->value);
if(obj.is_instance_of(hash_class))
extract_hash(obj);
else if(obj.is_instance_of(array_class))
extract_array(obj);
else if(obj.is_instance_of(string_class))
std::cout << i->value << "\n";
else
std::cout << i->value << "\n";
}
}
/* Brief: TODO description
* Parameter: index, TODO description
* Parameter: role, TODO description
*
* Note: This function is called
*/
QVariant CDailyWeatherModel::data( const QModelIndex & index, int role ) const
{
int column = index.column();
int row = index.row();
//qDebug("from inside Data(), row:%i, col:%i, role=%i, counter=%i", row, column, role, counter);
if (role == Qt::DisplayRole || role == Qt::EditRole)
{
if (mStation == NULL)
return QVariant("n/a");
if (column == CDailyWeatherModel::YEAR)
return QVariant(mYear);
else if (column == CDailyWeatherModel::DOY)
return QVariant(row+1);
else {
// Note: Be sure to use pointer here! Else, the map will be returned by value. This means
// that a copy of this huge map will be made whenever this function is called (whenever
// the model needs to be updated or the table needs to be redraen - potentially many times.
// This will lag the interface.
Hash* hash = mStation->getWeather();
QString yr = QString::number(mYear);
QString doy = QString::number(row+1);
Pair pair(yr, doy);
// Find item in weather map with key
Hash::const_iterator iter = hash->find(pair);
// (Year, Day of Year) not found in weather data map for the current station
if(iter == hash->end())
return QVariant("n/a");
return QVariant(iter.value()->at(column-2));
}
}
else if (role == Qt::TextAlignmentRole)
return QVariant(Qt::AlignCenter);
else
return QVariant();
}
void findSmallestSubString (string word, unsigned int indexInString)
{
Hash::iterator nptr;
bool checkForNewSmallest = false;
/* its not their in words to check */
if( (nptr=words.find(word)) == words.end() ) return ;
if( nptr->second->index == -1 )
noOfWords--;
nptr->second->index = indexInString;
if( start == NULL ) start = nptr->second;
else if( start == nptr->second)
{
start = start->next;
checkForNewSmallest = true;
}
if( end == NULL ) end = nptr->second;
else if( end != nptr->second)
{
Node *n = nptr->second;
if( n->prev ) n->prev->next = n->next;
if( n->next ) n->next->prev = n->prev;
n->prev = end;
end->next = n;
end = n;
}
if( noOfWords == 0 && checkForNewSmallest )
{
if( smallestCount > end->index - start->index + 1 )
{
smallestIndex = start->index;
smallestCount = end->index - start->index + 1;
}
}
}
int
da_build_dump(da_build_t* builder, char* tmpfile, FILE* lexfile)
{
Hash::iterator i, last;
Hash* entries = builder->entries;
char** keys = new char*[entries->size()];
size_t* lens = new size_t[entries->size()];
long* vals = new long[entries->size()];
int size = 0;
std::vector<long> lex_indices;
std::cerr << entries->size() << " entries" << std::endl;
i = entries->begin();
while (i != entries->end()) {
const std::string& key = i->first;
last = entries->upper_bound(key);
lex_indices.clear();
for (; i != last; i++) {
lex_indices.push_back(i->second);
}
lens[size] = key.size();
keys[size] = (char*) key.data();
vals[size] = redump_lex(lens[size], lex_indices, tmpfile, lexfile);
if (vals[size] < 0) {
std::cerr << "Unexpected error at " << key << std::endl;
cha_exit_perror((char*)"build darts file");
}
size++;
}
std::cerr << size << " keys" << std::endl;
DoubleArrayL da;
da.build(size, (const char**) keys, lens, vals);
da.save(builder->path->c_str(), "wb");
return builder->entries->size();
}
int StatusJob::execute()
{
bool matched = false;
const char *alternatives = "fileids|watchedpaths|dependencies|symbols|symbolnames|sources|jobs|info|compilers";
if (!strcasecmp(query.constData(), "fileids")) {
matched = true;
if (!write(delimiter) || !write("fileids") || !write(delimiter))
return 1;
const Hash<uint32_t, Path> paths = Location::idsToPaths();
for (Hash<uint32_t, Path>::const_iterator it = paths.begin(); it != paths.end(); ++it) {
if (!write<256>(" %u: %s", it->first, it->second.constData()))
return 1;
}
if (isAborted())
return 1;
}
std::shared_ptr<Project> proj = project();
if (!proj) {
if (!matched)
write(alternatives);
return matched ? 0 : 1;
}
if (query.isEmpty() || !strcasecmp(query.constData(), "watchedpaths")) {
matched = true;
if (!write(delimiter) || !write("watchedpaths") || !write(delimiter))
return 1;
Set<Path> watched = proj->watchedPaths();
if (!write("Indexer"))
return 1;
for (Set<Path>::const_iterator it = watched.begin(); it != watched.end(); ++it) {
if (!write<256>(" %s", it->constData()))
return 1;
}
if (proj->fileManager) {
if (!write("FileManager"))
return 1;
watched = proj->fileManager->watchedPaths();
for (Set<Path>::const_iterator it = watched.begin(); it != watched.end(); ++it) {
if (!write<256>(" %s", it->constData()))
return 1;
}
}
if (isAborted())
return 1;
}
if (query.isEmpty() || !strcasecmp(query.constData(), "dependencies")) {
matched = true;
const DependencyMap map = proj->dependencies();
if (!write(delimiter) || !write("dependencies") || !write(delimiter))
return 1;
DependencyMap depsReversed;
for (DependencyMap::const_iterator it = map.begin(); it != map.end(); ++it) {
if (!write<256>(" %s (%d) is depended on by", Location::path(it->first).constData(), it->first))
return 1;
const Set<uint32_t> &deps = it->second;
for (Set<uint32_t>::const_iterator dit = deps.begin(); dit != deps.end(); ++dit) {
if (!write<256>(" %s (%d)", Location::path(*dit).constData(), *dit))
return 1;
depsReversed[*dit].insert(it->first);
}
if (isAborted())
return 1;
}
for (DependencyMap::const_iterator it = depsReversed.begin(); it != depsReversed.end(); ++it) {
write<256>(" %s (%d) depends on", Location::path(it->first).constData(), it->first);
const Set<uint32_t> &deps = it->second;
for (Set<uint32_t>::const_iterator dit = deps.begin(); dit != deps.end(); ++dit) {
if (!write<256>(" %s (%d)", Location::path(*dit).constData(), *dit))
return 1;
}
if (isAborted())
return 1;
}
}
if (query.isEmpty() || !strcasecmp(query.constData(), "symbols")) {
matched = true;
const SymbolMap &map = proj->symbols();
write(delimiter);
write("symbols");
write(delimiter);
for (SymbolMap::const_iterator it = map.begin(); it != map.end(); ++it) {
const Location loc = it->first;
const std::shared_ptr<CursorInfo> ci = it->second;
write(loc);
write(ci);
write("------------------------");
if (isAborted())
return 1;
}
}
if (query.isEmpty() || !strcasecmp(query.constData(), "symbolnames")) {
matched = true;
const SymbolNameMap &map = proj->symbolNames();
write(delimiter);
write("symbolnames");
write(delimiter);
for (SymbolNameMap::const_iterator it = map.begin(); it != map.end(); ++it) {
write<128>(" %s", it->first.constData());
const Set<Location> &locations = it->second;
for (Set<Location>::const_iterator lit = locations.begin(); lit != locations.end(); ++lit) {
const Location &loc = *lit;
write<1024>(" %s", loc.key().constData());
}
if (isAborted())
return 1;
}
}
if (query.isEmpty() || !strcasecmp(query.constData(), "sources")) {
matched = true;
const SourceMap &map = proj->sources();
if (!write(delimiter) || !write("sources") || !write(delimiter))
return 1;
for (SourceMap::const_iterator it = map.begin(); it != map.end(); ++it) {
if (!write<512>(" %s: %s", it->second.sourceFile().constData(), it->second.toString().constData()))
return 1;
}
}
if (query.isEmpty() || !strcasecmp(query.constData(), "jobs")) {
matched = true;
if (!write(delimiter) || !write("jobs") || !write(delimiter))
return 1;
Server::instance()->dumpJobs(connection());
}
if (query.isEmpty() || !strcasecmp(query.constData(), "compilers")) {
matched = true;
if (!write(delimiter) || !write("compilers") || !write(delimiter))
return 1;
Source source;
for (const Path &compiler : CompilerManager::compilers()) {
source.compilerId = Location::insertFile(compiler);
source.defines.clear();
source.includePaths.clear();
CompilerManager::applyToSource(source, true, true);
write(compiler);
write(" Defines:");
for (const auto &it : source.defines)
write<512>(" %s", it.toString().constData());
write(" Includepaths:");
for (const auto &it : source.includePaths)
write<512>(" %s", it.toString().constData());
write("");
}
}
if (query.isEmpty() || !strcasecmp(query.constData(), "info")) {
matched = true;
if (!write(delimiter) || !write("info") || !write(delimiter))
return 1;
String out;
Log log(&out);
#ifdef NDEBUG
out << "Running a release build\n";
#else
out << "Running a debug build\n";
#endif
const Server::Options &opt = Server::instance()->options();
out << "socketFile" << opt.socketFile << '\n'
<< "dataDir" << opt.dataDir << '\n'
<< "options" << String::format("0x%x\n", opt.options)
<< "jobCount" << opt.jobCount << '\n'
<< "unloadTimer" << opt.unloadTimer << '\n'
<< "rpVisitFileTimeout" << opt.rpVisitFileTimeout << '\n'
<< "rpIndexerMessageTimeout" << opt.rpIndexerMessageTimeout << '\n'
<< "rpConnectTimeout" << opt.rpConnectTimeout << '\n'
<< "rpConnectTimeout" << opt.rpConnectTimeout << '\n'
<< "syncThreshold" << opt.syncThreshold << '\n'
<< "threadStackSize" << opt.threadStackSize << '\n'
<< "defaultArguments" << opt.defaultArguments << '\n'
<< "includePaths" << opt.includePaths << '\n'
<< "defines" << opt.defines << '\n'
<< "ignoredCompilers" << opt.ignoredCompilers;
write(out);
}
if (!matched) {
write<256>("rc -s %s", alternatives);
return 1;
} else {
return 0;
}
}
int main() {
Value a;
assert(!a.isInteger());
assert(!a.isString());
assert(!a.isList());
assert(!a.isHash());
assert(a.type() == Value::UNDEFINED);
assert(!a);
a = Value(11);
assert(a.isInteger());
assert(!a.isString());
assert(!a.isList());
assert(!a.isHash());
assert(a);
assert(a.asInteger() == 11);
a = Value("123");
assert(!a.isInteger());
assert(a.isString());
assert(!a.isList());
assert(!a.isHash());
assert(a);
assert(a.asString() == "123");
List b;
b.push_back(Value(11));
b.push_back(Value("111"));
a = Value(b);
b.push_back(Value(34));
assert(b.size() == 3);
assert(a.isList());
assert(a.asList().size() == 2);
Hash m;
m["aa"] = Value(12);
m["bb"] = Value(11);
a = Value(m);
m.erase("bb");
assert(m.size() == 1);
assert(m["aa"].asInteger() == 12);
assert(m.find("bb") == m.end());
assert(a.isHash());
assert(a.asHash().size() == 2);
a = Value(Vector(1,-1,2));
assert(a.type() == Value::VECTOR);
assert(a.isVector());
assert(a.asVector().y == -1);
assert(a);
a = Value(Position(1,-1,2));
assert(a.type() == Value::POSITION);
assert(a.isPosition());
assert(a.asPosition().x == 1);
assert(a);
std::cout << "Success!" << std::endl;
return 0;
}
int StatusJob::execute()
{
auto match = [this](const char *name) {
return !strncasecmp(query.constData(), name, query.size());
};
bool matched = false;
const char *alternatives = "fileids|watchedpaths|dependencies|cursors|symbols|targets|symbolnames|sources|jobs|info|compilers|headererrors|memory";
if (match("fileids")) {
matched = true;
if (!write(delimiter) || !write("fileids") || !write(delimiter))
return 1;
const Hash<uint32_t, Path> paths = Location::idsToPaths();
for (Hash<uint32_t, Path>::const_iterator it = paths.begin(); it != paths.end(); ++it) {
if (!write<256>(" %u: %s", it->first, it->second.constData()))
return 1;
}
if (isAborted())
return 1;
}
if (match("headererrors")) {
matched = true;
if (!write(delimiter) || !write("headererrors") || !write(delimiter))
return 1;
for (auto err : Server::instance()->jobScheduler()->headerErrors()) {
if (!write(Location::path(err)))
return 1;
}
if (isAborted())
return 1;
}
if (query.isEmpty() || match("info")) {
matched = true;
if (!write(delimiter) || !write("info") || !write(delimiter))
return 1;
String out;
Log log(&out);
#ifdef NDEBUG
out << "Running a release build\n";
#else
out << "Running a debug build\n";
#endif
const Server::Options &opt = Server::instance()->options();
out << "socketFile" << opt.socketFile << '\n'
<< "dataDir" << opt.dataDir << '\n'
<< "options" << opt.options
<< "jobCount" << opt.jobCount << '\n'
<< "rpVisitFileTimeout" << opt.rpVisitFileTimeout << '\n'
<< "rpIndexDataMessageTimeout" << opt.rpIndexDataMessageTimeout << '\n'
<< "rpConnectTimeout" << opt.rpConnectTimeout << '\n'
<< "rpConnectTimeout" << opt.rpConnectTimeout << '\n'
<< "threadStackSize" << opt.threadStackSize << '\n'
<< "defaultArguments" << opt.defaultArguments << '\n'
<< "includePaths" << opt.includePaths << '\n'
<< "defines" << opt.defines << '\n'
<< "ignoredCompilers" << opt.ignoredCompilers;
write(out);
}
std::shared_ptr<Project> proj = project();
if (!proj) {
if (!matched)
write(alternatives);
return matched ? 0 : 1;
}
if (query.isEmpty() || match("watchedpaths")) {
matched = true;
if (!write(delimiter) || !write("watchedpaths") || !write(delimiter))
return 1;
Hash<Path, Flags<Project::WatchMode> > watched = proj->watchedPaths();
auto watchModeToString = [](Flags<Project::WatchMode> mode) {
List<String> ret;
if (mode & Project::Watch_FileManager)
ret << "filemanager";
if (mode & Project::Watch_SourceFile)
ret << "source";
if (mode & Project::Watch_Dependency)
ret << "dependency";
if (mode & Project::Watch_CompilationDatabase)
ret << "compilationdatabase";
return String::join(ret, '|');
};
for (const auto &it : watched) {
if (!write<256>(" %s (%s)", it.first.constData(), watchModeToString(it.second).constData())) {
return 1;
}
}
}
const Dependencies &deps = proj->dependencies();
if (query.isEmpty() || match("dependencies")) {
matched = true;
if (!write(delimiter) || !write("dependencies") || !write(delimiter))
return 1;
for (auto it : deps) {
write(proj->dumpDependencies(it.first));
}
if (isAborted())
return 1;
}
if (query.isEmpty() || match("symbols") || match("cursors")) {
matched = true;
write(delimiter);
write("symbols");
write(delimiter);
for (const auto &dep : deps) {
auto symbols = proj->openSymbols(dep.first);
if (!symbols)
continue;
const int count = symbols->count();
for (int i=0; i<count; ++i) {
const Location loc = symbols->keyAt(i);
const Symbol c = symbols->valueAt(i);
write(loc);
write(c);
write("------------------------");
if (isAborted())
return 1;
}
}
}
if (query.isEmpty() || match("targets")) {
matched = true;
write(delimiter);
write("targets");
write(delimiter);
for (const auto &dep : deps) {
auto targets = proj->openTargets(dep.first);
if (!targets)
continue;
const int count = targets->count();
for (int i=0; i<count; ++i) {
const String usr = targets->keyAt(i);
write<128>(" %s", usr.constData());
for (const auto &t : proj->findByUsr(usr, dep.first, Project::ArgDependsOn)) {
write<1024>(" %s\t%s", t.location.toString(locationToStringFlags()).constData(),
t.kindSpelling().constData());
}
for (const auto &location : targets->valueAt(i)) {
write<1024>(" %s", location.toString(locationToStringFlags()).constData());
}
write("------------------------");
if (isAborted())
return 1;
}
}
}
if (query.isEmpty() || match("symbolnames")) {
matched = true;
write(delimiter);
write("symbolnames");
write(delimiter);
for (const auto &dep : deps) {
auto symNames = proj->openSymbolNames(dep.first);
if (!symNames)
continue;
const int count = symNames->count();
for (int i=0; i<count; ++i) {
write<128>(" %s", symNames->keyAt(i).constData());
for (const Location &loc : symNames->valueAt(i)) {
write<1024>(" %s", loc.toString().constData());
}
write("------------------------");
if (isAborted())
return 1;
}
}
}
if (query.isEmpty() || match("sources")) {
matched = true;
const Sources &map = proj->sources();
if (!write(delimiter) || !write("sources") || !write(delimiter))
return 1;
for (Sources::const_iterator it = map.begin(); it != map.end(); ++it) {
if (!write<512>(" %s: %s", it->second.sourceFile().constData(), it->second.toString().constData()))
return 1;
}
}
if (query.isEmpty() || match("jobs")) {
matched = true;
if (!write(delimiter) || !write("jobs") || !write(delimiter))
return 1;
Server::instance()->dumpJobs(connection());
}
if (query.isEmpty() || match("compilers")) {
matched = true;
if (!write(delimiter) || !write("compilers") || !write(delimiter))
return 1;
Source source;
for (const Path &compiler : CompilerManager::compilers()) {
source.compilerId = Location::insertFile(compiler);
source.defines.clear();
source.includePaths.clear();
CompilerManager::applyToSource(source, true, true);
write(compiler);
write(" Defines:");
for (const auto &it : source.defines)
write<512>(" %s", it.toString().constData());
write(" Includepaths:");
for (const auto &it : source.includePaths)
write<512>(" %s", it.toString().constData());
write("");
}
}
if (query.isEmpty() || match("memory")) {
write(proj->estimateMemory());
matched = true;
}
if (!matched) {
write<256>("rc -s %s", alternatives);
return 1;
} else {
return 0;
}
}
void tst_QHash::insert1()
{
const char *hello = "hello";
const char *world = "world";
const char *allo = "allo";
const char *monde = "monde";
{
typedef QHash<QString, QString> Hash;
Hash hash;
QString key;
for (int i = 0; i < 10; ++i) {
key[0] = i + '0';
for (int j = 0; j < 10; ++j) {
key[1] = j + '0';
hash.insert(key, "V" + key);
}
}
for (int i = 0; i < 10; ++i) {
key[0] = i + '0';
for (int j = 0; j < 10; ++j) {
key[1] = j + '0';
hash.remove(key);
}
}
}
{
typedef QHash<int, const char *> Hash;
Hash hash;
hash.insert(1, hello);
hash.insert(2, world);
QVERIFY(hash.size() == 2);
QVERIFY(!hash.isEmpty());
{
Hash hash2 = hash;
hash2 = hash;
hash = hash2;
hash2 = hash2;
hash = hash;
hash2.clear();
hash2 = hash2;
QVERIFY(hash2.size() == 0);
QVERIFY(hash2.isEmpty());
}
QVERIFY(hash.size() == 2);
{
Hash hash2 = hash;
hash2[1] = allo;
hash2[2] = monde;
QVERIFY(hash2[1] == allo);
QVERIFY(hash2[2] == monde);
QVERIFY(hash[1] == hello);
QVERIFY(hash[2] == world);
hash2[1] = hash[1];
hash2[2] = hash[2];
QVERIFY(hash2[1] == hello);
QVERIFY(hash2[2] == world);
hash[1] = hash[1];
QVERIFY(hash[1] == hello);
}
{
Hash hash2 = hash;
hash2.detach();
hash2.remove(1);
QVERIFY(hash2.size() == 1);
hash2.remove(1);
QVERIFY(hash2.size() == 1);
hash2.remove(0);
QVERIFY(hash2.size() == 1);
hash2.remove(2);
QVERIFY(hash2.size() == 0);
QVERIFY(hash.size() == 2);
}
hash.detach();
{
Hash::iterator it1 = hash.find(1);
QVERIFY(it1 != hash.end());
Hash::iterator it2 = hash.find(0);
QVERIFY(it2 != hash.begin());
QVERIFY(it2 == hash.end());
*it1 = monde;
QVERIFY(*it1 == monde);
QVERIFY(hash[1] == monde);
*it1 = hello;
QVERIFY(*it1 == hello);
QVERIFY(hash[1] == hello);
hash[1] = monde;
QVERIFY(it1.key() == 1);
QVERIFY(it1.value() == monde);
QVERIFY(*it1 == monde);
QVERIFY(hash[1] == monde);
hash[1] = hello;
QVERIFY(*it1 == hello);
QVERIFY(hash[1] == hello);
}
{
const Hash hash2 = hash;
Hash::const_iterator it1 = hash2.find(1);
QVERIFY(it1 != hash2.end());
QVERIFY(it1.key() == 1);
QVERIFY(it1.value() == hello);
QVERIFY(*it1 == hello);
Hash::const_iterator it2 = hash2.find(2);
QVERIFY(it1 != it2);
QVERIFY(it1 != hash2.end());
QVERIFY(it2 != hash2.end());
int count = 0;
it1 = hash2.begin();
while (it1 != hash2.end()) {
count++;
++it1;
}
QVERIFY(count == 2);
count = 0;
it1 = hash.begin();
while (it1 != hash.end()) {
count++;
++it1;
}
QVERIFY(count == 2);
}
{
QVERIFY(hash.contains(1));
QVERIFY(hash.contains(2));
QVERIFY(!hash.contains(0));
QVERIFY(!hash.contains(3));
}
{
QVERIFY(hash.value(1) == hello);
QVERIFY(hash.value(2) == world);
QVERIFY(hash.value(3) == 0);
QVERIFY(hash.value(1, allo) == hello);
QVERIFY(hash.value(2, allo) == world);
QVERIFY(hash.value(3, allo) == allo);
QVERIFY(hash.value(0, monde) == monde);
}
{
QHash<int,Foo> hash;
for (int i = 0; i < 10; i++)
hash.insert(i, Foo());
QVERIFY(Foo::count == 10);
hash.remove(7);
QVERIFY(Foo::count == 9);
}
QVERIFY(Foo::count == 0);
{
QHash<int, int*> hash;
QVERIFY(((const QHash<int,int*>*) &hash)->operator[](7) == 0);
}
}
}