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

Subversion Repositories HomeAutomation

(root)/trunk/PcSoftware/Atom/Tools/tools.cpp @ 990 – Rev 981 → 990