source/utils/CarlaStringList.hpp

   1 /*
   2  * Carla String List
   3  * Copyright (C) 2014-2019 Filipe Coelho <falktx@falktx.com>
   4  *
   5  * This program is free software; you can redistribute it and/or
   6  * modify it under the terms of the GNU General Public License as
   7  * published by the Free Software Foundation; either version 2 of
   8  * the License, or any later version.
   9  *
  10  * This program is distributed in the hope that it will be useful,
  11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
  13  * GNU General Public License for more details.
  14  *
  15  * For a full copy of the GNU General Public License see the doc/GPL.txt file.
  16  */
  17
  18 #ifndef CARLA_STRING_LIST_HPP_INCLUDED
  19 #define CARLA_STRING_LIST_HPP_INCLUDED
  20
  21 #include "LinkedList.hpp"
  22
  23 // -----------------------------------------------------------------------
  24 // Helper class to manage the lifetime of a "char**" object
  25
  26 class CharStringListPtr
  27 {
  28 public:
  29     CharStringListPtr() noexcept
  30         : fCharList(nullptr) {}
  31
  32     CharStringListPtr(const char* const* const c) noexcept
  33         : fCharList(c) {}
  34
  35     CharStringListPtr(const CharStringListPtr& ptr) noexcept
  36         : fCharList(nullptr)
  37     {
  38         copy(ptr.fCharList);
  39     }
  40
  41     CharStringListPtr(const LinkedList<const char*>& list) noexcept
  42         : fCharList(nullptr)
  43     {
  44         copy(list);
  45     }
  46
  47     ~CharStringListPtr() noexcept
  48     {
  49         clear();
  50     }
  51
  52     // -------------------------------------------------------------------
  53
  54     operator const char* const*() const noexcept
  55     {
  56         return fCharList;
  57     }
  58
  59     CharStringListPtr& operator=(const char* const* const c) noexcept
  60     {
  61         clear();
  62         fCharList = c;
  63         return *this;
  64     }
  65
  66     CharStringListPtr& operator=(const CharStringListPtr& ptr) noexcept
  67     {
  68         clear();
  69         copy(ptr.fCharList);
  70         return *this;
  71     }
  72
  73     CharStringListPtr& operator=(const LinkedList<const char*>& list) noexcept
  74     {
  75         clear();
  76         copy(list);
  77         return *this;
  78     }
  79
  80     // -------------------------------------------------------------------
  81
  82 protected:
  83     void clear() noexcept
  84     {
  85         if (fCharList == nullptr)
  86             return;
  87
  88         for (int i=0; fCharList[i] != nullptr; ++i)
  89             delete[] fCharList[i];
  90
  91         delete[] fCharList;
  92         fCharList = nullptr;
  93     }
  94
  95     void copy(const char* const* const c) noexcept
  96     {
  97         CARLA_SAFE_ASSERT_RETURN(c != nullptr,);
  98         CARLA_SAFE_ASSERT_RETURN(fCharList == nullptr,);
  99
 100         std::size_t count = 0;
 101         for (; c[count] != nullptr; ++count) {}
 102         CARLA_SAFE_ASSERT_RETURN(count > 0,);
 103
 104         const char** tmpList;
 105
 106         try {
 107             tmpList = new const char*[count+1];
 108         } CARLA_SAFE_EXCEPTION_RETURN("CharStringListPtr::copy",);
 109
 110         tmpList[count] = nullptr;
 111
 112         for (std::size_t i=0; i<count; ++i)
 113         {
 114             tmpList[i] = carla_strdup_safe(c[i]);
 115             CARLA_SAFE_ASSERT_BREAK(tmpList[i] != nullptr);
 116         }
 117
 118         fCharList = tmpList;
 119     }
 120
 121     void copy(const LinkedList<const char*>& list) noexcept
 122     {
 123         CARLA_SAFE_ASSERT_RETURN(fCharList == nullptr,);
 124
 125         const std::size_t count(list.count());
 126         CARLA_SAFE_ASSERT_RETURN(count > 0,);
 127
 128         const char** tmpList;
 129
 130         try {
 131             tmpList = new const char*[count+1];
 132         } CARLA_SAFE_EXCEPTION_RETURN("CharStringListPtr::copy",);
 133
 134         tmpList[count] = nullptr;
 135
 136         std::size_t i=0;
 137         for (LinkedList<const char*>::Itenerator it = list.begin2(); it.valid(); it.next(), ++i)
 138         {
 139             tmpList[i] = carla_strdup_safe(it.getValue(nullptr));
 140             CARLA_SAFE_ASSERT_BREAK(tmpList[i] != nullptr);
 141         }
 142         CARLA_SAFE_ASSERT(i == count);
 143
 144         fCharList = tmpList;
 145     }
 146
 147     // -------------------------------------------------------------------
 148
 149 private:
 150     const char* const* fCharList;
 151 };
 152
 153 // -----------------------------------------------------------------------
 154 // CarlaStringList
 155
 156 class CarlaStringList : public LinkedList<const char*>
 157 {
 158 public:
 159     CarlaStringList(bool allocateElements = true) noexcept
 160         : LinkedList<const char*>(),
 161           fAllocateElements(allocateElements) {}
 162
 163     CarlaStringList(const CarlaStringList& list) noexcept
 164         : LinkedList<const char*>(),
 165           fAllocateElements(list.fAllocateElements)
 166     {
 167         for (Itenerator it = list.begin2(); it.valid(); it.next())
 168             LinkedList<const char*>::append(carla_strdup_safe(it.getValue(nullptr)));
 169     }
 170
 171     ~CarlaStringList() noexcept override
 172     {
 173         clear();
 174     }
 175
 176     // -------------------------------------------------------------------
 177
 178     void clear() noexcept
 179     {
 180         if (fAllocateElements)
 181         {
 182             for (Itenerator it = begin2(); it.valid(); it.next())
 183             {
 184                 if (const char* const string = it.getValue(nullptr))
 185                     delete[] string;
 186             }
 187         }
 188
 189         LinkedList<const char*>::clear();
 190     }
 191
 192     // -------------------------------------------------------------------
 193
 194     bool append(const char* const string) noexcept
 195     {
 196         CARLA_SAFE_ASSERT_RETURN(string != nullptr, false);
 197
 198         if (const char* const stringDup = fAllocateElements ? carla_strdup_safe(string) : string)
 199         {
 200             if (LinkedList<const char*>::append(stringDup))
 201                 return true;
 202             delete[] stringDup;
 203         }
 204
 205         return false;
 206     }
 207
 208     bool appendUnique(const char* const string) noexcept
 209     {
 210         CARLA_SAFE_ASSERT_RETURN(string != nullptr, false);
 211
 212         if (contains(string))
 213             return false;
 214
 215         return append(string);
 216     }
 217
 218     bool appendAt(const char* const string, const Itenerator& it) noexcept
 219     {
 220         CARLA_SAFE_ASSERT_RETURN(string != nullptr, false);
 221
 222         if (const char* const stringDup = fAllocateElements ? carla_strdup_safe(string) : string)
 223         {
 224             if (LinkedList<const char*>::appendAt(stringDup, it))
 225                 return true;
 226             delete[] stringDup;
 227         }
 228
 229         return false;
 230     }
 231
 232     bool insert(const char* const string) noexcept
 233     {
 234         CARLA_SAFE_ASSERT_RETURN(string != nullptr, false);
 235
 236         if (const char* const stringDup = fAllocateElements ? carla_strdup_safe(string) : string)
 237         {
 238             if (LinkedList<const char*>::insert(stringDup))
 239                 return true;
 240             delete[] stringDup;
 241         }
 242
 243         return false;
 244     }
 245
 246     bool insertAt(const char* const string, const Itenerator& it) noexcept
 247     {
 248         CARLA_SAFE_ASSERT_RETURN(string != nullptr, false);
 249
 250         if (const char* const stringDup = fAllocateElements ? carla_strdup_safe(string) : string)
 251         {
 252             if (LinkedList<const char*>::insertAt(stringDup, it))
 253                 return true;
 254             delete[] stringDup;
 255         }
 256
 257         return false;
 258     }
 259
 260     // -------------------------------------------------------------------
 261
 262     const char* getAt(const std::size_t index) const noexcept
 263     {
 264         CARLA_SAFE_ASSERT_RETURN(fCount > 0 && index < fCount, nullptr);
 265
 266         std::size_t i = 0;
 267         ListHead* entry = fQueue.next;
 268
 269         for (; i++ != index; entry = entry->next) {}
 270
 271         const Data* const data(list_entry_const(entry, Data, siblings));
 272         CARLA_SAFE_ASSERT_RETURN(data != nullptr, nullptr);
 273
 274         return data->value;
 275     }
 276
 277     const char* getFirst() const noexcept
 278     {
 279         CARLA_SAFE_ASSERT_RETURN(fCount > 0, nullptr);
 280
 281         const Data* const data(list_entry_const(fQueue.next, Data, siblings));
 282         CARLA_SAFE_ASSERT_RETURN(data != nullptr, nullptr);
 283
 284         return data->value;
 285     }
 286
 287     const char* getLast() const noexcept
 288     {
 289         CARLA_SAFE_ASSERT_RETURN(fCount > 0, nullptr);
 290
 291         const Data* const data(list_entry_const(fQueue.prev, Data, siblings));
 292         CARLA_SAFE_ASSERT_RETURN(data != nullptr, nullptr);
 293
 294         return data->value;
 295     }
 296
 297     // -------------------------------------------------------------------
 298
 299     const char* getAndRemoveFirst() noexcept
 300     {
 301         CARLA_SAFE_ASSERT_RETURN(fCount > 0, nullptr);
 302
 303         const Data* const data = list_entry_const(fQueue.next, Data, siblings);
 304         CARLA_SAFE_ASSERT_RETURN(data != nullptr, nullptr);
 305
 306         const char* const ret = data->value;
 307
 308         Itenerator it = begin2();
 309         LinkedList<const char*>::remove(it);
 310
 311         return ret;
 312     }
 313
 314     // -------------------------------------------------------------------
 315
 316     bool contains(const char* const string) noexcept
 317     {
 318         CARLA_SAFE_ASSERT_RETURN(string != nullptr, false);
 319
 320         if (fCount == 0)
 321             return false;
 322
 323         for (Itenerator it = begin2(); it.valid(); it.next())
 324         {
 325             const char* const stringComp(it.getValue(nullptr));
 326             CARLA_SAFE_ASSERT_CONTINUE(stringComp != nullptr);
 327
 328             if (std::strcmp(string, stringComp) == 0)
 329                 return true;
 330         }
 331
 332         return false;
 333     }
 334
 335     const char* containsAndReturnString(const char* const string) noexcept
 336     {
 337         CARLA_SAFE_ASSERT_RETURN(string != nullptr, nullptr);
 338
 339         if (fCount == 0)
 340             return nullptr;
 341
 342         for (Itenerator it = begin2(); it.valid(); it.next())
 343         {
 344             const char* const stringComp(it.getValue(nullptr));
 345             CARLA_SAFE_ASSERT_CONTINUE(stringComp != nullptr);
 346
 347             if (std::strcmp(string, stringComp) == 0)
 348                 return stringComp;
 349         }
 350
 351         return nullptr;
 352     }
 353
 354     // -------------------------------------------------------------------
 355
 356     void remove(Itenerator& it) noexcept
 357     {
 358         if (const char* const string = it.getValue(nullptr))
 359             delete[] string;
 360
 361         LinkedList<const char*>::remove(it);
 362     }
 363
 364     bool removeOne(const char* const string) noexcept
 365     {
 366         CARLA_SAFE_ASSERT_RETURN(string != nullptr, false);
 367
 368         for (Itenerator it = begin2(); it.valid(); it.next())
 369         {
 370             const char* const stringComp(it.getValue(nullptr));
 371             CARLA_SAFE_ASSERT_CONTINUE(stringComp != nullptr);
 372
 373             if (std::strcmp(string, stringComp) != 0)
 374                 continue;
 375
 376             delete[] stringComp;
 377             LinkedList<const char*>::remove(it);
 378             return true;
 379         }
 380
 381         return false;
 382     }
 383
 384     void removeAll(const char* const string) noexcept
 385     {
 386         CARLA_SAFE_ASSERT_RETURN(string != nullptr,);
 387
 388         for (Itenerator it = begin2(); it.valid(); it.next())
 389         {
 390             const char* const stringComp(it.getValue(nullptr));
 391             CARLA_SAFE_ASSERT_CONTINUE(stringComp != nullptr);
 392
 393             if (std::strcmp(string, stringComp) != 0)
 394                 continue;
 395
 396             delete[] stringComp;
 397             LinkedList<const char*>::remove(it);
 398         }
 399     }
 400
 401     // -------------------------------------------------------------------
 402
 403     CharStringListPtr toCharStringListPtr() const noexcept
 404     {
 405         return CharStringListPtr(*this);
 406     }
 407
 408     CarlaStringList& operator=(const char* const* const charStringList) noexcept
 409     {
 410         CARLA_SAFE_ASSERT_RETURN(! fAllocateElements, *this);
 411
 412         clear();
 413
 414         CARLA_SAFE_ASSERT_RETURN(charStringList != nullptr, *this);
 415
 416         for (int i=0; charStringList[i] != nullptr; ++i)
 417         {
 418             if (const char* const string = carla_strdup_safe(charStringList[i]))
 419                 LinkedList<const char*>::append(string);
 420         }
 421
 422         return *this;
 423     }
 424
 425     CarlaStringList& operator=(const CarlaStringList& list) noexcept
 426     {
 427         CARLA_SAFE_ASSERT_RETURN(! fAllocateElements, *this);
 428
 429         clear();
 430
 431         for (Itenerator it = list.begin2(); it.valid(); it.next())
 432         {
 433             if (const char* const string = carla_strdup_safe(it.getValue(nullptr)))
 434                 LinkedList<const char*>::append(string);
 435         }
 436
 437         return *this;
 438     }
 439
 440 private:
 441     const bool fAllocateElements;
 442
 443     CARLA_PREVENT_VIRTUAL_HEAP_ALLOCATION
 444 };
 445
 446 // -----------------------------------------------------------------------
 447
 448 #endif // CARLA_STRING_LIST_HPP_INCLUDED