Subversion Repositories HomeAutomation

#include <string>

/***************************************************************************

 *   Copyright (C) 2004 by Mattias Runge                                   *

 *   mattias@mrunge.se                                                     *

 *                                                                         *

 *   This program 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.                                   *

 *                                                                         *

 *   This program 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 this program; if not, write to the                         *

 *   Free Software Foundation, Inc.,                                       *

 *   59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.             *

 ***************************************************************************/

#include "tools.h"

string niceTime()

{

    string result;

    struct tm tmStruct;

    time_t t = time(NULL);

    localtime_r(&t, &tmStruct);

    result += lpad(itos(tmStruct.tm_hour), 2, '0');

    result += ":";

    result += lpad(itos(tmStruct.tm_min), 2, '0');

    result += ":";

    result += lpad(itos(tmStruct.tm_sec), 2, '0');

    return result;

}

unsigned int hex2uint(string hex)

{

    return bin2uint(hex2bin(hex));

}

unsigned int bin2uint(string bin)

{

    unsigned int num = 0;

    for (int n = bin.length()-1; n >= 0; n--)

    {

        if (bin[n] == '1')

            num += (unsigned int)pow(2.0f, (int)(bin.length()-1-n));

    }

    return num;

}

string invert(string bin)

{

    string inverted;

    for (int n = 0; n < bin.length(); n++)

        inverted += (bin[n] == '1' ? '0' : '1');

    return inverted;

}

float bin2float(string bin)

{

    float num = 0;

    if (bin.length() == 0)

        return 0.0f;

    bool isNegative = false;;

    if (bin[0] == '1')

    {

        bin = invert(bin);

        isNegative = true;

    }

    for (int n = bin.length()-1; n > 0; n--)

    {

        if (bin[n] == '1')

            num += pow(2.0f, (int)(bin.length()-1-n));

    }

    num /= 64.0f;

    if (isNegative)

        num = -num;

    return num;

}

string bin2hex(string bin)

{

    string hex;

    while (bin.size() > 0)

    {

        string part;

        try

        {

            part = bin.substr(0, 4);

        }

        catch (std::out_of_range& e)

        {

            cout << "DEBUG: bin2hex exception: " << e.what() << "\n";

            cout << "DEBUG: A bin=" << bin << endl;

            continue;

        }

        bin.erase(0, part.size());

        while (part.size() < 4)

            part = "0" + part;

        if (part == "0000")

            hex += '0';

        else if (part == "0001")

            hex += '1';

        else if (part == "0010")

            hex += '2';

        else if (part == "0011")

            hex += '3';

        else if (part == "0100")

            hex += '4';

        else if (part == "0101")

            hex += '5';

        else if (part == "0110")

            hex += '6';

        else if (part == "0111")

            hex += '7';

        else if (part == "1000")

            hex += '8';

        else if (part == "1001")

            hex += '9';

        else if (part == "1010")

            hex += 'a';

        else if (part == "1011")

            hex += 'b';

        else if (part == "1100")

            hex += 'c';

        else if (part == "1101")

            hex += 'd';

        else if (part == "1110")

            hex += 'e';

        else if (part == "1111")

            hex += 'f';

    }

    return hex;

}

string float2bin(float num, int length)

{

    string bin;

    ///FIXME

    while (bin.size() < length)

        bin = "0" + bin;

    return bin;

}

string hex2bin(string hex)

{

    hex = strtolower(hex);

    string bin;

    for (int n = 0; n < hex.length(); n++)

    {

        switch (hex[n])

        {

            case '0': bin += "0000"; break;

            case '1': bin += "0001"; break;

            case '2': bin += "0010"; break;

            case '3': bin += "0011"; break;

            case '4': bin += "0100"; break;

            case '5': bin += "0101"; break;

            case '6': bin += "0110"; break;

            case '7': bin += "0111"; break;

            case '8': bin += "1000"; break;

            case '9': bin += "1001"; break;

            case 'a': bin += "1010"; break;

            case 'b': bin += "1011"; break;

            case 'c': bin += "1100"; break;

            case 'd': bin += "1101"; break;

            case 'e': bin += "1110"; break;

            case 'f': bin += "1111"; break;

        }

    }

    return bin;

}

