/Users/jst/src/grafalgo/cpp/misc/Util.cpp

Go to the documentation of this file.

#include "Util.h"

namespace grafalgo {

bool Util::skipSpace(istream& in, bool sameline) {
        while (true) {
                char c = in.get();
                if (!in.good()) return false;
                if (sameline && c == '\n') { in.unget(); return false; }
                if (!isspace(c)) { in.unget(); return true; }
        }
}

bool Util::skipBlank(istream& in) {
        char c; bool com;
        com = false;
        while (1) {
                in.get(c); if (!in.good()) return false;
                if (c ==  '#') {com =  true; continue; }
                if (c == '\n') {com = false; continue; }
                if (com || isspace(c)) continue;
                in.unget(); return true;
        }
}

bool Util::readWord(istream& in, string& s, bool sameline) {
        s = "";
        skipSpace(in,sameline);
        char c = in.peek();
        if (!in.good() || !isalpha(c)) return false;
        while (1) {
                c = in.get();
                if (!in.good()) return false;
                if (isalpha(c) || isdigit(c) || c == '_' || c == '/') s += c;
                else { in.unget(); return true; }
        }
}

bool Util::readInt(istream& in, int& i, bool sameline) {
        if (skipSpace(in,sameline)) {
                char c = in.get();
                if (in.good() && (isdigit(c) || c != '-')) {
                        in.unget();
                        in >> i;
                        if (in.good()) return true;
                }
        }
        return false;
}

bool Util::verify(istream& in, char c, bool strict) {
        skipSpace(in);
        char c1 = in.get();
        if (!in.good()) return false;
        if (c == c1) return true;
        in.unget();
        return false;
}

bool Util::prefix(string& s1, string& s2) {
        return s1.length() > 0 && s2.find(s1) == 0;
}

int Util::strnlen(char* s, int n) {
        for (int i = 0; i < n; i++) 
                if (*s++ == '\0') return i;
        return n;
}

void Util::genPerm(int n, int p[]) {
        int i, j, k;
        for (i = 1; i <= n; i++) p[i] = i;
        for (i = 1; i <= n; i++) {
                j = randint(i,n);
                k = p[i]; p[i] = p[j]; p[j] = k;
        }
}

uint32_t Util::getTime() {
        // note use of static variables
        static uint32_t now;
        static struct timeval prevTimeval = { 0, 0 };

        if (prevTimeval.tv_sec == 0 && prevTimeval.tv_usec == 0) {
                // first call to getTime(); initialize and return 0
                if (gettimeofday(&prevTimeval, NULL) < 0)
                        fatal("Util::getTime: gettimeofday failure");
                now = 0;
                return 0;
        }
        // normal case
        struct timeval nowTimeval;
        if (gettimeofday(&nowTimeval, NULL) < 0)
                fatal("Util::getTime: gettimeofday failure");
        uint32_t dsec = nowTimeval.tv_sec; dsec -= prevTimeval.tv_sec;
        uint32_t dusec = nowTimeval.tv_usec - prevTimeval.tv_usec;
        if (nowTimeval.tv_usec < prevTimeval.tv_usec) {
                dusec = nowTimeval.tv_usec + (1000000 - prevTimeval.tv_usec);
                dsec--;
        }
        now += 1000000*dsec + dusec;
        prevTimeval = nowTimeval;

        return now;
}

} // ends namespace