unitsdb.cpp File Reference

(986a3bf)

#include "resources/db/unitsdb.h"
#include "configuration.h"
#include "const/resources/currency.h"
#include "utils/cast.h"
#include "utils/checkutils.h"
#include "utils/stdmove.h"
#include "resources/beingcommon.h"
#include <climits>
#include "debug.h"

Go to the source code of this file.

Data Structures
struct	anonymous_namespace{unitsdb.cpp}::UnitLevel
struct	anonymous_namespace{unitsdb.cpp}::UnitDescription

Namespaces
	anonymous_namespace{unitsdb.cpp}

Functions
static std::string	formatUnit (const int value, const UnitDescription &ud)
static std::string	splitNumber (std::string str, const std::string &separator)
static UnitDescription	loadUnit (xmlNodePtr node)
static void	loadCurrencies (xmlNodePtr parentNode)

Variables
UnitDescription	anonymous_namespace{unitsdb.cpp}::defaultCurrency
UnitDescription	anonymous_namespace{unitsdb.cpp}::defaultWeight
std::map< std::string, UnitDescription >	anonymous_namespace{unitsdb.cpp}::mCurrencies

Function Documentation

formatUnit()

static std::string formatUnit ( const int  value, const UnitDescription &  ud  )

static

Definition at line 247 of file unitsdb.cpp.

{
    UnitLevel ul;
 
    // Shortcut for 0; do the same for values less than 0  (for now)
    if (value <= 0)
    {
        ul = ud.levels[0];
        return strprintf("0%s", ul.symbol.c_str());
    }
 
    double amount = ud.conversion * value;
    const unsigned int sz = CAST_U32(ud.levels.size());
 
    // If only the first level is needed, act like mix if false
    if (ud.mix && !ud.levels.empty() && ud.levels[1].count < amount)
    {
        std::string output;
        UnitLevel pl = ud.levels[0];
        ul = ud.levels[1];
        int levelAmount = CAST_S32(amount);
        int nextAmount = 0;
 
        if (ul.count != 0)
            levelAmount /= ul.count;
 
        amount -= static_cast<double>(levelAmount * ul.count);
 
        if (amount > 0)
        {
            output = splitNumber(strprintf("%.*f", pl.round,
                amount), pl.separator).append(pl.symbol);
        }
 
        for (unsigned int i = 2; i < sz; i++)
        {
            pl = ul;
            ul = ud.levels[i];
 
            if (ul.count != 0)
            {
                nextAmount = levelAmount / ul.count;
                levelAmount %= ul.count;
            }
 
            if (levelAmount > 0)
            {
                output = splitNumber(strprintf("%d", levelAmount),
                    pl.separator).append(pl.symbol).append(output);
            }
 
            if (nextAmount == 0)
                break;
            levelAmount = nextAmount;
        }
 
        return output;
    }
 
    ul.round = 0;
    for (unsigned int i = 0; i < sz; i++)
    {
        ul = ud.levels[i];
        if (amount < ul.count && ul.count > 0)
        {
            ul = ud.levels[i - 1];
            break;
        }
        if (ul.count != 0)
            amount /= ul.count;
    }
 
    return splitNumber(strprintf("%.*f", ul.round, amount),
        ul.separator).append(ul.symbol);
}

References CAST_S32, CAST_U32, splitNumber(), and strprintf().

Referenced by UnitsDb::formatCurrency(), UnitsDb::formatCurrency64(), and UnitsDb::formatWeight().

loadCurrencies()

static void loadCurrencies ( xmlNodePtr  parentNode )

static

Definition at line 181 of file unitsdb.cpp.

{
    for_each_xml_child_node(node, parentNode)
    {
        if (xmlNameEqual(node, "unit"))
        {
            const std::string name = XML::getProperty(node, "name", "");
            if (name.empty())
            {
                reportAlways("Error: unknown currency name.")
                continue;
            }
            mCurrencies[name] = loadUnit(node);
            if (name == DEFAULT_CURRENCY)
                defaultCurrency = mCurrencies[name];
        }
    }
}

References DEFAULT_CURRENCY, anonymous_namespace{unitsdb.cpp}::defaultCurrency, for_each_xml_child_node, XML::getProperty(), loadUnit(), anonymous_namespace{unitsdb.cpp}::mCurrencies, and reportAlways.

Referenced by UnitsDb::loadXmlFile().

loadUnit()

static UnitDescription loadUnit ( xmlNodePtr  node )

static

Definition at line 126 of file unitsdb.cpp.

{
    UnitDescription ud;
    int level = 1;
    ud.conversion = XML::getProperty(node, "conversion", 1);
    ud.mix = XML::getProperty(node, "mix", "no") == "yes";
 
    UnitLevel bu;
    bu.symbol = XML::getProperty(node, "base", "¤");
    bu.count = 1;
    bu.round = XML::getProperty(node, "round", 2);
    bu.separator = XML::getProperty(node, "separator", " ");
 
    ud.levels.push_back(bu);
 
    for_each_xml_child_node(uLevel, node)
    {
        if (xmlNameEqual(uLevel, "level"))
        {
            const UnitLevel ul =
            {
                XML::getProperty(uLevel, "symbol",
                                 strprintf("¤%d", level)),
                XML::getProperty(uLevel, "count", -1),
                XML::getProperty(uLevel, "round", bu.round),
                XML::getProperty(uLevel, "separator", bu.separator)
            };
 
            if (ul.count > 0)
            {
                ud.levels.push_back(ul);
                level++;
            }
            else
            {
                logger->log("Error bad unit count: %d for %s in %s",
                    ul.count,
                    ul.symbol.c_str(),
                    bu.symbol.c_str());
            }
        }
    }
 
    // Add one more level for saftey
    const UnitLevel lev =
    {
        "",
        INT_MAX,
        0,
        ""
    };
    ud.levels.push_back(lev);
    return ud;
}

References for_each_xml_child_node, XML::getProperty(), Logger::log(), logger, and strprintf().

Referenced by loadCurrencies(), and UnitsDb::loadXmlFile().

splitNumber()

static std::string splitNumber ( std::string  str, const std::string &  separator  )

static

Definition at line 362 of file unitsdb.cpp.

{
    std::string lastPart;
    const size_t point = str.find('.');
    if (point != std::string::npos)
    {
        lastPart = str.substr(point);
        str = str.substr(0, point);
    }
    std::string result;
 
    if (!str.empty())
    {
        size_t sz = str.size();
        while (sz >= 3)
        {
            if (sz >= 6)
            {
                result = std::string(separator).append(str.substr(
                    sz - 3)).append(result);
            }
            else
            {
                result = str.substr(sz - 3).append(result);
            }
            str = str.substr(0, str.size() - 3);
            sz = str.size();
        }
        if (!str.empty())
        {
            if (!result.empty())
                result = std::string(str).append(separator).append(result);
            else
                result = STD_MOVE(str);
        }
    }
 
    return result + lastPart;
}

References STD_MOVE.

Referenced by formatUnit().