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";
}
}
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;
}
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 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);
}
}
}