Changeset 1500:872b0b69e0d5


Ignore:
Timestamp:
05/14/11 23:07:44 (9 months ago)
Author:
niam
Branch:
default
Tags:
tip
Message:

{issue #103} added implementation of sl- and dl- lists

Location:
sources
Files:
1 added
25 edited

Legend:

Unmodified
Added
Removed

  • sources/configure

    r1499 r1500  
    674674enable_profiling 
    675675enable_libwrap 
    676 enable_deque 
    677676enable_io_xexec 
    678677enable_database_xexec 
    … …  
    13241323  --enable-profiling      enable profiling 
    13251324  --disable-libwrap       disable libwrap support 
    1326   --disable-deque         use std::vector instead of std::deque 
    13271325  --disable-io-xexec      compile io:: w/o xexec support 
    13281326  --disable-database-xexec 
    … …  
    48934891fi 
    48944892 
    4895 # Check whether --enable-deque was given. 
    4896 if test "${enable_deque+set}" = set; then : 
    4897   enableval=$enable_deque; DEQUE="$enableval" 
    4898 else 
    4899   DEQUE="yes" 
    4900 fi 
    4901  
    4902 if test "$DEQUE" = "yes" 
    4903 then 
    4904         echo -n -e "#define USE_DEQUE 1\n\n" >> include/libdodo/directives.runtime.h 
    4905  
    4906         RESULT="$RESULT\nDeque\t\t\t\t\t\t\t\tenabled" 
    4907 else 
    4908         RESULT="$RESULT\nDeque\t\t\t\t\t\t\t\tdisabled" 
    4909 fi 
    4910  
    49114893# Check whether --enable-io-xexec was given. 
    49124894if test "${enable_io_xexec+set}" = set; then : 

  • sources/configure.in

    r1499 r1500  
    136136else 
    137137        RESULT="$RESULT\nlibwrap\t\t\t\t\t\t\t\tdisabled" 
    138 fi 
    139  
    140 AC_ARG_ENABLE(deque, 
    141         AS_HELP_STRING([--disable-deque], [use std::vector instead of std::deque]), 
    142                 [DEQUE="$enableval"], [DEQUE="yes"]) 
    143 if test "$DEQUE" = "yes" 
    144 then 
    145         echo -n -e "#define USE_DEQUE 1\n\n" >> include/libdodo/directives.runtime.h 
    146  
    147         RESULT="$RESULT\nDeque\t\t\t\t\t\t\t\tenabled" 
    148 else 
    149         RESULT="$RESULT\nDeque\t\t\t\t\t\t\t\tdisabled" 
    150138fi 
    151139 

  • sources/examples/io_network.pc_thread/test.cc

    r1493 r1500  
    111111 
    112112                dodo_try { 
    113                     dodoList<unsigned long> threads = manager.jobs(); 
    114                     dodoList<unsigned long>::iterator i = threads.begin(), j = threads.end(); 
     113                    dodo::slList<unsigned long> threads = manager.jobs(); 
     114                    dodo::slList<unsigned long>::iterator i = threads.begin(), j = threads.end(); 
    115115                    for (; i != j; ++i) 
    116116                        if (manager.isRunning(*i)) { 

  • sources/examples/pc_workqueue/test.cc

    r1493 r1500  
    4949        wq.add(work, (void *)"last"); 
    5050 
    51         tools::os::sleep(20); 
     51        tools::os::sleep(30); 
    5252    } dodo_catch (dodo::exception::basic *e)   { 
    5353        cout << (dodo::string)*e << "\t" << e->line << "\t" << e->file << endl; 

  • sources/include/libdodo/cgiDialogue.h

    r1439 r1500  
    262262            dodo::string postFilesTmpDir;                                                                 ///< directory for POST files if on they are saved on the disk 
    263263 
    264             dodoList<cookie> cookies;                                                                   ///< cookies 
     264            dodo::slList<cookie> cookies;                                                                   ///< cookies 
    265265            int requestMethod;                                                                          ///< request method 
    266266 

  • sources/include/libdodo/dataBasePostgresql.h

    r1439 r1500  
    250250                }; 
    251251 
    252                 dodoList<__blob__> blobs;                                                               ///< references to blob data 
     252                dodo::slList<__blob__> blobs;                                                               ///< references to blob data 
    253253 
    254254              private: 

  • sources/include/libdodo/dataBaseSqlite.h

    r1439 r1500  
    172172                }; 
    173173 
    174                 dodoList<__blob__> blobs;           ///< references to blob data 
     174                dodo::slList<__blob__> blobs;           ///< references to blob data 
    175175 
    176176              private: 

  • sources/include/libdodo/pcExecutionManager.h

    r1439 r1500  
    119119                 * @return list of jobs in object 
    120120                 */ 
    121                 dodoList<unsigned long> jobs(); 
     121                dodo::slList<unsigned long> jobs(); 
    122122 
    123123                /** 

  • sources/include/libdodo/pcExecutionWorkqueue.h

    r1482 r1500  
    8989 
    9090                struct __work__; 
    91                 dodoList<__work__ *> tasks;  ///< pending work 
    9291 
    93                 dodoList<execution::thread *> active;  ///< active thread 
    94                 dodoList<execution::thread *> inactive;  ///< inactive thread 
     92                dodo::dlList<__work__ *> tasks;  ///< pending work 
     93 
     94                dodo::dlList<execution::thread *> active;  ///< active thread 
     95                dodo::dlList<execution::thread *> inactive;  ///< inactive thread 
    9596 
    9697                unsigned int maxThreads; ///< max amount of active threads 

  • sources/include/libdodo/toolsLogger.h

    r1439 r1500  
    128128            }; 
    129129 
    130             dodoList<__log_map__> handlers;                             ///< list of log maps 
     130            dodo::slList<__log_map__> handlers;                             ///< list of log maps 
    131131 
    132132            unsigned long handlersNum;                                  ///< number of registered handlers 

  • sources/include/libdodo/types.h

    r1464 r1500  
    3333#include <libdodo/directives.h> 
    3434#include <libdodo/string.h> 
     35#include <libdodo/list.h> 
    3536 
    3637#include <vector> 
    37 #include <list> 
    3838#include <deque> 
    3939#include <map> 
     40#include <cstddef> 
     41 
     42#ifndef NULL 
     43#define NULL ((void *)0) 
     44#endif 
    4045 
    4146namespace dodo { 
    … …  
    143148#define dodoMap std::map 
    144149 
    145 #ifdef USE_DEQUE 
    146 #define dodoArray    std::deque 
    147 #else 
    148150#define dodoArray    std::vector 
    149 #endif 
    150151 
    151152    typedef dodoArray<dodo::string> dodoStringArray;                                          ///< array of strings 
    152153 
    153 #define dodoList std::list 
    154  
    155     typedef dodoList<dodo::string> dodoStringList;                                            ///< array of strings 
     154    typedef dodo::slList<dodo::string> dodoStringList;                                            ///< array of strings 
    156155 
    157156    typedef dodoMap<dodo::string, dodo::string, dodoMapStringCompare> dodoStringMap;            ///< hash of strings 

  • sources/include/libdodo/xexec.h

    r1439 r1500  
    257257         * @param id defines XExec identificator 
    258258         */ 
    259         bool getXexec(dodoList<__item__> &list, 
     259        bool getXexec(dodo::slList<__item__> &list, 
    260260                      int                id); 
    261261 
    … …  
    267267         * @param data defines hook data 
    268268         */ 
    269         int addXExec(dodoList<__item__> &list, 
     269        int addXExec(dodo::slList<__item__> &list, 
    270270                     hook               func, 
    271271                     void               *data); 
    … …  
    276276         * @param operation defines what operation initiated the hook 
    277277         */ 
    278         void performXExec(dodoList<__item__> &list, 
     278        void performXExec(dodo::slList<__item__> &list, 
    279279                          short              operation) const; 
    280280 
    281         mutable dodoList<__item__> preExec;             ///< preExec hooks 
    282         mutable dodoList<__item__> postExec;            ///< postExec hooks 
     281        mutable dodo::slList<__item__> preExec;             ///< preExec hooks 
     282        mutable dodo::slList<__item__> postExec;            ///< postExec hooks 
    283283 
    284284        int execs;                                      ///< hook counter 
    285285 
    286         dodoList<__item__>::iterator current;           ///< iterator for list[for matched with getXexec method] 
     286        dodo::slList<__item__>::iterator current;           ///< iterator for list[for matched with getXexec method] 
    287287 
    288288        short execObject;                               ///< type of object, @see xexec::objectEnum 

  • sources/src/cgiDialogue.cc

    r1497 r1500  
    574574 
    575575    if (cookies.size() > 0) { 
    576         dodoList<cookie>::const_iterator i(cookies.begin()), j(cookies.end()); 
     576        dodo::slList<cookie>::iterator i(cookies.begin()), j(cookies.end()); 
    577577        for (; i != j; ++i) { 
    578578            io.writeString("Set-Cookie: "); 
    … …  
    818818dialogue::setCookie(const cookie &cookie) 
    819819{ 
    820     cookies.push_back(cookie); 
    821 } 
    822  
    823 //------------------------------------------------------------------- 
    824  
     820    cookies.push(cookie); 
     821} 
     822 
     823//------------------------------------------------------------------- 
     824 

  • sources/src/dataBaseMysql.cc

    r1464 r1500  
    280280    MYSQL_FIELD *mysqlFields = mysql_fetch_fields(handle->result); 
    281281 
    282 #ifndef USE_DEQUE 
    283282    rows->fields.reserve(numFields); 
    284283 
    285284    rows->values.reserve(mysql_num_rows(handle->result)); 
    286 #endif 
    287285 
    288286    unsigned long *length, j; 
    … …  
    292290    MYSQL_ROW mysqlRow; 
    293291 
    294 #ifndef USE_DEQUE 
    295292    values.reserve(numFields); 
    296 #endif 
    297293 
    298294    for (unsigned int i(0); i < numFields; ++i) 

  • sources/src/dataBasePostgresql.cc

    r1464 r1500  
    279279    int fieldsNum = PQnfields(handle->result); 
    280280 
    281 #ifndef USE_DEQUE 
    282281    rows->fields.reserve(fieldsNum); 
    283282    rows->values.reserve(rowsNum); 
    284 #endif 
    285283 
    286284    dodoStringArray values; 
    287285 
    288 #ifndef USE_DEQUE 
    289286    values.reserve(fieldsNum); 
    290 #endif 
    291287 
    292288    for (int i(0); i < fieldsNum; ++i) 
    … …  
    453449            int *formats = new int[size]; 
    454450 
    455             dodoList<__blob__>::iterator i(blobs.begin()), j(blobs.end()); 
     451            dodo::slList<__blob__>::iterator i(blobs.begin()), j(blobs.end()); 
    456452            for (int o = 0; i != j; ++i, ++o) { 
    457453                values[o] = (char *)i->value->data(); 
    … …  
    560556                                blob.value = &(*j); 
    561557 
    562                                 blobs.push_back(blob); 
     558                                blobs.push(blob); 
    563559                            } else { 
    564560                                request += dodo::string(statements[sql::constructor::STATEMENT_EQUAL]); 
    … …  
    590586                            blob.value = &(*j); 
    591587 
    592                             blobs.push_back(blob); 
     588                            blobs.push(blob); 
    593589                        } else { 
    594590                            request += dodo::string(statements[sql::constructor::STATEMENT_EQUAL]); 
    … …  
    670666                                blob.value = &(*i); 
    671667 
    672                                 blobs.push_back(blob); 
     668                                blobs.push(blob); 
    673669                            } else 
    674670                                request += dodo::string(*i + statements[sql::constructor::STATEMENT_COMA]); 
    … …  
    690686                            blob.value = &(*i); 
    691687 
    692                             blobs.push_back(blob); 
     688                            blobs.push(blob); 
    693689                        } else 
    694690                            request += dodo::string(*i); 
    … …  
    719715                            blob.value = &(*i); 
    720716 
    721                             blobs.push_back(blob); 
     717                            blobs.push(blob); 
    722718                        } else 
    723719                            request += dodo::string(*i + statements[sql::constructor::STATEMENT_COMA]); 
    … …  
    739735                        blob.value = &(*i); 
    740736 
    741                         blobs.push_back(blob); 
     737                        blobs.push(blob); 
    742738                    } else 
    743739                        request += dodo::string(*i); 

  • sources/src/dataBaseSqlConstructor.cc

    r1456 r1500  
    202202 
    203203            dodoStringArray array; 
    204 #ifndef USE_DEQUE 
    205204            array.reserve(i->size()); 
    206 #endif 
    207205 
    208206            for (;i!=j;++i) { 
    … …  
    232230 
    233231        dodoStringArray array; 
    234 #ifndef USE_DEQUE 
    235232        array.reserve(map.size()); 
    236 #endif 
    237233 
    238234        for (;o!=p;++o) 

  • sources/src/dataBaseSqlite.cc

    r1464 r1500  
    213213    unsigned int i = 0; 
    214214 
    215 #ifndef USE_DEQUE 
    216215    rows->fields.reserve(numFields); 
    217 #endif 
    218216 
    219217    for (i = 0; i < numFields; ++i) 
    … …  
    241239 
    242240                values.clear(); 
    243  
    244 #ifndef USE_DEQUE 
    245241                values.reserve(numFields); 
    246 #endif 
    247242 
    248243                for (i = 0; i < numFields; ++i) { 
    … …  
    536531            dodo_throw exception::basic(exception::MODULE_DATABASESQLITE, SQLITEEX_EXEC, exception::ERRNO_SQLITE, sqlite3_errcode(handle->handle), sqlite3_errmsg(handle->handle), __LINE__, __FILE__, collectedData.query->sql); 
    537532 
    538         dodoList<__blob__>::iterator i(blobs.begin()), j(blobs.end()); 
     533        dodo::slList<__blob__>::iterator i(blobs.begin()), j(blobs.end()); 
    539534        for (; i != j; ++i) { 
    540535            if (sqlite3_bind_blob(handle->result, i->reference, i->value->data(), i->value->size(), SQLITE_TRANSIENT) != SQLITE_OK) { 
    … …  
    626621                                blob.value = &(*j); 
    627622 
    628                                 blobs.push_back(blob); 
     623                                blobs.push(blob); 
    629624                            } else { 
    630625                                request += dodo::string(statements[STATEMENT_EQUAL]); 
    … …  
    656651                            blob.value = &(*j); 
    657652 
    658                             blobs.push_back(blob); 
     653                            blobs.push(blob); 
    659654                        } else { 
    660655                            request += dodo::string(statements[STATEMENT_EQUAL]); 
    … …  
    736731                                blob.value = &(*i); 
    737732 
    738                                 blobs.push_back(blob); 
     733                                blobs.push(blob); 
    739734                            } else 
    740735                                request += dodo::string(*i + statements[STATEMENT_COMA]); 
    … …  
    756751                            blob.value = &(*i); 
    757752 
    758                             blobs.push_back(blob); 
     753                            blobs.push(blob); 
    759754                        } else 
    760755                            request += dodo::string(*i); 
    … …  
    785780                            blob.value = &(*i); 
    786781 
    787                             blobs.push_back(blob); 
     782                            blobs.push(blob); 
    788783                        } else 
    789784                            request += dodo::string(*i + statements[STATEMENT_COMA]); 
    … …  
    805800                        blob.value = &(*i); 
    806801 
    807                         blobs.push_back(blob); 
     802                        blobs.push(blob); 
    808803                    } else 
    809804                        request += dodo::string(*i); 

  • sources/src/dataTplProcessor.cc

    r1464 r1500  
    704704 
    705705        if (tools::filesystem::exists(temp1)) { 
    706             processed.push_back(path); 
     706            processed.push(path); 
    707707 
    708708            processFile(temp1, tpl); 
    709709 
    710             processed.pop_back(); 
     710            processed.pop(); 
    711711        } 
    712712    } 

  • sources/src/pcExecutionManager.cc

    r1464 r1500  
    216216//------------------------------------------------------------------- 
    217217 
    218 dodoList<unsigned long> 
     218dodo::slList<unsigned long> 
    219219manager::jobs() 
    220220{ 
    221221    pc::sync::stack tg(keeper); 
    222222 
    223     dodoList<unsigned long> jobs; 
     223    dodo::slList<unsigned long> jobs; 
    224224 
    225225    dodoMap<unsigned long, execution::job *>::const_iterator i = handles.begin(), j = handles.end(); 
    226226 
    227227    for (; i != j; ++i) 
    228         jobs.push_back(i->first); 
     228        jobs.push(i->first); 
    229229 
    230230    return jobs; 

  • sources/src/pcExecutionWorkqueue.cc

    r1486 r1500  
    9494        for (unsigned int i=0; i<minThreads; ++i) { 
    9595            t = new thread((routine)workqueue::worker, this, ON_DESTRUCTION_STOP); 
    96             inactive.push_back(t); 
     96            inactive.pushBack(t); 
    9797            t->run(); 
    9898        } 
    … …  
    110110workqueue::~workqueue() 
    111111{ 
    112     dodoList<thread *>::iterator i, j; 
    113     dodoList<__work__ *>::iterator o, p; 
     112    dodo::dlList<thread *>::iterator i, j; 
     113    dodo::dlList<__work__ *>::iterator o, p; 
    114114 
    115115    tasksProtector->acquire(); 
    … …  
    148148    bool active = false; 
    149149 
    150     dodoList<thread *> &inactiveQueue = queue->inactive, 
     150    dodo::dlList<thread *> &inactiveQueue = queue->inactive, 
    151151        &activeQueue = queue->active; 
    152152    sync::thread *tasksProtector = queue->tasksProtector, 
    153153        *threadsProtector = queue->threadsProtector; 
    154     dodoList<__work__ *> &tasks = queue->tasks; 
    155  
    156     threadsProtector->acquire(); 
    157     for (dodoList<thread *>::iterator i = inactiveQueue.begin(), j = inactiveQueue.end(); 
     154    dodo::dlList<__work__ *> &tasks = queue->tasks; 
     155 
     156    threadsProtector->acquire(); 
     157    for (dodo::dlList<thread *>::iterator i = inactiveQueue.begin(), j = inactiveQueue.end(); 
    158158         i != j; 
    159159         ++i) { 
    … …  
    172172        if (tasks.size()) { 
    173173            work = *tasks.begin(); 
    174             tasks.pop_front(); 
     174            tasks.popFront(); 
    175175        } else { 
    176176            work = NULL; 
    … …  
    182182                threadsProtector->acquire(); 
    183183                inactiveQueue.remove(self); 
    184                 activeQueue.push_back(self); 
     184                activeQueue.pushBack(self); 
    185185                threadsProtector->release(); 
    186186 
    … …  
    196196                threadsProtector->acquire(); 
    197197                activeQueue.remove(self); 
    198                 inactiveQueue.push_back(self); 
     198                inactiveQueue.pushBack(self); 
    199199                threadsProtector->release(); 
    200200 
    … …  
    265265 
    266266    tasksProtector->acquire(); 
    267     tasks.push_back(work); 
     267    tasks.pushBack(work); 
    268268    tasksProtector->release(); 
    269269 
    … …  
    284284 
    285285    threadsProtector->acquire(); 
    286     inactive.push_back(t); 
     286    inactive.pushBack(t); 
    287287    threadsProtector->release(); 
    288288 

  • sources/src/toolsLogger.cc

    r1439 r1500  
    9898    lm.position = ++handlersNum; 
    9999 
    100     handlers.push_back(lm); 
     100    handlers.push(lm); 
    101101 
    102102    return handlersNum; 
    … …  
    110110    pc::sync::stack pg(keeper); 
    111111 
    112     dodoList<__log_map__>::iterator i(handlers.begin()), j(handlers.end()); 
     112    dodo::slList<__log_map__>::iterator i(handlers.begin()), j(handlers.end()); 
    113113    for (; i != j; ++i) { 
    114114        if (i->position == position) { 
    115             handlers.erase(i); 
     115            handlers.remove(i); 
    116116 
    117117            break; 
    … …  
    131131        return; 
    132132 
    133     dodoList<__log_map__>::iterator i(handlers.begin()), j(handlers.end()); 
     133    dodo::slList<__log_map__>::iterator i(handlers.begin()), j(handlers.end()); 
    134134    for (; i != j; ++i) { 
    135135        if (i->level == level) { 

  • sources/src/toolsMisc.cc

    r1497 r1500  
    152152        cmpFunc = string::equal; 
    153153 
    154     dodoStringList::const_iterator i(arr.begin()), j(arr.end()); 
     154    dodoStringList::iterator i(arr.begin()), j(arr.end()); 
    155155    for (; i != j; ++i) 
    156156        if (cmpFunc(*i, needle)) 

  • sources/src/toolsRegexp.cc

    r1464 r1500  
    137137        return false; 
    138138 
    139 #ifndef USE_DEQUE 
    140139    pockets.reserve(boundaries.size()); 
    141 #endif 
    142140 
    143141    dodoArray<__regex_match__>::const_iterator i(boundaries.begin()), j(boundaries.end()); 

  • sources/src/types.cc

    r1439 r1500  
    3131 
    3232#include <vector> 
    33 #include <list> 
    3433#include <deque> 
    3534#include <map> 

  • sources/src/xexec.cc

    r1464 r1500  
    7777    deinitModule deinit; 
    7878 
    79     dodoList<__item__>::iterator i(preExec.begin()), j(preExec.end()); 
     79    dodo::slList<__item__>::iterator i(preExec.begin()), j(preExec.end()); 
    8080    for (; i != j; ++i) { 
    8181        if (i->handle == NULL) 
    … …  
    111111 
    112112int 
    113 xexec::addXExec(dodoList<__item__> &list, 
     113xexec::addXExec(dodo::slList<__item__> &list, 
    114114                hook               func, 
    115115                void               *data) 
    … …  
    125125#endif 
    126126 
    127     list.push_back(e); 
     127    list.push(e); 
    128128 
    129129    return e.id; 
    … …  
    136136{ 
    137137    if (getXexec(preExec, id)) 
    138         preExec.erase(current); 
     138        preExec.remove(current); 
    139139    else if (getXexec(postExec, id)) 
    140         postExec.erase(current); 
     140        postExec.remove(current); 
    141141    else 
    142142        return; 
    … …  
    192192 
    193193void 
    194 xexec::performXExec(dodoList<__item__> &list, 
     194xexec::performXExec(dodo::slList<__item__> &list, 
    195195                    short              operation) const 
    196196{ 
    … …  
    198198        return; 
    199199 
    200     dodoList<__item__>::iterator i(list.begin()), j(list.end()); 
     200    dodo::slList<__item__>::iterator i(list.begin()), j(list.end()); 
    201201 
    202202    for (; i != j; ++i) { 
    … …  
    281281    if (mod.type & ACTION_PREEXEC) { 
    282282        e.id = ++execs; 
    283         preExec.push_back(e); 
     283        preExec.push(e); 
    284284        preExecId = e.id; 
    285285    } 
    … …  
    287287    if (mod.type & ACTION_POSTEXEC) { 
    288288        e.id = ++execs; 
    289         postExec.push_back(e); 
     289        postExec.push(e); 
    290290        postExecId = e.id; 
    291291    } 
    … …  
    297297 
    298298bool 
    299 xexec::getXexec(dodoList<__item__> &list, 
     299xexec::getXexec(dodo::slList<__item__> &list, 
    300300                int                id) 
    301301{ 
    302     dodoList<__item__>::iterator i(list.begin()), j(list.end()); 
     302    dodo::slList<__item__>::iterator i(list.begin()), j(list.end()); 
    303303    for (; i != j; ++i) { 
    304304        if (i->id == id) { 
Note: See TracChangeset for help on using the changeset viewer.