WebSVN – HomeAutomation – Diff – /trunk/PcSoftware/Atom/Tools/tools.cpp


 
#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;
 
    return bin;
}
 
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;
}
 
 
// FileTools
 
vector<string> FileTools::GetDirList(string path)
{
    DIR *dir = opendir(path.c_str());
    vector<string> list;
 
    if (!dir)
        return list;
 
    dirent *d;
    while ((d = readdir(dir)))
    {
        if (d->d_name[0] == '.')
            continue;
 
        list.push_back(d->d_name);
    }
    closedir(dir);
 
    return list;
}
 
string FileTools::GetUniqeFilename(string path, string prefix, string postfix)
{
    time_t now;
    time(&now);
 
    string filename = path + prefix + itos(now);
 
    int index = 0;
    while (1)
    {
        string file = filename + itos(index) + postfix;
        if (!Exist(file))
            break;
        index++;
    }
 
    filename += itos(index) + postfix;
 
    return filename;
}
 
bool FileTools::SaveFile(string filepath, string data)
{
    ofstream destfile(filepath.c_str());
    if (!destfile.is_open())
    {
        destfile.close();
        return false;
    }
 
    destfile << data;
 
    destfile.close();
    return true;
}
 
string FileTools::Get(string src)
{
    ifstream srcfile(src.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 FileTools::Copy(string src, string dest)
{
    ifstream srcfile(src.c_str());
    if (!srcfile.is_open())
    {
        srcfile.close();
        return false;
    }
 
    ofstream destfile(dest.c_str());
    if (!destfile.is_open())
    {
        destfile.close();
        srcfile.close();
        return false;
    }
 
    string line;
    while (!srcfile.eof())
    {
        getline(srcfile, line);
        if (srcfile.eof())
            break;
        destfile << line << endl;
    };
 
    destfile.close();
    srcfile.close();
 
    return true;
}
 
bool FileTools::Exist(string filename)
{
    ifstream file(filename.c_str());
    if (file.is_open())
    {
        file.close();
        return true;
    }
 
    return false;
}
 
 
 
 
 
/*
void bd()
{
         int n,b=0,a[6],i=0,t=0;
         clrscr();
         printf("Conversion from Binary to Decimal\n");
         printf("Enter Binary Number\n");
         scanf("%d",&n);
         while(n!=0)
         {
          a[i]=n%10;
          n=n/10;
          if(a[i]!=1 && a[i]!=0)
           t=1;
          i++;
         }
         a[i]=2;
         n=1;
         for(i=0;a[i]!=2;i++)
         {
          b=b+a[i]*n;
          n=n*2;
         }
         if(t==0)
          printf("Decimal Equivalent=%d",B);
         else if(t==1)
          printf("Entered number is not binary.");
 
}
 
void db()
{
         int dec,bin,n,i=0,a[10];
         clrscr();
         printf("Conversion from Decimal to Binary\n");
         printf("Input decimal no.");
         scanf("%d",&dec);
         do
         {
         a[i]=dec%2;
         dec=dec/2;
         i++;
         }while(dec!=0);
         for(n=i-1;n>=0;n--)
         printf("%d",a[n]);
}
 
void doc()
{
         int n,i,a[10];
         clrscr();
         printf("Conversion from Decimal to Octal\n");
         printf("Enter a Decimal number\n");
         scanf("%d",&n);
         i=0;
         printf("Octal equavalent of %d is ",n);
         while(n!=0)
         {
          a[i]=n%8;
          n=n/8;
          i++;
         }
         i--;
         for(;i>=0;i--)
          printf("%d",a[i]);
}
 
void dh(long n)
{
         long i;
         if(n>0)
         {
          i=n%16;
          n=n/16;
          dh(n);
          if(i>=10)
          {
           switch(i)
           {
            case 10:
             printf("A");
             break;
            case 11:
             printf("B");
             break;
            case 12:
             printf("C");
             break;
            case 13:
             printf("D");
             break;
            case 14:
             printf("E");
             break;
            case 15:
             printf("F");
             break;
           }
          }
          else
           printf("%ld",i);
         }
}
 
void od()
{
         unsigned long n,i=0,a,p=1,t=0;
         clrscr();
         printf("Conversion from Octal to Decimal\n");
         printf("Enter a Octal number\n");
         scanf("%ld",&n);
         i=0;
         printf("Decimal equavalent of %ld",n);
         while(n!=0)
         {
          a=n%10;
          if(a>7)
           t=1;
          n=n/10;
          i=i+a*p;
          p=p*8;
         }
         if(t==0)
          printf("= %ld",i);
         else if(t==1)
          printf(" can't be calculated because it is not an Octal Number.\n");
}
 
void ob()
{
         int n,a[6],i=0,t=0;
         clrscr();
         printf("Convertion from Octal to Binary.\n");
         printf("Enter an Octal Number.\n");
         scanf("%d",&n);
         while(n!=0)
         {
          a[i]=n%10;
          n=n/10;
          if(a[i]>7)
           t=1;
          i++;
         }
         i--;
         if(t==0)
          for(;i>=0;i--)
          {
           switch(a[i])
           {
            case 0:
             printf("000");
             break;
            case 1:
             printf("001");
             break;
            case 2:
             printf("010");
             break;
            case 3:
             printf("011");
             break;
            case 4:
             printf("100");
             break;
            case 5:
             printf("101");
             break;
            case 6:
             printf("110");
             break;
            case 7:
             printf("111");
             break;
           }
          }
         if(t==1)
          printf("Not a Octal number\n");
}
 
void bo()
{
         int i=0,a[5],t=0;
         long int n;
         clrscr();
         printf("Convertion From Binary to Octal\n");
         printf("Enter a Binary number\n");
         scanf("%ld",&n);
         while(n!=0)
         {
          a[i]=n%1000;
          n=n/1000;
          if(a[i]>111)
           t=1;
          i++;
         }
         i--;
         if(t==0)
          for(;i>=0;i--)
          {
           switch(a[i])
           {
            case 0:
             printf("0");
             break;
            case 1:
             printf("1");
             break;
            case 10:
             printf("2");
             break;
            case 11:
             printf("3");
             break;
            case 100:
             printf("4");
             break;
            case 101:
             printf("5");
             break;
            case 110:
             printf("6");
             break;
            case 111:
             printf("7");
             break;
            default:
   printf("\nEntered number is not binary.\nPrinted value is not correct.\n");
             break;
           }
          }
         if(t==1)
          printf("Number is not Binary\n");
}
 
void bh()
{
         int i=0,a[5],t=0;
         long int n;
         clrscr();
         printf("Convertion from Binary to Hexadecimal\n");
         printf("Enter a Binary number\n");
         scanf("%ld",&n);
         while(n!=0)
         {
          a[i]=n%10000;
          n=n/10000;
          if(a[i]>1111)
           t=1;
          i++;
         }
         i--;
         if(t==0)
          for(;i>=0;i--)
          {
           switch(a[i])
           {
            case 0:
             printf("0");
             break;
            case 1:
             printf("1");
             break;
            case 10:
             printf("2");
             break;
            case 11:
             printf("3");
             break;
            case 100:
             printf("4");
             break;
            case 101:
             printf("5");
             break;
            case 110:
             printf("6");
             break;
            case 111:
             printf("7");
             break;
            case 1000:
             printf("8");
             break;
            case 1001:
             printf("9");
             break;
            case 1010:
             printf("A");
             break;
            case 1011:
             printf("B");
             break;
            case 1100:
             printf("C");
             break;
            case 1101:
             printf("D");
             break;
            case 1110:
             printf("E");
             break;
            case 1111:
             printf("F");
             break;
            default:
     printf("\nEntered number is not binary.\nPrinted value is not correct.\n");
             break;
           }
          }
         if(t==1)
          printf("Number is not Binary\n");
}
 
void hb()
{
         int i;
         char s[20];
         clrscr();
         printf("Convertion from Hexadecimal to Binary\n");
         printf("Enter a Hexadecimal number\n");
         scanf("%s",s);
         //gets(s);
         printf("Binary Equivalent=");
         for(i=0;s[i]!=NULL;i++)
         {
          switch(s[i])
           {
            case '0':
             printf("0000");
             break;
            case '1':
             printf("0001");
             break;
            case '2':
             printf("0010");
             break;
            case '3':
             printf("0011");
             break;
            case '4':
             printf("0100");
             break;
            case '5':
             printf("0101");
             break;
            case '6':
             printf("0110");
             break;
            case '7':
             printf("0111");
             break;
            case '8':
             printf("1000");
             break;
            case '9':
             printf("1001");
             break;
            case 'a':
            case 'A':
             printf("1010");
             break;
            case 'b':
            case 'B':
             printf("1011");
             break;
            case 'c':
            case 'C':
             printf("1100");
             break;
            case 'd':
            case 'D':
             printf("1101");
             break;
            case 'e':
            case 'E':
             printf("1110");
             break;
            case 'f':
            case 'F':
             printf("1111");
             break;
            default:
       printf("\nEntered number is not Hexadecimal.\nPrinted value is not correct.\n");
             break;
           }
          }
}
 
void hd()
{
         int i,a[20];
         unsigned long int h=0,m=1;
         char s[20];
         clrscr();
         printf("Convertion from Hexadecimal to Decimal\n");
         printf("Enter a Hexadecimal number\n");
         scanf("%s",s);
         printf("Decimal Equivalent=");
         for(i=0;s[i]!=NULL;i++)
         {
          switch(s[i])
           {
            case '0':
             a[i]=0;
             break;
            case '1':
             a[i]=1;
             break;
            case '2':
             a[i]=2;
             break;
            case '3':
             a[i]=3;
             break;
            case '4':
             a[i]=4;
             break;
            case '5':
             a[i]=5;
             break;
            case '6':
             a[i]=6;
             break;
            case '7':
             a[i]=7;
             break;
            case '8':
             a[i]=8;
             break;
            case '9':
             a[i]=9;
             break;
            case 'a':
            case 'A':
             a[i]=10;
             break;
            case 'b':
            case 'B':
             a[i]=11;
             break;
            case 'c':
            case 'C':
             a[i]=12;
             break;
            case 'd':
            case 'D':
             a[i]=13;
             break;
            case 'e':
            case 'E':
             a[i]=14;
             break;
            case 'f':
            case 'F':
             a[i]=15;
             break;
            default:
    printf("\nEntered number is not Hexadecimal.\nPrinted value is not correct.\n");
             break;
           }
         }
         i--;
         for(;i>=0;i--)
         {
          h=h+a[i]*m;
          m=m*16;
         }
          printf("%ld ",h);
}
 
void oh(long n)
{
         long i;
         if(n>0)
         {
          i=n%16;
          n=n/16;
          oh(n);
          if(i>=10)
          {
           switch(i)
           {
            case 10:
             printf("A");
             break;
            case 11:
             printf("B");
             break;
            case 12:
             printf("C");
             break;
            case 13:
             printf("D");
             break;
            case 14:
             printf("E");
             break;
            case 15:
             printf("F");
             break;
           }
          }
          else
           printf("%ld",i);
         }
}
 
void ho()
{
         int i,a[20];
         unsigned long int h=0,m=1;
         char s[20];
         clrscr();
         printf("Convertion from Hexadecimal to Octal\n");
         printf("Enter a Hexadecimal number\n");
         scanf("%s",s);
         // Converting hex to dec first
         for(i=0;s[i]!=NULL;i++)
         {
          switch(s[i])
           {
            case '0':
             a[i]=0;
             break;
            case '1':
             a[i]=1;
             break;
            case '2':
             a[i]=2;
             break;
            case '3':
             a[i]=3;
             break;
            case '4':
             a[i]=4;
             break;
            case '5':
             a[i]=5;
             break;
            case '6':
             a[i]=6;
             break;
            case '7':
             a[i]=7;
             break;
            case '8':
             a[i]=8;
             break;
            case '9':
             a[i]=9;
             break;
            case 'a':
            case 'A':
             a[i]=10;
             break;
            case 'b':
            case 'B':
             a[i]=11;
             break;
            case 'c':
            case 'C':
             a[i]=12;
             break;
            case 'd':
            case 'D':
             a[i]=13;
             break;
            case 'e':
            case 'E':
             a[i]=14;
             break;
            case 'f':
            case 'F':
             a[i]=15;
             break;
            default:
      printf("\nEntered number is not Hexadecimal.\nPrinted value is not correct.\n");
             break;
           }
         }
         i--;
         for(;i>=0;i--)
         {
          h=h+a[i]*m;
          m=m*16;
         }
         // Now convering from decimal to octal (h)
         i=0;
         printf("Octal equavalent=");
         while(h!=0)
         {
          a[i]=h%8;
          h=h/8;
          i++;
         }
         i--;
         for(;i>=0;i--)
          printf("%d",a[i]);
}*/
 

Rev 1008	Rev 1011
1		1
2	#include <string>	2	#include <string>
3		3
4	/***************************************************************************	4	/***************************************************************************
5	* Copyright (C) 2004 by Mattias Runge *	5	* Copyright (C) 2004 by Mattias Runge *
6	* mattias@mrunge.se *	6	* mattias@mrunge.se *
7	* *	7	* *
8	* This program is free software; you can redistribute it and/or modify *	8	* This program is free software; you can redistribute it and/or modify *
9	* it under the terms of the GNU General Public License as published by *	9	* it under the terms of the GNU General Public License as published by *
10	* the Free Software Foundation; either version 2 of the License, or *	10	* the Free Software Foundation; either version 2 of the License, or *
11	* (at your option) any later version. *	11	* (at your option) any later version. *
12	* *	12	* *
13	* This program is distributed in the hope that it will be useful, *	13	* This program is distributed in the hope that it will be useful, *
14	* but WITHOUT ANY WARRANTY; without even the implied warranty of *	14	* but WITHOUT ANY WARRANTY; without even the implied warranty of *
15	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *	15	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *
16	* GNU General Public License for more details. *	16	* GNU General Public License for more details. *
17	* *	17	* *
18	* You should have received a copy of the GNU General Public License *	18	* You should have received a copy of the GNU General Public License *
19	* along with this program; if not, write to the *	19	* along with this program; if not, write to the *
20	* Free Software Foundation, Inc., *	20	* Free Software Foundation, Inc., *
21	* 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. *	21	* 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. *
22	***************************************************************************/	22	***************************************************************************/
23	#include "tools.h"	23	#include "tools.h"
24		24
25	string niceTime()	25	string niceTime()
26	{	26	{
27	string result;	27	string result;
28	struct tm tmStruct;	28	struct tm tmStruct;
29	time_t t = time(NULL);	29	time_t t = time(NULL);
30	localtime_r(&t, &tmStruct);	30	localtime_r(&t, &tmStruct);
31		31
32	result += lpad(itos(tmStruct.tm_hour), 2, '0');	32	result += lpad(itos(tmStruct.tm_hour), 2, '0');
33	result += ":";	33	result += ":";
34	result += lpad(itos(tmStruct.tm_min), 2, '0');	34	result += lpad(itos(tmStruct.tm_min), 2, '0');
35	result += ":";	35	result += ":";
36	result += lpad(itos(tmStruct.tm_sec), 2, '0');	36	result += lpad(itos(tmStruct.tm_sec), 2, '0');
37		37
38	return result;	38	return result;
-		39	}
-		40
-		41	unsigned int hex2uint(string hex)
-		42	{
-		43	return bin2uint(hex2bin(hex));
39	}	44	}
40		45
41	unsigned int bin2uint(string bin)	46	unsigned int bin2uint(string bin)
42	{	47	{
43	unsigned int num = 0;	48	unsigned int num = 0;
44		49
45	for (int n = bin.length()-1; n >= 0; n--)	50	for (int n = bin.length()-1; n >= 0; n--)
46	{	51	{
47	if (bin[n] == '1')	52	if (bin[n] == '1')
48	num += (unsigned int)pow(2.0f, (int)(bin.length()-1-n));	53	num += (unsigned int)pow(2.0f, (int)(bin.length()-1-n));
49	}	54	}
50		55
51	return num;	56	return num;
52	}	57	}
53		58
54	string invert(string bin)	59	string invert(string bin)
55	{	60	{
56	string inverted;	61	string inverted;
57		62
58	for (int n = 0; n < bin.length(); n++)	63	for (int n = 0; n < bin.length(); n++)
59	inverted += (bin[n] == '1' ? '0' : '1');	64	inverted += (bin[n] == '1' ? '0' : '1');
60		65
61	return inverted;	66	return inverted;
62	}	67	}
63		68
64	float bin2float(string bin)	69	float bin2float(string bin)
65	{	70	{
66	float num = 0;	71	float num = 0;
67		72
68	if (bin.length() == 0)	73	if (bin.length() == 0)
69	return 0.0f;	74	return 0.0f;
70		75
71	bool isNegative = false;;	76	bool isNegative = false;;
72		77
73	if (bin[0] == '1')	78	if (bin[0] == '1')
74	{	79	{
75	bin = invert(bin);	80	bin = invert(bin);
76	isNegative = true;	81	isNegative = true;
77	}	82	}
78		83
79	for (int n = bin.length()-1; n > 0; n--)	84	for (int n = bin.length()-1; n > 0; n--)
80	{	85	{
81	if (bin[n] == '1')	86	if (bin[n] == '1')
82	num += pow(2.0f, (int)(bin.length()-1-n));	87	num += pow(2.0f, (int)(bin.length()-1-n));
83	}	88	}
84		89
85	num /= 64.0f;	90	num /= 64.0f;
86		91
87	if (isNegative)	92	if (isNegative)
88	num = -num;	93	num = -num;
89		94
90	return num;	95	return num;
91	}	96	}
92		97
93	string bin2hex(string bin)	98	string bin2hex(string bin)
94	{	99	{
95	string hex;	100	string hex;
96		101
97	while (bin.size() > 0)	102	while (bin.size() > 0)
98	{	103	{
99	string part;	104	string part;
100		105
101	try	106	try
102	{	107	{
103	part = bin.substr(0, 4);	108	part = bin.substr(0, 4);
104	}	109	}
105	catch (std::out_of_range& e)	110	catch (std::out_of_range& e)
106	{	111	{
107	cout << "DEBUG: bin2hex exception: " << e.what() << "\n";	112	cout << "DEBUG: bin2hex exception: " << e.what() << "\n";
108	cout << "DEBUG: A bin=" << bin << endl;	113	cout << "DEBUG: A bin=" << bin << endl;
109	continue;	114	continue;
110	}	115	}
111		116
112	bin.erase(0, part.size());	117	bin.erase(0, part.size());
113		118
114	while (part.size() < 4)	119	while (part.size() < 4)
115	part = "0" + part;	120	part = "0" + part;
116		121
117	if (part == "0000")	122	if (part == "0000")
118	hex += '0';	123	hex += '0';
119	else if (part == "0001")	124	else if (part == "0001")
120	hex += '1';	125	hex += '1';
121	else if (part == "0010")	126	else if (part == "0010")
122	hex += '2';	127	hex += '2';
123	else if (part == "0011")	128	else if (part == "0011")
124	hex += '3';	129	hex += '3';
125	else if (part == "0100")	130	else if (part == "0100")
126	hex += '4';	131	hex += '4';
127	else if (part == "0101")	132	else if (part == "0101")
128	hex += '5';	133	hex += '5';
129	else if (part == "0110")	134	else if (part == "0110")
130	hex += '6';	135	hex += '6';
131	else if (part == "0111")	136	else if (part == "0111")
132	hex += '7';	137	hex += '7';
133	else if (part == "1000")	138	else if (part == "1000")
134	hex += '8';	139	hex += '8';
135	else if (part == "1001")	140	else if (part == "1001")
136	hex += '9';	141	hex += '9';
137	else if (part == "1010")	142	else if (part == "1010")
138	hex += 'a';	143	hex += 'a';
139	else if (part == "1011")	144	else if (part == "1011")
140	hex += 'b';	145	hex += 'b';
141	else if (part == "1100")	146	else if (part == "1100")
142	hex += 'c';	147	hex += 'c';
143	else if (part == "1101")	148	else if (part == "1101")
144	hex += 'd';	149	hex += 'd';
145	else if (part == "1110")	150	else if (part == "1110")
146	hex += 'e';	151	hex += 'e';
147	else if (part == "1111")	152	else if (part == "1111")
148	hex += 'f';	153	hex += 'f';
149	}	154	}
150		155
151	return hex;	156	return hex;
152	}	157	}
153		158
154	string float2bin(float num, int length)	159	string float2bin(float num, int length)
155	{	160	{
156	string bin;	161	string bin;
157		162
158	///FIXME	163	///FIXME
159		164
160	while (bin.size() < length)	165	while (bin.size() < length)
161	bin = "0" + bin;	166	bin = "0" + bin;
162		167
163	return bin;	168	return bin;
164	}	169	}
165		170
166	string hex2bin(string hex)	171	string hex2bin(string hex)
167	{	172	{
168	hex = strtolower(hex);	173	hex = strtolower(hex);
169		174
170	string bin;	175	string bin;
171		176
172	for (int n = 0; n < hex.length(); n++)	177	for (int n = 0; n < hex.length(); n++)
173	{	178	{
174	switch (hex[n])	179	switch (hex[n])
175	{	180	{
176	case '0': bin += "0000"; break;	181	case '0': bin += "0000"; break;
177	case '1': bin += "0001"; break;	182	case '1': bin += "0001"; break;
178	case '2': bin += "0010"; break;	183	case '2': bin += "0010"; break;
179	case '3': bin += "0011"; break;	184	case '3': bin += "0011"; break;
180	case '4': bin += "0100"; break;	185	case '4': bin += "0100"; break;
181	case '5': bin += "0101"; break;	186	case '5': bin += "0101"; break;
182	case '6': bin += "0110"; break;	187	case '6': bin += "0110"; break;
183	case '7': bin += "0111"; break;	188	case '7': bin += "0111"; break;
184	case '8': bin += "1000"; break;	189	case '8': bin += "1000"; break;
185	case '9': bin += "1001"; break;	190	case '9': bin += "1001"; break;
186	case 'a': bin += "1010"; break;	191	case 'a': bin += "1010"; break;
187	case 'b': bin += "1011"; break;	192	case 'b': bin += "1011"; break;
188	case 'c': bin += "1100"; break;	193	case 'c': bin += "1100"; break;
189	case 'd': bin += "1101"; break;	194	case 'd': bin += "1101"; break;
190	case 'e': bin += "1110"; break;	195	case 'e': bin += "1110"; break;
191	case 'f': bin += "1111"; break;	196	case 'f': bin += "1111"; break;
192	}	197	}
193	}	198	}
194		199
195	return bin;	200	return bin;
196	}	201	}
197		202
198	string uint2bin(unsigned int num, int length)	203	string uint2bin(unsigned int num, int length)
199	{	204	{
200	string bin;	205	string bin;
201		206
202	while (num)	207	while (num)
203	{	208	{
204	bin = char((num&1)+'0') + bin;	209	bin = char((num&1)+'0') + bin;
205	num >>= 1;	210	num >>= 1;
206	}	211	}
207		212
208	while (bin.size() < length)	213	while (bin.size() < length)
209	bin = "0" + bin;	214	bin = "0" + bin;
210		215
211	return bin;	216	return bin;
212	}	217	}
213		218
214	string uint2hex(unsigned int num, int length)	219	string uint2hex(unsigned int num, int length)
215	{	220	{
216	return bin2hex(uint2bin(num, length));	221	return bin2hex(uint2bin(num, length));
217	}	222	}
218		223
219	vector<string> explode(string delimiter, string str)	224	vector<string> explode(string delimiter, string str)
220	{	225	{
221	vector<string> parts;	226	vector<string> parts;
222	string::size_type startPos = 0;	227	string::size_type startPos = 0;
223	string::size_type endPos = 0;	228	string::size_type endPos = 0;
224		229
225	while ((endPos = str.find(delimiter, startPos)) != string::npos)	230	while ((endPos = str.find(delimiter, startPos)) != string::npos)
226	{	231	{
227	try	232	try
228	{	233	{
229	parts.push_back(str.substr(startPos, endPos-startPos));	234	parts.push_back(str.substr(startPos, endPos-startPos));
230	}	235	}
231	catch (std::out_of_range& e)	236	catch (std::out_of_range& e)
232	{	237	{
233	cout << "DEBUG: explode exception: " << e.what() << "\n";	238	cout << "DEBUG: explode exception: " << e.what() << "\n";
234	cout << "DEBUG: A str=" << str << " :: startPos=" << startPos << " :: endPos=" << endPos << endl;	239	cout << "DEBUG: A str=" << str << " :: startPos=" << startPos << " :: endPos=" << endPos << endl;
235	continue;	240	continue;
236	}	241	}
237		242
238	startPos = endPos+delimiter.length();	243	startPos = endPos+delimiter.length();
239	}	244	}
240		245
241	if (startPos < str.length())	246	if (startPos < str.length())
242	{	247	{
243	try	248	try
244	{	249	{
245	parts.push_back(str.substr(startPos, str.length()-startPos));	250	parts.push_back(str.substr(startPos, str.length()-startPos));
246	}	251	}
247	catch (std::out_of_range& e)	252	catch (std::out_of_range& e)
248	{	253	{
249	cout << "DEBUG: explode exception: " << e.what() << "\n";	254	cout << "DEBUG: explode exception: " << e.what() << "\n";
250	cout << "DEBUG: B str=" << str << " :: startPos=" << startPos << " :: endPos=" << endPos << endl;	255	cout << "DEBUG: B str=" << str << " :: startPos=" << startPos << " :: endPos=" << endPos << endl;
251	}	256	}
252	}	257	}
253		258
254	return parts;	259	return parts;
255	}	260	}
256		261
257	string strtoupper(string s)	262	string strtoupper(string s)
258	{	263	{
259	for (unsigned int n = 0; n < s.size(); n++)	264	for (unsigned int n = 0; n < s.size(); n++)
260	s[n] = (char)toupper(s[n]);	265	s[n] = (char)toupper(s[n]);
261		266
262	return s;	267	return s;
263	}	268	}
264		269
265	string strtolower(string s)	270	string strtolower(string s)
266	{	271	{
267	for (unsigned int n = 0; n < s.size(); n++)	272	for (unsigned int n = 0; n < s.size(); n++)
268	s[n] = (char)tolower(s[n]);	273	s[n] = (char)tolower(s[n]);
269		274
270	return s;	275	return s;
271	}	276	}
272		277
273	string trim(string s)	278	string trim(string s)
274	{	279	{
275	return trim(s, ' ');	280	return trim(s, ' ');
276	}	281	}
277		282
278	string trim(const string s, char c)	283	string trim(const string s, char c)
279	{	284	{
280	string result = s;	285	string result = s;
281	while (result[0] == c)	286	while (result[0] == c)
282	result.erase(0, 1);	287	result.erase(0, 1);
283		288
284	while (result[result.length()-1] == c)	289	while (result[result.length()-1] == c)
285	result.erase(result.length()-1, 1);	290	result.erase(result.length()-1, 1);
286		291
287	return result;	292	return result;
288	}	293	}
289		294
290	int stoi(const string s)	295	int stoi(const string s)
291	{	296	{
292	istringstream in(s);	297	istringstream in(s);
293	int i;	298	int i;
294	in >> i;	299	in >> i;
295	return i;	300	return i;
296	}	301	}
297		302
298	string itos(int i)	303	string itos(int i)
299	{	304	{
300	ostringstream out;	305	ostringstream out;
301	out << i;	306	out << i;
302	return out.str();	307	return out.str();
303	}	308	}
304		309
305	unsigned int stou(const string s)	310	unsigned int stou(const string s)
306	{	311	{
307	istringstream in(s);	312	istringstream in(s);
308	unsigned int i;	313	unsigned int i;
309	in >> i;	314	in >> i;
310	return i;	315	return i;
311	}	316	}
312		317
313	string utos(unsigned int i)	318	string utos(unsigned int i)
314	{	319	{
315	ostringstream out;	320	ostringstream out;
316	out << i;	321	out << i;
317	return out.str();	322	return out.str();
318	}	323	}
319		324
320	float stof(const string s)	325	float stof(const string s)
321	{	326	{
322	istringstream in(s);	327	istringstream in(s);
323	float f;	328	float f;
324	in >> f;	329	in >> f;
325	return f;	330	return f;
326	}	331	}
327		332
328	string ftos(float f)	333	string ftos(float f)
329	{	334	{
330	ostringstream out;	335	ostringstream out;
331	out << f;	336	out << f;
332	return out.str();	337	return out.str();
333	}	338	}
334		339
335	string str_replace(string search, string replace, string str)	340	string str_replace(string search, string replace, string str)
336	{	341	{
337	vector<string> parts = explode(search, str);	342	vector<string> parts = explode(search, str);
338		343
339	string result;	344	string result;
340	for (int n = 0; n < parts.size(); n++)	345	for (int n = 0; n < parts.size(); n++)
341	{	346	{
342	result += parts[n];	347	result += parts[n];
343		348
344	if (n < parts.size()-1)	349	if (n < parts.size()-1)
345	result += replace;	350	result += replace;
346	}	351	}
347		352
348	return result;	353	return result;
349	}	354	}
350		355
351	string file_get_contents(string filename)	356	string file_get_contents(string filename)
352	{	357	{
353	ifstream srcfile(filename.c_str());	358	ifstream srcfile(filename.c_str());
354		359
355	if (!srcfile.is_open())	360	if (!srcfile.is_open())
356	{	361	{
357	srcfile.close();	362	srcfile.close();
358	return "";	363	return "";
359	}	364	}
360		365
361	string buffer = "";	366	string buffer = "";
362	string line;	367	string line;
363		368
364	while (!srcfile.eof())	369	while (!srcfile.eof())
365	{	370	{
366	getline(srcfile, line);	371	getline(srcfile, line);
367		372
368	if (srcfile.eof())	373	if (srcfile.eof())
369	break;	374	break;
370		375
371	buffer += line + "\n";	376	buffer += line + "\n";
372	};	377	};
373		378
374	srcfile.close();	379	srcfile.close();
375		380
376	return buffer;	381	return buffer;
377	}	382	}
378		383
379	bool file_exists(string filename)	384	bool file_exists(string filename)
380	{	385	{
381	ifstream file(filename.c_str());	386	ifstream file(filename.c_str());
382	if (file.is_open())	387	if (file.is_open())
383	{	388	{
384	file.close();	389	file.close();
385	return true;	390	return true;
386	}	391	}
387		392
388	return false;	393	return false;
389	}	394	}
390		395
391	string escape(string in)	396	string escape(string in)
392	{	397	{
393	string out;	398	string out;
394		399
395	for (int n = 0; n < in.length(); n++)	400	for (int n = 0; n < in.length(); n++)
396	{	401	{
397	switch (in[n])	402	switch (in[n])
398	{	403	{
399	case '\r':	404	case '\r':
400	break;	405	break;
401		406
402	case '\n':	407	case '\n':
403	out += "\\n";	408	out += "\\n";
404	break;	409	break;
405		410
406	case '\'':	411	case '\'':
407	out += "\\'";	412	out += "\\'";
408	break;	413	break;
409		414
410	case '"':	415	case '"':
411	out += "\\\"";	416	out += "\\\"";
412	break;	417	break;
413		418
414	default:	419	default:
415	out += in[n];	420	out += in[n];
416	break;	421	break;
417	}	422	}
418	}	423	}
419		424
420	return out;	425	return out;
421	}	426	}
422		427
423	string rpad(string in, int length, char c)	428	string rpad(string in, int length, char c)
424	{	429	{
425	while (in.length() < length)	430	while (in.length() < length)
426	{	431	{
427	in += c;	432	in += c;
428	}	433	}
429		434
430	return in;	435	return in;
431	}	436	}
432		437
433	string lpad(string in, int length, char c)	438	string lpad(string in, int length, char c)
434	{	439	{
435	while (in.length() < length)	440	while (in.length() < length)
436	{	441	{
437	in = c + in;	442	in = c + in;
438	}	443	}
439		444
440	return in;	445	return in;
441	}	446	}
442		447
443		448
444	// FileTools	449	// FileTools
445		450
446	vector<string> FileTools::GetDirList(string path)	451	vector<string> FileTools::GetDirList(string path)
447	{	452	{
448	DIR *dir = opendir(path.c_str());	453	DIR *dir = opendir(path.c_str());
449	vector<string> list;	454	vector<string> list;
450		455
451	if (!dir)	456	if (!dir)
452	return list;	457	return list;
453		458
454	dirent *d;	459	dirent *d;
455	while ((d = readdir(dir)))	460	while ((d = readdir(dir)))
456	{	461	{
457	if (d->d_name[0] == '.')	462	if (d->d_name[0] == '.')
458	continue;	463	continue;
459		464
460	list.push_back(d->d_name);	465	list.push_back(d->d_name);
461	}	466	}
462	closedir(dir);	467	closedir(dir);
463		468
464	return list;	469	return list;
465	}	470	}
466		471
467	string FileTools::GetUniqeFilename(string path, string prefix, string postfix)	472	string FileTools::GetUniqeFilename(string path, string prefix, string postfix)
468	{	473	{
469	time_t now;	474	time_t now;
470	time(&now);	475	time(&now);
471		476
472	string filename = path + prefix + itos(now);	477	string filename = path + prefix + itos(now);
473		478
474	int index = 0;	479	int index = 0;
475	while (1)	480	while (1)
476	{	481	{
477	string file = filename + itos(index) + postfix;	482	string file = filename + itos(index) + postfix;
478	if (!Exist(file))	483	if (!Exist(file))
479	break;	484	break;
480	index++;	485	index++;
481	}	486	}
482		487
483	filename += itos(index) + postfix;	488	filename += itos(index) + postfix;
484		489
485	return filename;	490	return filename;
486	}	491	}
487		492
488	bool FileTools::SaveFile(string filepath, string data)	493	bool FileTools::SaveFile(string filepath, string data)
489	{	494	{
490	ofstream destfile(filepath.c_str());	495	ofstream destfile(filepath.c_str());
491	if (!destfile.is_open())	496	if (!destfile.is_open())
492	{	497	{
493	destfile.close();	498	destfile.close();
494	return false;	499	return false;
495	}	500	}

Subversion Repositories HomeAutomation

(root)/trunk/PcSoftware/Atom/Tools/tools.cpp @ 1011 – Rev 1008 → 1011