helpers.cpp

Go to the documentation of this file.

/*
    toxic - A Global Illumination Renderer
    Copyright (C) 2003-2004 Francois Beaune
    Contact: http://toxicengine.sourceforge.net/

    This file is part of toxic.

    toxic is free software; you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
    the Free Software Foundation; either version 2 of the License, or
    (at your option) any later version.

    toxic is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU General Public License for more details.

    You should have received a copy of the GNU General Public License
    along with toxic; if not, write to the Free Software
    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
*/

#include "helpers.h"    // include first
#include "common/misc/stringutils.h"

#include <cassert>
#include <cmath>    // std::ceil()
#include <iomanip>  // std::setprecision()
#include <sstream>

using namespace sheep;
using namespace std;
using namespace toxic;

PrefixStack::PrefixStack() {}

PrefixStack::PrefixStack(const string &s) {
    Push(s);
}

void PrefixStack::Push(const string &s) {
    push_back(m_prefix);
    m_prefix += s;
}

void PrefixStack::Pop() {
    m_prefix = back();
    pop_back();
}

const string &PrefixStack::operator()() const {
    return m_prefix;
}

void Indenter::Indent(int spaces /*= 2*/) {
    push_back(m_indent_string);
    m_indent_string += string(spaces, ' ');
}

void Indenter::Unindent() {
    m_indent_string = back();
    pop_back();
}

const string &Indenter::operator()() const {
    return m_indent_string;
}

string toxic::Ratio(int64 n, int64 d) {
    if(d == 0)
        return "not available";

    stringstream ss;

    ss << fixed << setprecision(1);
    ss << static_cast<float>(n) / d;

    return ss.str();
}

string toxic::Percentage(int64 n, int64 d) {
    if(d == 0)
        return "not available";

    const float p = (100.0f * n) / d;

    if(p > 0.0f && p < 0.1f)
        return "<0.1%";
    else {
        stringstream ss;

        ss << fixed << setprecision(1);
        ss << p;
        ss << '%';

        return ss.str();
    }
}

//!\todo Implement for floating point arguments, then use it in
//! the Ratio() function (in this file).
string toxic::ConvertNumberToString(int64 n) {
    //!\todo Rewrite using std::vector<> (or better, std::string).

    static char digits[] = { '0', '1', '2', '3', '4', '5', '6', '7', '8', '9' };
    const int BUFSIZE = 1000;
    char buf[BUFSIZE];
    char *p = buf;

    // Handle negative numbers.
    bool is_neg = n < 0;
    if(is_neg)
        n = -n;

    // Counter to insert commas at the right places.
    int ndigits = 0;

    // Build the string in reverse order.
    do {
        if(ndigits == 3) {
            // Make sure there's still room in the buffer.
            assert(p - buf < BUFSIZE);
            *p++ = ',';
            ndigits = 0;
        }

        // Make sure there's still room in the buffer.
        assert(p - buf < BUFSIZE);
        *p++ = digits[n % 10];
        ++ndigits;

        // Next digit.
        n /= 10;
    } while(n > 0);

    // Make sure the resulting string contains at least one character.
    assert(p - buf > 0);

    // Allocate the final string.
    string s;
    s.reserve(p - buf + is_neg ? 1 : 0);

    // Insert unary minus if input number was negative.
    if(is_neg)
        s += '-';

    // Copy the C-string to the final string.
    while(p > buf)
        s += *(--p);

    return s;
}

namespace {
    inline
    float ratio(int64 n, int64 d) {
        return static_cast<float>(n) / d;
    }
}

string toxic::ConvertSizeToString(int64 size, bool omit_details /*= false*/) {
    assert(size >= 0);

    string s = "";

    const int64 KB = 1024;
//  const int64 MB = 1024 * KB;
//  const int64 GB = 1024 * MB;

    if(size == 0)
        s += "0 byte";
    else if(size == 1)
        s += "1 byte";
    else if(size < KB)
        s += ConvertNumberToString(size) + " bytes";
    else /*if(size < MB)*/ {
        int64 n = static_cast<int64>(ceil(ratio(size, KB)));
        s += ConvertNumberToString(n) + " KB";
    } /*else if(size < GB) {
        int64 n = static_cast<int64>(ceil(ratio(size, MB)));
        s += ConvertNumberToString(n) + " MB";
    } else {
        int64 n = static_cast<int64>(ceil(ratio(size, GB)));
        s += ConvertNumberToString(n) + " GB";
    }*/

    if(size >= KB && !omit_details)
        s += " (" + ConvertNumberToString(size) + " bytes)";

    return s;
}

---