projects/smsdaemon/util.cpp


#include <string>
#include <sstream>
#include <vector>
#include <cctype>

#include <iostream>
#include <fstream>
#include <iconv.h>

#include <time.h>

#include "util.h"

using namespace std;

namespace Util
{
        void str_dump(const string& str)
        {
            for (unsigned i=0; i<str.length(); ++i)
            {
                        cout.width(2);
                        cout.fill('0');
                        cout << hex << static_cast<int>(str.at(i)) << " ";
                }
                cout.width(1);
                cout << dec <<  endl;
        }


        string str_replace(string str, string search, string replace)
        {
                unsigned int pos = 0;
                
                while ( (pos = str.find(search,pos)) != string::npos)
                {
                        str.replace(pos, search.size(), replace);
                        pos += replace.size();
                }
                return str;
        }

    std::string str_replace_char(std::string str, char search, char replace)
        {
                unsigned int pos = 0;

                while ( (pos = str.find(search,pos)) != string::npos)
                {
                        str.replace(pos, 1, 1, replace);
                }
                return str;
        }

        
        string str_trim(string str)
        {
                while (str.length() > 0 && isspace(str.at(0)))
                        str.erase(0,1);
                while (str.length() > 0 && isspace(str.at(str.length()-1)))
                        str.erase(str.length()-1,1);
                return str;
        }

        string str_striptags(string str)
        {
                unsigned int pos=0;

                while ( (pos=str.find("<",pos)) != string::npos)
                {
                        unsigned int endpos = str.find(">",pos);
                        if (endpos == string::npos)
                                break;
                        str.erase(pos, (endpos-pos)+1);
                }

                return str;
        }

        vector<string> str_split(string input, string delimiter)
        {
        vector<string> retval;

                while ( 1 )
                {
                        unsigned int endpos = input.find(delimiter);

                        string entry = input.substr(0,endpos);
                        retval.push_back( entry );


                        if (endpos == string::npos)
                                break;

                        endpos += delimiter.length();
                        input = input.substr(endpos, input.length() - endpos);
                }

                return retval;
        }

        string str_characters(string str)
        {
                string rep;
                rep.append(1,197);
                str = str_replace(str, "&#197;", rep);

                rep.at(0) = 198;
                str = str_replace(str, "&#198;", rep);

                rep.at(0) = 216;
                str = str_replace(str, "&#216;", rep);


                rep.at(0) = 229;
                str = str_replace(str, "&#229;", rep);

                rep.at(0) = 230;
                str = str_replace(str, "&#230;", rep);

                rep.at(0) = 248;
                str = str_replace(str, "&#248;", rep);

                return str;
        }


        string str_gsm2latin1(string str)
        {
                str = str_replace_char(str, 0x1c, 198); //AE
                str = str_replace_char(str, 0x0b, 216); //OE
                str = str_replace_char(str, 0x0e, 197); //AA

                str = str_replace_char(str, 0x1d, 230); //ae
                str = str_replace_char(str, 0x0c, 248); //oe
                str = str_replace_char(str, 0x0f, 229); //aa
                return str;
        }

