source: molecuilder/src/helpers.hpp@ d50d2a

/** \file helpers.hpp
 *
 * Declaration of some auxiliary functions for memory dis-/allocation and so on 
 */

#ifndef HELPERS_HPP_
#define HELPERS_HPP_

using namespace std;

#include <iostream>
#include <iomanip>
#include <fstream>
#include <sstream>
#include <math.h>
#include <string>
#include <stdio.h>
#include <stdlib.h>
#include <time.h>

#include "defs.hpp"

// include config.h
#ifdef HAVE_CONFIG_H
#include <config.h>
#endif

/********************************************** helpful functions *********************************/

// taken out of TREMOLO
/*@-namechecks@*/
#ifndef __GNUC__
# undef __attribute__
# define __attribute__(x)
#endif
/*@=namechecks@*/

/* Behandelt aufgetretene Fehler. error ist der Fehlertyp(enum Errors)
   void *SpecialData ist ein untypisierter Zeiger auf Spezielle Daten zur Fehlerbehandlung.
   Man koennte auch noch einen Zeiger auf eine Funktion uebergeben */
extern void /*@exits@*/ debug(const char *output);
  //__attribute__ ((__return__));
#define debug(data) debug_in((data), __FILE__, __LINE__)

extern void /*@exits@*/ debug_in(const char *output,
    const char *file, const int line);
  //__attribute__ ((__return__));

double ask_value(const char *text);
bool check_bounds(double *x, double *cell_size);
void bound(double *b, double lower_bound, double upper_bound);
void flip(double *x, double *y);
int pot(int base, int n);
void * Malloc(size_t size, const char* output);
void * Calloc(size_t size, const char* output);
void * ReAlloc(void * OldPointer, size_t size, const char* output);
char* MallocString(size_t size, const char* output);
void Free(void ** buffer, const char* output);
char *FixedDigitNumber(const int FragmentNumber, const int digits);

/********************************************** helpful template functions *********************************/

/******************************** Some templates for list management ***********************************/

/** Adds linking of an item to a list.
 * \param *walker
 * \return true - adding succeeded, false - error in list
 */
template <typename X> void link(X *walker, X *end)
{
  X *vorher = end->previous;
  if (vorher != NULL)
    vorher->next = walker;
  end->previous = walker;
  walker->previous = vorher;
  walker->next = end;
};

/** Removes linking of an item in a list.
 * \param *walker
 * \return true - removing succeeded, false - given item not found in list
 */
template <typename X> void unlink(X *walker)
{
  if (walker->next != NULL) 
    walker->next->previous = walker->previous;
  if (walker->previous != NULL)
    walker->previous->next = walker->next;
};

/** Adds new item before an item \a *end in a list.
 * \param *pointer   item to be added
 * \param *end  end of list
 * \return true - addition succeeded, false - unable to add item to list
 */
template <typename X>  bool add(X *pointer, X *end)
{
  if (end != NULL) {
    link(pointer, end);
  } else {
    pointer->previous = NULL;
    pointer->next = NULL; 
  }
  return true;
};

/** Finds item in list
 * \param *suche  search criteria
 * \param *start  begin of list
 * \param *end  end of list
 * \return X - if found, NULL - if not found
 */
template <typename X, typename Y> X * find(Y *suche, X *start, X *end)
{
  X *walker = start;
  while (walker->next != end) { // go through list
    walker = walker->next; // step onward beforehand
    if (*walker->sort == *suche) return (walker);
  }
  return NULL;
};

/** Removes an item from the list without check.
 * \param *walker item to be removed
 * \return true - removing succeeded, false - given item not found in list
 */
template <typename X> void removewithoutcheck(X *walker)
{
  if (walker != NULL) {
    unlink(walker);
    delete(walker);
    walker = NULL;
  }
};

/** Removes an item from the list, checks if exists.
 * Checks beforehand if atom is really within molecule list.
 * \param *pointer   item to be removed
 * \param *start  begin of list
 * \param *end  end of list
 * \return true - removing succeeded, false - given item not found in list
 */
template <typename X> bool remove(X *pointer, X *start, X *end)
{
  X *walker = find (pointer->sort, start, end);
/*  while (walker->next != pointer) { // search through list
    walker = walker->next;
    if (walker == end) return false;  // item not found in list
  }*/
  // atom found, now unlink
  if (walker != NULL)
    removewithoutcheck(walker);
  else
    return false;
  return true;
};

/** Cleans the whole list.
 * \param *start begin of list
 * \param *end end of list
 * \return true - list was cleaned successfully, false - error in list structure
 */
template <typename X> bool cleanup(X *start, X *end)
{
  X *pointer = start->next;
  X *walker;
  while (pointer != end) { // go through list
    walker = pointer; // mark current
    pointer = pointer->next; // step onward beforehand
    // remove walker
    unlink(walker);
    delete(walker);
    walker = NULL;
  }
  return true;
};

/** Returns the first marker in a chain list.
 * \param *me one arbitrary item in chain list
 * \return poiner to first marker
 */
template <typename X> X *GetFirst(X *me)
{
  X *Binder = me;
  while(Binder->previous != NULL)
    Binder = Binder->previous;
  return Binder;
}; 

/** Returns the last marker in a chain list.
 * \param *me one arbitrary item in chain list
 * \return poiner to last marker
 */
template <typename X> X *GetLast(X *me)
{
  X *Binder = me;
  while(Binder->next != NULL)
    Binder = Binder->next;
  return Binder;
}; 

/** Frees a two-dimensional array.
 * \param *ptr pointer to array
 * \param dim first dim of array
 */
template <typename X> void Free2DArray(X **ptr, int dim)
{
  int i;
  if (ptr != NULL) {
    for(i=0;i<dim;i++)
      if (ptr[i] != NULL)
        free(ptr[i]);
    free(ptr);
  }
};

/************************************* Class Verbose & Binary *******************************/

/** Verbose is an IO manipulator, that writes tabs according to \a Verbosity level.
 */
class Verbose
{
  public:
    Verbose(int value) : Verbosity(value) { }

    ostream& print (ostream &ost) const;
  private:
    int Verbosity;
};

ostream& operator<<(ostream& ost,const Verbose& m);

/** Binary is an IO manipulator, that writes 0 and 1 according to number \a Binary.
 */
class Binary
{
  public:
    Binary(int value) : BinaryNumber(value) { }

    ostream& print (ostream &ost) const;
  private:
    int BinaryNumber;
};

ostream& operator<<(ostream& ost,const Binary& m);



#endif /*HELPERS_HPP_*/