StringUtil.cpp
上传用户:lbr_007
上传日期:2019-05-31
资源大小:282k
文件大小:6k
源码类别:

传真(Fax)编程

开发平台:

Visual C++

  1. #include "stdafx.h"
  2. #include <stringutil.h>
  3. #include <vector>
  4. bool StringUtil::StartsWith(std::string& s1, const char * s2)
  5. {
  6. bool result = false;
  7. if (s2)
  8. {
  9. int len1 = s1.length();
  10. int len2 = strlen(s2);
  11. if ((len2 > 0) && (len1 >= len2))
  12. {
  13. const char * ptr1 = s1.c_str();
  14. result = true;
  15. for (int i=0;i<len2;i++){
  16. if (s2[i] != ptr1[i])
  17. {
  18. result = false;
  19. break;
  20. }
  21. }
  22. }
  23. }
  24. return result;
  25. }
  26. bool StringUtil::Equals(std::string& s1, const char * s2)
  27. {
  28. std::string s = s2;
  29. return Equals(s1,s);
  30. }
  31. bool StringUtil::Equals(std::string& s1, std::string& s2)
  32. {
  33. bool result = false;
  34. int len1 = s1.length();
  35. int len2 = s2.length();
  36. if (len1 > 0)
  37. {
  38. if (len1 == len2)
  39. {
  40. const char * ptr1 = s1.c_str();
  41. const char * ptr2 = s2.c_str();
  42. result = true;
  43. for (int i=0;i<len1;i++){
  44. if (ptr1[i] != ptr2[i])
  45. {
  46. result = false;
  47. break;
  48. }
  49. }
  50. }
  51. }
  52. return result;
  53. }
  54. void StringUtil::StripControlCharacters(std::string& s)
  55. {
  56. std::string result;
  57. int len = s.length();
  58. char c;
  59. for (int i=0;i<len;i++){
  60. c = s.c_str()[i];
  61. if (c >= 32)
  62. {
  63. result += c;
  64. }
  65. }
  66. s = result;
  67. }
  68. void StringUtil::Uppercase(std::string& s)
  69. {
  70. std::string result;
  71. int len = s.length();
  72. char c;
  73. for (int i=0;i<len;i++){
  74. c = s.c_str()[i];
  75. if ((c > 96) && (c < 123))
  76. {
  77. c -= 32;
  78. }
  79. result += c;
  80. }
  81. s = result;
  82. }
  83. int StringUtil::CompareNoCaseOrSpace(std::string& s1, std::string& s2)
  84. {
  85. int result = 0;
  86. std::string tmp1 = s1;
  87. std::string tmp2 = s2;
  88. StripSpaces(tmp1);
  89. StripSpaces(tmp2);
  90. if (CalculateHashNumber(tmp1) == CalculateHashNumber(tmp2))
  91. {
  92. if (tmp1 == tmp2)
  93. {
  94. result++;
  95. }
  96. }
  97. return result;
  98. }
  99. int StringUtil::CalculateHashNumber(std::string& s)
  100. {
  101. int result = 0;
  102. int length = s.length();
  103. if (length > 0)
  104. {
  105. const char * cptr = s.c_str();
  106. char c;
  107. for (int i=0;i<length;i++){
  108. c = cptr[i];
  109. // we want this to be case insensitive
  110. if ((c > 96) && (c < 123))
  111. {
  112. c -= 32;
  113. }
  114. result += (int)c;
  115. }
  116. }
  117. return result;
  118. }
  119. UINT32 StringUtil::DecodeIPAddress(std::string& s)
  120. {
  121. UINT32 result = 0;
  122. std::string stmp = s;
  123. int length = stmp.length();
  124. const char * cptr = stmp.c_str();
  125. int i;
  126. char c;
  127. std::string tmp;
  128. int non_num = 0;
  129. int num = 0;
  130. std::vector<UINT32> numbers;
  131. for (i=0;i<length;i++){
  132. c = cptr[i];
  133. if (c == '.')
  134. {
  135. if (tmp.length() > 0)
  136. {
  137. if (IsIntNumber(tmp))
  138. {
  139. num++;
  140. UINT32 u = atoi(tmp.c_str());
  141. numbers.push_back(u);
  142. }
  143. else
  144. {
  145. non_num++;
  146. }
  147. }
  148. else
  149. {
  150. break;
  151. }
  152. }
  153. else
  154. {
  155. tmp += c;
  156. }
  157. }
  158. int size = numbers.size();
  159. if (size == 4)
  160. {
  161. UINT32 a = numbers[0];
  162. UINT32 b = numbers[1];
  163. UINT32 c = numbers[2];
  164. UINT32 d = numbers[4];
  165. result = (d << 24) | (c << 16) | (b << 8) | a;
  166. }
  167. return result;
  168. }
  169. int StringUtil::IsIPAddress(std::string& s)
  170. {
  171. int result = 0;
  172. std::string stmp = s;
  173. StripSpaces(stmp);
  174. std::string tmp;
  175. int length = stmp.length();
  176. const char * cptr = stmp.c_str();
  177. int i;
  178. int non_num = 0;
  179. int num = 0;
  180. char c;
  181. for (i=0;i<length;i++){
  182. c = cptr[i];
  183. if (c == '.')
  184. {
  185. if (tmp.length() > 0)
  186. {
  187. if (IsIntNumber(tmp))
  188. {
  189. num++;
  190. }
  191. else
  192. {
  193. non_num++;
  194. }
  195. tmp = "";
  196. }
  197. else
  198. {
  199. break;
  200. }
  201. }
  202. else
  203. {
  204. tmp += c;
  205. }
  206. }
  207. if ((num == 4) && (non_num == 0))
  208. {
  209. result++;
  210. }
  211. return result;
  212. }
  213. int StringUtil::IsIntNumber(std::string& s)
  214. {
  215. char c;
  216. int ok = 0;
  217. int size = s.length();
  218. const char * cptr = s.c_str();
  219. for (int i=0;i<size;i++){
  220. c = cptr[i];
  221. if (i == 0)
  222. {
  223. if (c == '-')
  224. {
  225. ok++;
  226. }
  227. else if ((c>=48) && (c<=57))
  228. {
  229. ok++;
  230. }
  231. else
  232. {
  233. break;
  234. }
  235. }
  236. else
  237. {
  238. if ((c>=48 && c<=57))
  239. {
  240. }
  241. else
  242. {
  243. ok = 0;
  244. break;
  245. }
  246. }
  247. }
  248. return ok;
  249. }
  250. int StringUtil::IsFloatNumber(std::string& s)
  251. {
  252. char c;
  253. int ok = 0;
  254. int size = s.length();
  255. int got_decimal = 0;
  256. const char * cptr = s.c_str();
  257. for (int i=0;i<size;i++){
  258. c = cptr[i];
  259. if (i == 0)
  260. {
  261. if (c == '.')
  262. {
  263. ok++;
  264. got_decimal++;
  265. }
  266. else if (c == '-')
  267. {
  268. ok++;
  269. }
  270. else if ((c>=48) && (c<=57))
  271. {
  272. ok++;
  273. }
  274. else
  275. {
  276. break;
  277. }
  278. }
  279. else
  280. {
  281. if (c == '.' && !got_decimal)
  282. {
  283. got_decimal++;
  284. }
  285. else if ((c>=48 && c<=57))
  286. {
  287. }
  288. else
  289. {
  290. ok = 0;
  291. break;
  292. }
  293. }
  294. }
  295. return ok;
  296. }
  297. int StringUtil::IsPositiveIntNumber(std::string& s)
  298. {
  299. char c;
  300. int ok = 0;
  301. int size = s.length();
  302. const char * cptr = s.c_str();
  303. for (int i=0;i<size;i++){
  304. c = cptr[i];
  305. if (i == 0)
  306. {
  307. if ((c>=48) && (c<=57))
  308. {
  309. ok++;
  310. }
  311. else
  312. {
  313. break;
  314. }
  315. }
  316. else
  317. {
  318. if ((c>=48 && c<=57))
  319. {
  320. }
  321. else
  322. {
  323. ok = 0;
  324. break;
  325. }
  326. }
  327. }
  328. return ok;
  329. }
  330. int StringUtil::IsPositiveFloatNumber(std::string& s)
  331. {
  332. char c;
  333. int ok = 0;
  334. int size = s.length();
  335. int got_decimal = 0;
  336. const char * cptr = s.c_str();
  337. for (int i=0;i<size;i++){
  338. c = cptr[i];
  339. if (i == 0)
  340. {
  341. if (c == '.')
  342. {
  343. ok++;
  344. got_decimal++;
  345. }
  346. else if ((c>=48) && (c<=57))
  347. {
  348. ok++;
  349. }
  350. else
  351. {
  352. break;
  353. }
  354. }
  355. else
  356. {
  357. if (c == '.' && !got_decimal)
  358. {
  359. got_decimal++;
  360. }
  361. else if ((c>=48 && c<=57))
  362. {
  363. }
  364. else
  365. {
  366. ok = 0;
  367. break;
  368. }
  369. }
  370. }
  371. return ok;
  372. }
  373. void StringUtil::StripLeadingSpaces(std::string& s)
  374. {
  375. std::string result = "";
  376. const char * ptr = s.c_str();
  377. int length = s.length();
  378. int start = 0;
  379. int i;
  380. char c;
  381. for (i=0;i<length;i++){
  382. c = ptr[i];
  383. if (c != ' ')
  384. {
  385. start = i;
  386. break;
  387. }
  388. }
  389. for (i=start;i<length;i++){
  390. c = ptr[i];
  391. result += c;
  392. }
  393. s = result.c_str();
  394. }
  395. void StringUtil::StripTrailingSpaces(std::string& s)
  396. {
  397. std::string result = "";
  398. const char * ptr = s.c_str();
  399. int length = s.length();
  400. int end = length-1;
  401. int i;
  402. char c;
  403. for (i=end;i>=0;i--){
  404. c = ptr[i];
  405. if (c != ' ')
  406. {
  407. end = i;
  408. break;
  409. }
  410. }
  411. for (i=0;i<=end;i++){
  412. c = ptr[i];
  413. result += c;
  414. }
  415. s = result.c_str();
  416. }
  417. void StringUtil::StripSpaces(std::string& s)
  418. {
  419. StripLeadingSpaces(s);
  420. StripTrailingSpaces(s);
  421. }