gclib2/modules/Core/earray.cxx

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