Don't like ads? PRO users don't see any ads ;-)
Public Pastes
Guest

Core.String

By: a guest on Jun 21st, 2012  |  syntax: C++  |  size: 12.06 KB  |  hits: 20  |  expires: Never
download  |  raw  |  embed  |  report abuse  |  print
Text below is selected. Please press Ctrl+C to copy to your clipboard. (⌘+C on Mac)
  1. #include "String.h"
  2.  
  3. #include <stdlib.h>
  4. #include <stdio.h>
  5.  
  6. char String::ConversionBuffer[256];
  7. int String::CaseSensitive = true;
  8.  
  9. String::String(const char* pData) {
  10.         for (_Length = 0; pData[_Length] != '\0'; _Length++);
  11.  
  12.         Data = (char*)malloc(_Length + 1);
  13.  
  14.         for (int I = 0; I <= _Length; I++)
  15.                 Data[I] = pData[I];
  16. }
  17.  
  18. String* String::Append(char* Buffer, int Size) {
  19.         char* NewBuffer = (char*)malloc(_Length + Size + 1);
  20.  
  21.         for (int I = 0; I < _Length; I++)
  22.                 NewBuffer[I] = Data[I];
  23.  
  24.         for (int I = 0; I <= Size; I++)
  25.                 NewBuffer[I + _Length] = Buffer[I];
  26.  
  27.         return new String(NewBuffer, _Length + Size);
  28. }
  29.  
  30. String* String::Prepend(char* Buffer, int Size) {
  31.         char* NewBuffer = (char*)malloc(_Length + Size + 1);
  32.  
  33.         for (int I = 0; I < Size; I++)
  34.                 NewBuffer[I] = Buffer[I];
  35.  
  36.         for (int I = 0; I <= _Length; I++)
  37.                 NewBuffer[I + Size] = Data[I];
  38.  
  39.         return new String(NewBuffer, _Length + Size);
  40. }
  41.  
  42. String* String::Append(char* Buffer) {
  43.     int Size;
  44.     for (Size = 0; Buffer[Size]; Size++);
  45.    
  46.     return Append(Size);
  47. }
  48.  
  49. String* String::Prepend(char* Buffer) {
  50.     int Size;
  51.     for (Size = 0; Buffer[Size]; Size++);
  52.    
  53.     return Prepend(Size);
  54. }
  55.  
  56. String* String::Append(String* Other) {
  57.         return Append(Other->Data, Other->_Length);
  58. }
  59.  
  60. String* String::Append(bool Value) {
  61.         int Size = sprintf(ConversionBuffer, "%d", Value);
  62.  
  63.         return Append(ConversionBuffer, Size);
  64. }
  65.  
  66. String* String::Append(int Value) {
  67.         int Size = sprintf(ConversionBuffer, "%d", Value);
  68.  
  69.         return Append(ConversionBuffer, Size);
  70. }
  71.  
  72. String* String::Append(short Value) {
  73.         int Size = sprintf(ConversionBuffer, "%hd", Value);
  74.  
  75.         return Append(ConversionBuffer, Size);
  76. }
  77.  
  78. String* String::Append(long long int Value) {
  79.         int Size = ConvertLongLong(Value);
  80.  
  81.         return Append(ConversionBuffer, Size);
  82. }
  83.  
  84. String* String::Append(size_t Value) {
  85.         return Append((long long int)Value);
  86. }
  87.  
  88. String* String::Append(float Value) {
  89.         int Size = sprintf(ConversionBuffer, "%f", Value);
  90.  
  91.         return Append(ConversionBuffer, Size);
  92. }
  93.  
  94. String* String::Append(double Value) {
  95.         int Size = sprintf(ConversionBuffer, "%f", Value);
  96.  
  97.         return Append(ConversionBuffer, Size);
  98. }
  99.  
  100.  
  101. String* String::Prepend(String* Other) {
  102.         return Prepend(Other->Data, Other->_Length);
  103. }
  104.  
  105. String* String::Prepend(bool Value) {
  106.         int Size = sprintf(ConversionBuffer, "%d", Value);
  107.  
  108.         return Prepend(ConversionBuffer, Size);
  109. }
  110.  
  111. String* String::Prepend(short Value) {
  112.         int Size = sprintf(ConversionBuffer, "%hd", Value);
  113.  
  114.         return Prepend(ConversionBuffer, Size);
  115. }
  116.  
  117. String* String::Prepend(int Value) {
  118.         int Size = sprintf(ConversionBuffer, "%d", Value);
  119.  
  120.         return Prepend(ConversionBuffer, Size);
  121. }
  122.  
  123. String* String::Prepend(long long int Value) {
  124.         int Size = ConvertLongLong(Value);
  125.  
  126.         return Prepend(ConversionBuffer, Size);
  127. }
  128.  
  129. String* String::Prepend(size_t Value) {
  130.         return Prepend((long long int)Value);
  131. }
  132.  
  133. String* String::Prepend(float Value) {
  134.         int Size = sprintf(ConversionBuffer, "%f", Value);
  135.  
  136.         return Prepend(ConversionBuffer, Size);
  137. }
  138.  
  139. String* String::Prepend(double Value) {
  140.         int Size = sprintf(ConversionBuffer, "%f", Value);
  141.  
  142.         return Prepend(ConversionBuffer, Size);
  143. }
  144.  
  145. //Custom lli-to-string routine since sprintf provides no standardized way of doing that
  146. int String::ConvertLongLong(long long int Value) {
  147.         int Sign = 0;
  148.         if (Value < 0) {
  149.                 Sign = 1;
  150.                 Value = -Value;
  151.         }
  152.  
  153.         int Size = 0;
  154.    
  155.     if (Value) {
  156.         while(Value) {
  157.             ConversionBuffer[Size++] = (Value % 10) + '0';
  158.  
  159.             Value /= 10;
  160.         }
  161.     } else
  162.         ConversionBuffer[Size++] = '0';
  163.  
  164.         if (Sign)
  165.                 ConversionBuffer[Size++] = '-';
  166.  
  167.         for (int I = 0; I < Size/2; I++) {
  168.                 char Temp = ConversionBuffer[I];
  169.                 ConversionBuffer[I] = ConversionBuffer[Size - I - 1];
  170.                 ConversionBuffer[Size - I - 1] = Temp;
  171.         }
  172.  
  173.         ConversionBuffer[Size] = '\0';
  174.  
  175.         return Size;
  176. }
  177. String* String::Part(int from, int _to){
  178.         if (from <0){
  179.                 from = 0;
  180.         }
  181.         if (_to > _Length){
  182.                 _to = _Length;
  183.         }
  184.        
  185.         char *buffer = (char*)malloc((_to+1-from)*sizeof(char));
  186.        
  187.         //char *bufferptr = buffer;
  188.         for (int i = 0;i<=_to-from;i++){
  189.                 buffer[i] = Data[from+i];
  190.         }
  191.         buffer[_to-from+1] = 0;
  192.         return new String(buffer);
  193. }
  194.  
  195. int String::Find(String* search, int from){
  196.         if (CaseSensitive==true){
  197.                 for (int i = from;i <=_Length - search->_Length;i++){
  198.                         if (Data[i] == search->Data[0]){
  199.                                 //printf("i: %d\n",i);
  200.                                 int pos = 0;
  201.                                 while (Data[pos+i] == search->Data[pos]){
  202.                                         //printf("source = Data, Pos: %d\n"+pos);
  203.                                         pos++;
  204.                                         if (pos==search->_Length){
  205.                                                 return i;
  206.                                         }
  207.                                 //pos++;       
  208.                                 }
  209.                         }
  210.                 }
  211.         }
  212.         else{
  213.                 String* s = this->ToLower();
  214.                 String* s2 = search->ToLower();
  215.                 for (int i = from;i <=_Length - search->_Length;i++){
  216.                         if (s->Data[i] == s2->Data[0]){
  217.                                 //printf("i: %d\n",i);
  218.                                 int pos = 0;
  219.                                 while (s->Data[pos+i] == s2->Data[pos]){
  220.                                         //printf("source = Data, Pos: %d\n"+pos);
  221.                                         pos++;
  222.                                         if (pos==search->_Length){
  223.                                                 return i;
  224.                                         }
  225.                                 //pos++;       
  226.                                 }
  227.                         }
  228.                 }
  229.                
  230.         }
  231.         return -1;
  232.         //return source.find(search,from);
  233. }
  234.  
  235. int String::FindLast(String* search, int from){
  236.        
  237.         if (CaseSensitive==true){
  238.                 for (int i = _Length - search->_Length;i >= from;i--){
  239.                         if (Data[i] == search->Data[0]){
  240.                                 //printf("i: %d\n",i);
  241.                                 int pos = 0;
  242.                                 while (Data[pos+i] == search->Data[pos]){
  243.                                         //printf("source = Data, Pos: %d\n"+pos);
  244.                                         pos++;
  245.                                         if (pos==search->_Length){
  246.                                                 return i;
  247.                                         }
  248.                                 //pos++;       
  249.                                 }
  250.                         }
  251.                 }
  252.         }
  253.         else{
  254.                 String* s1 = this->ToLower();
  255.                 String* s2 = search->ToLower();
  256.                
  257.                 for (int i = _Length - search->_Length;i >= from;i--){
  258.                         if (s1->Data[i] == s2->Data[0]){
  259.                                 //printf("i: %d\n",i);
  260.                                 int pos = 0;
  261.                                 while (s1->Data[pos+i] == s2->Data[pos]){
  262.                                         //printf("source = Data, Pos: %d\n"+pos);
  263.                                         pos++;
  264.                                         if (pos==search->_Length){
  265.                                                 return i;
  266.                                         }
  267.                                 //pos++;       
  268.                                 }
  269.                         }
  270.                 }
  271.                
  272.         }
  273.         return -1;
  274.         //return source.find(search,from);
  275. }
  276.  
  277. String* String::Replace(String* search, String* restring)
  278. {
  279.         int pos = Find(search,0);
  280.         int lastpos = 0;
  281.         //String* copy = Part(0,_Length);
  282.         String* result = new String("");
  283.         while (pos >=0){
  284.                 result = result->Append(Part(lastpos,pos-1));
  285.                 result = result->Append(restring);
  286.                 lastpos = pos+search->_Length;
  287.                 pos = Find(search,lastpos);
  288.         }
  289.         result = result->Append(Part(lastpos,_Length));
  290.         return result;
  291. }
  292.  
  293. String* String::Between(String* _start, String* _end, int _skip)
  294. {
  295.         //printf("Between: '%s', '%s', '%s' \n", &this->Data[0], &_start->Data[0], &_end->Data[0]);
  296.         if (_end->_Length==0) {_end=_start;}
  297.         if (_start->_Length==0) {return this;}
  298.         //printf("Between: %d, %d\n", _start->_Length, _end->_Length);
  299.         //printf("Between: '%s', '%s'\n", &_start->Data[0], &_end->Data[0]);
  300.  
  301.         int pos1 = this->Find(_start, 0);
  302.         if (_skip>0)
  303.         {
  304.                 //printf("Between: Skipping %d\n", _skip);
  305.            for (int i=0; i<_skip; i++)
  306.                 {
  307.                  pos1=this->Find(_start, pos1+_start->_Length);
  308.                 }
  309.         }
  310.         int pos2 = this->Find(_end, pos1+_start->_Length);
  311.         if (pos1==-1 || pos2==-1) {return this;}
  312.  
  313.         return this->Part(pos1+_start->_Length, pos2-1);
  314. }
  315.  
  316. int String::ToInt()
  317. {
  318.         return atoi(Data);
  319. }
  320.  
  321. float String::ToFloat()
  322. {
  323.         return atof(Data);
  324. }
  325.  
  326. String* String::TrimLead()
  327. {
  328.         int pos = 0;
  329.  
  330.         for (int i=0 ;(this->Data[i]<=32) ; i++)
  331.         {
  332.                 pos = i;
  333.         }
  334.         char *buffer = (char*)malloc(((this->_Length-pos)+1)*sizeof(char));
  335.         for (int j=pos ; j<=this->_Length ; j++)
  336.         {
  337.                 buffer[j-pos] = this->Data[j+1];
  338.         }
  339.         buffer[this->_Length-pos] = 0;
  340.         return new String(buffer);
  341. }
  342.  
  343. String* String::TrimTrail()
  344. {
  345.         int pos = this->_Length;
  346.  
  347.         for (int i=this->_Length ;(this->Data[i]<=32) ; i--)
  348.         {
  349.                 pos = i;
  350.         }
  351.         char *buffer = (char*)malloc((pos+1)*sizeof(char));
  352.         for (int j=0 ; j<pos ; j++)
  353.         {
  354.                 buffer[j] = this->Data[j];
  355.         }
  356.         buffer[pos] = 0;
  357.         return new String(buffer);     
  358. }
  359.  
  360. String* String::Trim()
  361. {
  362.         String* result = TrimLead();
  363.         return result->TrimTrail();
  364. }
  365.  
  366. String* String::FromChar(int code)
  367. {
  368.         char* buffer = (char*)malloc(2*sizeof(char));
  369.         buffer[0]=code;
  370.         buffer[1]=0;
  371.         return new String(buffer);
  372. }
  373.  
  374. int String::Ascii()
  375. {
  376.         return (int)this->Data[0];
  377. }
  378.  
  379. String* String::ToLower()
  380. {
  381.         char* buffer = (char*)malloc(this->_Length*sizeof(char));
  382.         for( int i=0; i<=this->_Length;i++)
  383.         {
  384.                 buffer[i]=this->Data[i];
  385.                         //printf("%d\n",(int)buffer[i]);
  386.                 if (((buffer[i]>=65)&&(buffer[i]<=90))||((buffer[i]>=-64)&&(buffer[i]<=-42))||((buffer[i]>=-40)&&(buffer[i]<=-34)))
  387.                 {
  388.                         //printf("%d\n",(int)buffer[i]);
  389.                         buffer[i]+=32;
  390.                 }                      
  391.         }
  392.         return new String(buffer);
  393. }
  394.  
  395. String* String::ToUpper()
  396. {
  397.         char* buffer = (char*)malloc(this->_Length*sizeof(char));
  398.         for( int i=0; i<=this->_Length;i++)
  399.         {
  400.                 buffer[i]=this->Data[i];
  401.                 if (((buffer[i]>=97)&&(buffer[i]<=122))||((buffer[i]>=-32)&&(buffer[i]<=-10))||((buffer[i]>=-8)&&(buffer[i]<=-2)))
  402.                 {
  403.                         buffer[i]-=32;
  404.                 }                      
  405.         }
  406.         return new String(buffer);
  407. }
  408.  
  409. int String::Contains(String* sub)
  410. {
  411.         if (Find(sub,0)>=0){return true;}
  412.         return false;
  413. }
  414.  
  415. int String::BeginsWith(String* sub)
  416. {
  417.         if(Find(sub,0)==0){return true;}
  418.         return false;
  419. }
  420.  
  421. int String::EndsWith(String* sub)
  422. {
  423.         if(Find(sub,0)== this->_Length-sub->_Length){return true;}
  424.         return false;
  425. }
  426.  
  427. int String::Length()
  428. {
  429.         return _Length;
  430. }
  431.  
  432. String* String::FromCString(char* pointer)
  433. {
  434.         return new String(pointer);
  435. }
  436.  
  437. String* String::FromCString(const char* pointer)
  438. {
  439.         return new String((char*)(pointer));
  440. }
  441.  
  442. bool String::Equals(String* Other) {
  443.     return !strcmp(Data, Other->Data);
  444. }
  445.  
  446. String* String::Reverse()
  447. {
  448.         char* Buffer = (char*)malloc((this->_Length+1)*sizeof(char));
  449.         for(int i = 0;i<=_Length;i++)
  450.         {
  451.                 Buffer[i]=Data[_Length-i-1];
  452.         }
  453.         Buffer[_Length]=0;
  454.         return new String(Buffer);
  455. }
  456.  
  457. String* String::Hex(int number)
  458. {
  459.         char* Buffer = (char*)malloc(9*sizeof(char));
  460.         //Buffer[0]='$';
  461.         for (int k = 7 ; k>=0 ; k--)
  462.         {
  463.                 int n = (number & 15) + 48;
  464.                 if (n>57) {n=n+7;}
  465.                 Buffer[k]=n;
  466.                 number = number >> 4;
  467.         }
  468.         Buffer[8]=0;
  469.         return new String(Buffer);
  470. }
  471.  
  472. String* String::Bin(int number)
  473. {
  474.         char* Buffer = (char*)malloc(33*sizeof(char));
  475.         //Buffer[0]='$';
  476.         for (int k = 31 ; k>=0 ; k--)
  477.         {
  478.                 int n = (number & 1) + 48;
  479.                 //if (n>57) {n=n+7;}
  480.                 Buffer[k]=n;
  481.                 number = number >> 1;
  482.         }
  483.         Buffer[32]=0;
  484.         return new String(Buffer);
  485. }
  486.  
  487. String* String::Oct(int number)
  488. {
  489.         char* Buffer = (char*)malloc(12*sizeof(char));
  490.         //Buffer[0]='$';
  491.         for (int k = 10 ; k>=0 ; k--)
  492.         {
  493.                 int n = (number & 7) + 48;
  494.                 //if (n==55) {printf("hulla\n");}
  495.                 Buffer[k]=n;
  496.                 if (k>1)
  497.                         {number = number >> 3;}
  498.                 else
  499.                 {number = (number&24) >>3;}
  500.         }
  501.         //sprintf("%d\n",(int)number);
  502.         //number = number >>2;
  503.         //Buffer[10]=int( (number & 7) + 48);
  504.         Buffer[11]=0;
  505.         return new String(Buffer);
  506. }
  507.  
  508. String* String::LongOct(long long int number)
  509. {
  510.         char* Buffer = (char*)malloc(23*sizeof(char));
  511.         //Buffer[0]='$';
  512.         for (int k = 21 ; k>=0 ; k--)
  513.         {
  514.                 int n = (number & 7) + 48;
  515.                 //if (n==55) {printf("hulla\n");}
  516.                 Buffer[k]=n;
  517.                 if (k>1)
  518.                         {number = number >> 3;}
  519.                 else
  520.                 {number = (number&8) >>3;}
  521.         }
  522.         //sprintf("%d\n",(int)number);
  523.         //number = number >>2;
  524.         //Buffer[10]=int( (number & 7) + 48);
  525.         Buffer[22]=0;
  526.         return new String(Buffer);
  527. }
  528.  
  529. String* String::FromBytes(Array<char, 1>* a, int number)
  530. {
  531.         char* Buffer = (char*)malloc((number+1)*sizeof(char));
  532.         for (int i=0 ; i<number ; i++)
  533.         {
  534.                 Buffer[i]=a->Data[i];
  535.         }
  536.         Buffer[number]=0;
  537.         return new String(Buffer);
  538. }
  539.  
  540. char* String::ToCString()
  541. {
  542.         return Data+'\0';
  543. }
  544.  
  545. Array<String*,1>* String::Split(String* div)
  546. {
  547.     return new Array<String*,1>(1);
  548.         Array<String*,1>* a = new Array<String*,1>(-1,CountOccurrences(div)+1);
  549.         for(int i = 0, count=0; this->Find(div,i)>=0; i=this->Find(div,i)+(div->_Length),count++)
  550.         {      
  551.                 a->Data[count] = Part(i,Find(div,i)-1);
  552.         }
  553.         a->Data[CountOccurrences(div)] = Part(FindLast(div,0)+div->_Length,_Length-1);
  554.         return a;
  555. }
  556.  
  557. int String::CountOccurrences(String* sub)
  558. {
  559.         if (Find(sub,0)>=0)
  560.         {      
  561.                 int count = 0;
  562.                 for(int i = 0; this->Find(sub,i)>=0; i=this->Find(sub,i)+(sub->_Length))
  563.                 {count++;}
  564.                 return count;
  565.         }
  566.         return false;
  567. }
create a new version of this paste RAW Paste Data