silentbob/gclib/src/earray.cxx

   1 /*
   2  * (c) Oleg Puchinin 2006
   3  * graycardinalster@gmail.com
   4  *
   5  */
   6
   7 #include <gclib/gclib_c.h>
   8 #include <gclib/gclib.h>
   9
  10 /* Extendent array */
  11 EArray::EArray (int asize)
  12 {
  13 }
  14
  15 int EArray::add (long one)
  16 {
  17         return DArray::add (LPCHAR (one));
  18 }
  19
  20 int EArray::sfind (char * d_find)
  21 {
  22         int i;
  23         int d_size = get_size ();
  24         char ** d_array = get_skeleton ();
  25
  26         for (i = 0; i < d_size; i++) {
  27                 if (EQ (d_find, d_array[i]))
  28                         return i;
  29         }
  30
  31         return -1;
  32 }
  33
  34 int EArray::snfind (char * d_find)
  35 {
  36         int i;
  37         int d_size = get_size ();
  38         char ** d_array = get_skeleton ();
  39
  40         for (i = 0; i < d_size; i++) {
  41                 if (!strncmp (d_find, d_array[i], strlen (d_array[i])))
  42                         return i;
  43         }
  44
  45         return -1;
  46 }
  47
  48 void EArray::push (char ** d_push)
  49 {
  50         int i = 0;
  51         if (d_push == NULL)
  52                 return;
  53
  54         while (d_push[i]) {
  55                 add ((long) d_push[i]);
  56                 ++i;
  57         }
  58 }
  59
  60 int EArray::snfind_fast (char *str, int n)
  61 {
  62         int first;
  63         int last;
  64         int fact;
  65         int check;
  66         int move;
  67
  68         first = 0;
  69         last = get_size ();
  70         --last;
  71         if (last < 0)
  72                 return -1;
  73
  74         if (strcmp (get (0), str) > 0)
  75                 return -1;
  76
  77         while (true) {
  78                 move = (last - first) >> 1;
  79                 if (! move) {
  80                         if (EQ (get (first), str))
  81                                 return first;
  82                         if (EQ (get (last), str))
  83                                 return last;
  84                         return -1;
  85                 }
  86
  87                 check = first + move;
  88                 if (n)
  89                         fact = strncmp (get (check), str, n);
  90                 else
  91                         fact = strcmp (get (check), str);
  92
  93                 if (fact < 0) { // [check] < str
  94                         first = check;
  95                 } else if (! fact) { // [check] == str
  96                         return check;
  97                 } else if (fact > 0) { // [chec] > str
  98                         last = check;
  99                 }
 100         }
 101
 102         if (EQ (get (first), str))
 103                 return first;
 104
 105         return -1;
 106 }
 107
 108 int EArray::from_pipe (int fd)
 109 {
 110         char * buf;
 111         FILE * m_file;
 112
 113         m_file = fdopen (fd, "r");
 114         if (m_file == NULL)
 115                 return false;
 116
 117         buf = CNEW (char, 256);
 118         while (true) {
 119                 if (fgets (buf, 256, m_file) == NULL)
 120                         break;
 121
 122                 add (strdup (buf));
 123         }
 124
 125         fclose (m_file);
 126         DROP (buf);
 127         return get_size ();
 128 }
 129
 130 char * EArray::join (char * mid, int *len_out)
 131 {
 132         char *Ret;
 133         char *ptr;
 134         int count;
 135         int len = 0;
 136         int mid_len;
 137         int i;
 138
 139         if (! mid) {
 140                 mid_len = 0;
 141                 mid = (char *) "";
 142         } else
 143                 mid_len = strlen (mid);
 144
 145         count = get_size ();
 146         for (i = 0; i < count; i++)
 147                 len += strlen (get (i));
 148
 149         if (mid)
 150                 len += count * mid_len;
 151
 152         len++;
 153         Ret = CNEW (char, len);
 154         ptr = Ret;
 155         for (i = 0; i < count; i++) {
 156                 strcpy (ptr, (char *) get (i));
 157                 ptr += strlen (get (i));
 158                 strcpy (ptr, mid);
 159                 ptr += mid_len;
 160         }
 161
 162         if (len_out)
 163                 *len_out = len;
 164
 165         return Ret;
 166 }
 167
 168 int EArray::strings_to_file (char * f_name)
 169 {
 170         FILE * d_file;
 171         int d_len;
 172         int i;
 173
 174         d_file = fopen (f_name, "w");
 175         if (! d_file)
 176                 return -1;
 177
 178         d_len = get_size ();
 179         for (i = 0; i < d_len; ++i)
 180                 fprintf (d_file, "%s\n", get (i));
 181
 182         fclose (d_file);
 183         return d_len;
 184 }
 185
 186 EArray & EArray::operator << (char *S)
 187 {
 188         add (S);
 189         return *this;
 190 }
 191
 192 int EArray::expand (EArray * e)
 193 {
 194         int count;
 195         int i;
 196
 197         if (! e)
 198                 return get_size ();
 199
 200         count = e->get_size ();
 201         if (! count)
 202                 return get_size ();
 203
 204         for (i = 0; i < count; ++i)
 205                 add (e->get (i));
 206
 207         return get_size ();
 208 }
 209
 210 int EArray::expand (char *buf, char * split)
 211 {
 212         char * S;
 213         char * ptr = buf;
 214         int split_len;
 215         char * last;
 216
 217         if (!buf || !split || !(*buf))
 218                 return -1;
 219
 220         last = &buf[strlen (buf)-1];
 221         split_len = strlen (split);
 222         while((S = Dmid_memmem (ptr, last, split, split_len)) && S) {
 223                 add (Dstrndup (ptr, S - ptr));
 224                 S += split_len;
 225                 ptr = S;
 226         }
 227
 228         if (ptr <= last)
 229                 add (Dstrndup (ptr, last-ptr+1));
 230
 231         return get_size ();
 232 }
 233
 234 int EArray::dump (char * d_join)
 235 {
 236         int i;
 237         int count;
 238
 239         count = get_size ();
 240         for (i = 0; i < count; ++i)
 241                 printf ("%s%s", get (i), d_join);
 242
 243         return count;
 244 }