string uint2bin(unsigned int num, int length)

{

    string bin;

    while (num)

    {

        bin = char((num&1)+'0') + bin;

        num >>= 1;

    }

    while (bin.size() < length)

        bin = "0" + bin;

    string bin2;

    for (int i = 0; i < length; i++)

    {

        bin2 = bin2 + bin[i];

    }

    return bin2;

}

string uint2hex(unsigned int num, int length)

{

    return bin2hex(uint2bin(num, length));

}

vector<string> explode(string delimiter, string str)

{

    vector<string> parts;

    string::size_type startPos = 0;

    string::size_type endPos = 0;

    while ((endPos = str.find(delimiter, startPos)) != string::npos)

    {

        try

        {

            parts.push_back(str.substr(startPos, endPos-startPos));

        }

        catch (std::out_of_range& e)

        {

            cout << "DEBUG: explode exception: " << e.what() << "\n";

            cout << "DEBUG: A str=" << str << " :: startPos=" << startPos << " :: endPos=" << endPos << endl;

            continue;

        }

        startPos = endPos+delimiter.length();

    }

    if (startPos < str.length())

    {

        try

        {

            parts.push_back(str.substr(startPos, str.length()-startPos));

        }

        catch (std::out_of_range& e)

        {

            cout << "DEBUG: explode exception: " << e.what() << "\n";

            cout << "DEBUG: B str=" << str << " :: startPos=" << startPos << " :: endPos=" << endPos << endl;

        }

    }

    return parts;

}

string strtoupper(string s)

{

    for (unsigned int n = 0; n < s.size(); n++)

        s[n] = (char)toupper(s[n]);

    return s;

}

string strtolower(string s)

{

    for (unsigned int n = 0; n < s.size(); n++)

        s[n] = (char)tolower(s[n]);

    return s;

}

string trim(string s)

{

    return trim(s, ' ');

}

string trim(const string s, char c)

{

    string result = s;

    while (result[0] == c)

        result.erase(0, 1);

    while (result[result.length()-1] == c)

        result.erase(result.length()-1, 1);

    return result;

}

int stoi(const string s)

{

    istringstream in(s);

    int i;

    in >> i;

    return i;

}

string itos(int i)

{

    ostringstream out;

    out << i;

    return out.str();

}

unsigned int stou(const string s)

{

    istringstream in(s);

    unsigned int i;

    in >> i;

    return i;

}

string utos(unsigned int i)

{

    ostringstream out;

    out << i;

    return out.str();

}

float stof(const string s)

{

    istringstream in(s);

    float f;

    in >> f;

    return f;

}

string ftos(float f)

{

    ostringstream out;

    out << f;

    return out.str();

}

string str_replace(string search, string replace, string str)

{

    vector<string> parts = explode(search, str);

    string result;

    for (int n = 0; n < parts.size(); n++)

    {

        result += parts[n];

        if (n < parts.size()-1)

            result += replace;

    }

    return result;

}

string file_get_contents(string filename)

{

    ifstream srcfile(filename.c_str());

    if (!srcfile.is_open())

    {

        srcfile.close();

        return "";

    }

    string buffer = "";

    string line;

    while (!srcfile.eof())

    {

        getline(srcfile, line);

        if (srcfile.eof())

            break;

        buffer += line + "\n";

    };

    srcfile.close();

    return buffer;

}

bool file_exists(string filename)

{

    ifstream file(filename.c_str());

    if (file.is_open())

    {

        file.close();

        return true;

    }

    return false;

}

string escape(string in)

{

    string out;

    for (int n = 0; n < in.length(); n++)

    {

        switch (in[n])

        {

            case '\r':

                break;

            case '\n':

                out += "\\n";

                break;

            case '\'':

                out += "\\'";

                break;

            case '"':

                out += "\\\"";

                break;

            default:

                out += in[n];

                break;

        }

    }

    return out;

}

string rpad(string in, int length, char c)

{

    while (in.length() < length)

    {

        in += c;

    }

    return in;

}

string lpad(string in, int length, char c)

{

    while (in.length() < length)

    {

        in = c + in;

    }

    return in;

}