        string readUrl(string url, string tempfile)
        {
                char buf[128000];
                string document;
                
                ostringstream command;
                command << "wget -O " << tempfile << " -o /dev/null \"" << url << "\"";
                system( command.str().c_str() );

                ifstream in( tempfile.c_str() );

                if (!in)
                        return "";

                while (!in.eof() )
                {
                        in.getline(buf,128000-1);
                        document += buf;
                        document += "\n";
                }
                in.close();
                unlink(tempfile.c_str());
                
                return document;
        }

        
        string iconv_wrapper(string _input, string to_format, string from_format)
        {
                char* input,*output,*input_ptr, *output_ptr;
                input = input_ptr = (char*) malloc(_input.size()+1);
                strcpy(input, _input.c_str());
                
                output = output_ptr = (char*) malloc(_input.size()*2);


                unsigned int realinsize,insize,outsize,realsize;
                
                iconv_t icv = iconv_open(to_format.c_str(), from_format.c_str());
                if (icv == (iconv_t)-1)
                {
                        perror(0);
                        return "";
                }

                
                realsize = outsize = _input.size()*2;
                realinsize = insize = _input.size();
                
                iconv(icv,
                                &input_ptr,
                                &insize,
                                &output_ptr,
                                &outsize);


                perror(0);
/*              cout << "len=" << len << endl;
                cout << "outsize=" <<  outsize << endl;
                cout << "realsize=" << realsize << endl;
                cout << "insize=" << insize << endl;
                cout << "realinsize=" << realinsize << endl;*/
                iconv_close(icv);

                string returnstr;
                for (unsigned int i=0; i<realsize - outsize; i++)
                {
                        //cout << i << ":" << (unsigned short) output[i] << "|" << (unsigned short) input[i];
                        //cout << " (" << output[i] << ")" << endl;
                        returnstr += output[i];
                }
            return returnstr;
        }

        std::string convertToUnicode(std::string str)
        {
                return iconv_wrapper(str, "UTF-8", "ISO8859-1");
        }

        std::string convertFromUnicode(std::string str)
        {
                return iconv_wrapper(str, "ISO8859-1", "UTF-8");
        }

        int uTimeDiff(const timeval& then, const timeval& now)
        {
                return ( (now.tv_sec - then.tv_sec)*1000000) + (now.tv_usec-then.tv_usec);
        }

