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

Subversion Repositories HomeAutomation

(root)/trunk/PcSoftware/Atom/Tools/tools.cpp @ 976 – Rev 969 → 976