Ignore:
File:
1 edited

Legend:

Unmodified
Added
Removed

  • src/helpers.hpp

    rcc2ee5 r6ac7ee  
    11/** \file helpers.hpp
    22 *
    3  * Declaration of some auxiliary functions for memory dis-/allocation and so on 
     3 * Declaration of some auxiliary functions for memory dis-/allocation and so on
    44 */
    55
    … …  
    3838
    3939/* Behandelt aufgetretene Fehler. error ist der Fehlertyp(enum Errors)
    40   void *SpecialData ist ein untypisierter Zeiger auf Spezielle Daten zur Fehlerbehandlung.
    41   Man koennte auch noch einen Zeiger auf eine Funktion uebergeben */
     40        void *SpecialData ist ein untypisierter Zeiger auf Spezielle Daten zur Fehlerbehandlung.
     41        Man koennte auch noch einen Zeiger auf eine Funktion uebergeben */
    4242extern void /*@exits@*/ debug(const char *output);
    43   //__attribute__ ((__return__));
     43        //__attribute__ ((__return__));
    4444#define debug(data) debug_in((data), __FILE__, __LINE__)
    4545
    4646extern void /*@exits@*/ debug_in(const char *output,
    47     const char *file, const int line);
    48   //__attribute__ ((__return__));
     47                const char *file, const int line);
     48        //__attribute__ ((__return__));
    4949
    5050double ask_value(const char *text);
    … …  
    7373template <typename T> bool CreateFatherLookupTable(ofstream *out, T *start, T *end, T **&LookupTable, int count = 0)
    7474{
    75   bool status = true;
    76   T *Walker = NULL;
    77   int AtomNo;
    78  
    79   if (LookupTable != NULL) {
    80     *out << "Pointer for Lookup table is not NULL! Aborting ..." <<endl;
    81     return false;
    82   }
    83  
    84   // count them
    85   if (count == 0) {
    86     Walker = start;
    87     while (Walker->next != end) { // create a lookup table (Atom::nr -> atom) used as a marker table lateron
    88       Walker = Walker->next;
    89       count = (count < Walker->GetTrueFather()->nr) ? Walker->GetTrueFather()->nr : count;
    90     }
    91   }
    92   if (count <= 0) {
    93     *out << "Count of lookup list is 0 or less." << endl;
    94     return false;
    95   }
    96 
    97   // allocat and fill
    98   LookupTable = (T **) Malloc(sizeof(T *)*count, "CreateFatherLookupTable - **LookupTable");
    99   if (LookupTable == NULL) {
    100     cerr << "LookupTable memory allocation failed!" << endl;
    101     status = false;
    102   } else {
    103     for (int i=0;i<count;i++)
    104       LookupTable[i] = NULL;
    105     Walker = start;
    106     while (Walker->next != end) { // create a lookup table (Atom::nr -> atom) used as a marker table lateron
    107       Walker = Walker->next;
    108       AtomNo = Walker->GetTrueFather()->nr;
    109       if ((AtomNo >= 0) && (AtomNo < count)) {
    110         //*out << "Setting LookupTable[" << AtomNo << "] to " << *Walker << endl;
    111         LookupTable[AtomNo] = Walker;
    112       } else {
    113         *out << "Walker " << *Walker << " exceeded range of nuclear ids [0, " << count << ")." << endl;
    114         status = false;
    115         break;
    116       }
    117     }
    118   }
    119  
    120   return status;
     75        bool status = true;
     76        T *Walker = NULL;
     77        int AtomNo;
     78
     79        if (LookupTable != NULL) {
     80                *out << "Pointer for Lookup table is not NULL! Aborting ..." <<endl;
     81                return false;
     82        }
     83
     84        // count them
     85        if (count == 0) {
     86                Walker = start;
     87                while (Walker->next != end) { // create a lookup table (Atom::nr -> atom) used as a marker table lateron
     88                        Walker = Walker->next;
     89                        count = (count < Walker->GetTrueFather()->nr) ? Walker->GetTrueFather()->nr : count;
     90                }
     91        }
     92        if (count <= 0) {
     93                *out << "Count of lookup list is 0 or less." << endl;
     94                return false;
     95        }
     96
     97        // allocat and fill
     98        LookupTable = (T **) Malloc(sizeof(T *)*count, "CreateFatherLookupTable - **LookupTable");
     99        if (LookupTable == NULL) {
     100                cerr << "LookupTable memory allocation failed!" << endl;
     101                status = false;
     102        } else {
     103                for (int i=0;i<count;i++)
     104                        LookupTable[i] = NULL;
     105                Walker = start;
     106                while (Walker->next != end) { // create a lookup table (Atom::nr -> atom) used as a marker table lateron
     107                        Walker = Walker->next;
     108                        AtomNo = Walker->GetTrueFather()->nr;
     109                        if ((AtomNo >= 0) && (AtomNo < count)) {
     110                                //*out << "Setting LookupTable[" << AtomNo << "] to " << *Walker << endl;
     111                                LookupTable[AtomNo] = Walker;
     112                        } else {
     113                                *out << "Walker " << *Walker << " exceeded range of nuclear ids [0, " << count << ")." << endl;
     114                                status = false;
     115                                break;
     116                        }
     117                }
     118        }
     119
     120        return status;
    121121};
    122122
    … …  
    129129template <typename X> void link(X *walker, X *end)
    130130{
    131   X *vorher = end->previous;
    132   if (vorher != NULL)
    133     vorher->next = walker;
    134   end->previous = walker;
    135   walker->previous = vorher;
    136   walker->next = end;
     131        X *vorher = end->previous;
     132        if (vorher != NULL)
     133                vorher->next = walker;
     134        end->previous = walker;
     135        walker->previous = vorher;
     136        walker->next = end;
    137137};
    138138
    … …  
    143143template <typename X> void unlink(X *walker)
    144144{
    145   if (walker->next != NULL)
    146     walker->next->previous = walker->previous;
    147   if (walker->previous != NULL)
    148     walker->previous->next = walker->next;
     145        if (walker->next != NULL)
     146                walker->next->previous = walker->previous;
     147        if (walker->previous != NULL)
     148                walker->previous->next = walker->next;
    149149};
    150150
    151151/** Adds new item before an item \a *end in a list.
    152  * \param *pointer  item to be added
    153  * \param *end  end of list
     152 * \param *pointer      item to be added
     153 * \param *end  end of list
    154154 * \return true - addition succeeded, false - unable to add item to list
    155155 */
    156 template <typename X>  bool add(X *pointer, X *end)
    157 {
    158   if (end != NULL) {
    159     link(pointer, end);
    160   } else {
    161     pointer->previous = NULL;
    162     pointer->next = NULL;
    163   }
    164   return true;
     156template <typename X>   bool add(X *pointer, X *end)
     157{
     158        if (end != NULL) {
     159                link(pointer, end);
     160        } else {
     161                pointer->previous = NULL;
     162                pointer->next = NULL;
     163        }
     164        return true;
    165165};
    166166
    167167/** Finds item in list
    168  * \param *suche  search criteria
    169  * \param *start  begin of list
    170  * \param *end  end of list
     168 * \param *suche        search criteria
     169 * \param *start        begin of list
     170 * \param *end  end of list
    171171 * \return X - if found, NULL - if not found
    172172 */
    173173template <typename X, typename Y> X * find(Y *suche, X *start, X *end)
    174174{
    175   X *walker = start;
    176   while (walker->next != end) { // go through list
    177     walker = walker->next; // step onward beforehand
    178     if (*walker->sort == *suche) return (walker);
    179   }
    180   return NULL;
     175        X *walker = start;
     176        while (walker->next != end) { // go through list
     177                walker = walker->next; // step onward beforehand
     178                if (*walker->sort == *suche) return (walker);
     179        }
     180        return NULL;
    181181};
    182182
    … …  
    187187template <typename X> void removewithoutcheck(X *walker)
    188188{
    189   if (walker != NULL) {
    190     unlink(walker);
    191     delete(walker);
    192     walker = NULL;
    193   }
     189        if (walker != NULL) {
     190                unlink(walker);
     191                delete(walker);
     192                walker = NULL;
     193        }
    194194};
    195195
    196196/** Removes an item from the list, checks if exists.
    197197 * Checks beforehand if atom is really within molecule list.
    198  * \param *pointer  item to be removed
    199  * \param *start  begin of list
    200  * \param *end  end of list
     198 * \param *pointer      item to be removed
     199 * \param *start        begin of list
     200 * \param *end  end of list
    201201 * \return true - removing succeeded, false - given item not found in list
    202202 */
    203203template <typename X> bool remove(X *pointer, X *start, X *end)
    204204{
    205   X *walker = find (pointer->sort, start, end);
    206 /*  while (walker->next != pointer) { // search through list
    207     walker = walker->next;
    208     if (walker == end) return false;  // item not found in list
    209   }*/
    210   // atom found, now unlink
    211   if (walker != NULL)
    212     removewithoutcheck(walker);
    213   else
    214     return false;
    215   return true;
     205        X *walker = find (pointer->sort, start, end);
     206/*      while (walker->next != pointer) { // search through list
     207                walker = walker->next;
     208                if (walker == end) return false;        // item not found in list
     209        }*/
     210        // atom found, now unlink
     211        if (walker != NULL)
     212                removewithoutcheck(walker);
     213        else
     214                return false;
     215        return true;
    216216};
    217217
    … …  
    223223template <typename X> bool cleanup(X *start, X *end)
    224224{
    225   X *pointer = start->next;
    226   X *walker;
    227   while (pointer != end) { // go through list
    228     walker = pointer; // mark current
    229     pointer = pointer->next; // step onward beforehand
    230     // remove walker
    231     unlink(walker);
    232     delete(walker);
    233     walker = NULL;
    234   }
    235   return true;
     225        X *pointer = start->next;
     226        X *walker;
     227        while (pointer != end) { // go through list
     228                walker = pointer; // mark current
     229                pointer = pointer->next; // step onward beforehand
     230                // remove walker
     231                unlink(walker);
     232                delete(walker);
     233                walker = NULL;
     234        }
     235        return true;
    236236};
    237237
    … …  
    242242template <typename X> X *GetFirst(X *me)
    243243{
    244   X *Binder = me;
    245   while(Binder->previous != NULL)
    246     Binder = Binder->previous;
    247   return Binder;
    248 }; 
     244        X *Binder = me;
     245        while(Binder->previous != NULL)
     246                Binder = Binder->previous;
     247        return Binder;
     248};
    249249
    250250/** Returns the last marker in a chain list.
    … …  
    254254template <typename X> X *GetLast(X *me)
    255255{
    256   X *Binder = me;
    257   while(Binder->next != NULL)
    258     Binder = Binder->next;
    259   return Binder;
    260 }; 
     256        X *Binder = me;
     257        while(Binder->next != NULL)
     258                Binder = Binder->next;
     259        return Binder;
     260};
    261261
    262262/** Frees a two-dimensional array.
    … …  
    266266template <typename X> void Free2DArray(X **ptr, int dim)
    267267{
    268   int i;
    269   if (ptr != NULL) {
    270     for(i=dim;i--;)
    271       if (ptr[i] != NULL)
    272         free(ptr[i]);
    273     free(ptr);
    274   }
     268        int i;
     269        if (ptr != NULL) {
     270                for(i=dim;i--;)
     271                        if (ptr[i] != NULL)
     272                                free(ptr[i]);
     273                free(ptr);
     274        }
    275275};
    276276
    … …  
    281281class Verbose
    282282{
    283   public:
    284     Verbose(int value) : Verbosity(value) { }
    285 
    286     ostream& print (ostream &ost) const;
    287   private:
    288     int Verbosity;
     283        public:
     284                Verbose(int value) : Verbosity(value) { }
     285
     286                ostream& print (ostream &ost) const;
     287        private:
     288                int Verbosity;
    289289};
    290290
    … …  
    295295class Binary
    296296{
    297   public:
    298     Binary(int value) : BinaryNumber(value) { }
    299 
    300     ostream& print (ostream &ost) const;
    301   private:
    302     int BinaryNumber;
     297        public:
     298                Binary(int value) : BinaryNumber(value) { }
     299
     300                ostream& print (ostream &ost) const;
     301        private:
     302                int BinaryNumber;
    303303};
    304304
Note: See TracChangeset for help on using the changeset viewer.