        int mTimeDiff(const timeval& then, const timeval& now)
        {
                return uTimeDiff(then,now) / 1000;
        }

}
1
2	#include <string>
3	#include <sstream>
4	#include <vector>
5	#include <cctype>
6
7	#include <iostream>
8	#include <fstream>
9	#include <iconv.h>
10
11	#include <time.h>
12
13	#include "util.h"
14
15	using namespace std;
16
17	namespace Util
18	{
19	void str_dump(const string& str)
20	{
21	for (unsigned i=0; i<str.length(); ++i)
22	{
23	cout.width(2);
24	cout.fill('0');
25	cout << hex << static_cast<int>(str.at(i)) << " ";
26	}
27	cout.width(1);
28	cout << dec << endl;
29	}
30
31
32
33	string str_replace(string str, string search, string replace)
34	{
35	unsigned int pos = 0;
36
37	while ( (pos = str.find(search,pos)) != string::npos)
38	{
39	str.replace(pos, search.size(), replace);
40	pos += replace.size();
41	}
42	return str;
43	}
44
45	std::string str_replace_char(std::string str, char search, char replace)
46	{
47	unsigned int pos = 0;
48
49	while ( (pos = str.find(search,pos)) != string::npos)
50	{
51	str.replace(pos, 1, 1, replace);
52	}
53	return str;
54	}
55
56
57
58	string str_trim(string str)
59	{
60	while (str.length() > 0 && isspace(str.at(0)))
61	str.erase(0,1);
62	while (str.length() > 0 && isspace(str.at(str.length()-1)))
63	str.erase(str.length()-1,1);
64	return str;
65	}
66
67	string str_striptags(string str)
68	{
69	unsigned int pos=0;
70
71	while ( (pos=str.find("<",pos)) != string::npos)
72	{
73	unsigned int endpos = str.find(">",pos);
74	if (endpos == string::npos)
75	break;
76	str.erase(pos, (endpos-pos)+1);
77	}
78
79	return str;
80	}
81
82	vector<string> str_split(string input, string delimiter)
83	{
84	vector<string> retval;
85
86	while ( 1 )
87	{
88	unsigned int endpos = input.find(delimiter);
89
90	string entry = input.substr(0,endpos);
91	retval.push_back( entry );
92
93
94	if (endpos == string::npos)
95	break;
96
97	endpos += delimiter.length();
98	input = input.substr(endpos, input.length() - endpos);
99	}
100
101	return retval;
102	}
103
104	string str_characters(string str)
105	{
106	string rep;
107	rep.append(1,197);
108	str = str_replace(str, "Å", rep);
109
110	rep.at(0) = 198;
111	str = str_replace(str, "Æ", rep);
112
113	rep.at(0) = 216;
114	str = str_replace(str, "Ø", rep);
115
116
117	rep.at(0) = 229;
118	str = str_replace(str, "å", rep);
119
120	rep.at(0) = 230;
121	str = str_replace(str, "æ", rep);
122
123	rep.at(0) = 248;
124	str = str_replace(str, "ø", rep);
125
126	return str;
127	}
128
129
130	string str_gsm2latin1(string str)
131	{
132	str = str_replace_char(str, 0x1c, 198); //AE
133	str = str_replace_char(str, 0x0b, 216); //OE
134	str = str_replace_char(str, 0x0e, 197); //AA
135
136	str = str_replace_char(str, 0x1d, 230); //ae
137	str = str_replace_char(str, 0x0c, 248); //oe
138	str = str_replace_char(str, 0x0f, 229); //aa
139	return str;
140	}
141
142	string readUrl(string url, string tempfile)
143	{
144	char buf[128000];
145	string document;
146
147	ostringstream command;
148	command << "wget -O " << tempfile << " -o /dev/null \"" << url << "\"";
149	system( command.str().c_str() );
150
151	ifstream in( tempfile.c_str() );
152
153	if (!in)
154	return "";
155
156	while (!in.eof() )
157	{
158	in.getline(buf,128000-1);
159	document += buf;
160	document += "\n";
161	}
162	in.close();
163	unlink(tempfile.c_str());
164
165	return document;
166	}
167
168
169
170	string iconv_wrapper(string _input, string to_format, string from_format)
171	{
172	char* input,output,input_ptr, *output_ptr;
173	input = input_ptr = (char*) malloc(_input.size()+1);
174	strcpy(input, _input.c_str());
175
176	output = output_ptr = (char) malloc(_input.size()2);
177
178
179
180	unsigned int realinsize,insize,outsize,realsize;
181
182	iconv_t icv = iconv_open(to_format.c_str(), from_format.c_str());
183	if (icv == (iconv_t)-1)
184	{
185	perror(0);
186	return "";
187	}
188
189
190	realsize = outsize = _input.size()*2;
191	realinsize = insize = _input.size();
192
193	iconv(icv,
194	&input_ptr,
195	&insize,
196	&output_ptr,
197	&outsize);
198
199
200	perror(0);
201	/* cout << "len=" << len << endl;
202	cout << "outsize=" << outsize << endl;
203	cout << "realsize=" << realsize << endl;
204	cout << "insize=" << insize << endl;
205	cout << "realinsize=" << realinsize << endl;*/
206	iconv_close(icv);
207
208	string returnstr;
209	for (unsigned int i=0; i<realsize - outsize; i++)
210	{
211	//cout << i << ":" << (unsigned short) output[i] << "\|" << (unsigned short) input[i];
212	//cout << " (" << output[i] << ")" << endl;
213	returnstr += output[i];
214	}
215	return returnstr;
216	}
217
218	std::string convertToUnicode(std::string str)
219	{
220	return iconv_wrapper(str, "UTF-8", "ISO8859-1");
221	}
222
223	std::string convertFromUnicode(std::string str)
224	{
225	return iconv_wrapper(str, "ISO8859-1", "UTF-8");
226	}
227
228	int uTimeDiff(const timeval& then, const timeval& now)
229	{
230	return ( (now.tv_sec - then.tv_sec)*1000000) + (now.tv_usec-then.tv_usec);
231	}
232
233	int mTimeDiff(const timeval& then, const timeval& now)
234	{
235	return uTimeDiff(then,now) / 1000;
236	}
237
238	}