/home66/gary/public_html/cloudy/c08_branch/source/utilitymacros.h

Go to the documentation of this file.

/* This file is part of Cloudy and is copyright (C)1978-2008 by Gary J. Ferland and
 * others.  For conditions of distribution and use see copyright notice in license.txt */

#ifndef _UTILITYMACROS_H_
#define _UTILITYMACROS_H_





/*
// ------------- include guards -----------------             
*/
                                                              

#ifdef UTILITYMACROS_H                                        
#  error Multiple #included file!
#endif
#define UTILITYMACROS_H


/* --------------- definitions ------------------ */


#define REPEAT_2(x)       x x
#define REPEAT_4(x)       REPEAT_2   (x)  REPEAT_2   (x)
#define REPEAT_8(x)       REPEAT_4   (x)  REPEAT_4   (x)
#define REPEAT_16(x)      REPEAT_8   (x)  REPEAT_8   (x)
#define REPEAT_32(x)      REPEAT_16  (x)  REPEAT_16  (x)
#define REPEAT_64(x)      REPEAT_32  (x)  REPEAT_32  (x)
#define REPEAT_128(x)     REPEAT_64  (x)  REPEAT_64  (x)
#define REPEAT_256(x)     REPEAT_128 (x)  REPEAT_128 (x)
#define REPEAT_512(x)     REPEAT_256 (x)  REPEAT_256 (x)
#define REPEAT_1024(x)    REPEAT_512 (x)  REPEAT_512 (x)


#define REPEAT(count, what)   REPEAT_##count (what)


#define REPEAT_WC_2(x)    x, x
#define REPEAT_WC_4(x)    REPEAT_WC_2   (x), REPEAT_WC_2   (x)  
#define REPEAT_WC_8(x)    REPEAT_WC_4   (x), REPEAT_WC_4   (x)  
#define REPEAT_WC_16(x)   REPEAT_WC_8   (x), REPEAT_WC_8   (x)
#define REPEAT_WC_32(x)   REPEAT_WC_16  (x), REPEAT_WC_16  (x)
#define REPEAT_WC_64(x)   REPEAT_WC_32  (x), REPEAT_WC_32  (x)
#define REPEAT_WC_128(x)  REPEAT_WC_64  (x), REPEAT_WC_64  (x)  
#define REPEAT_WC_256(x)  REPEAT_WC_128 (x), REPEAT_WC_128 (x)
#define REPEAT_WC_512(x)  REPEAT_WC_256 (x), REPEAT_WC_256 (x)
#define REPEAT_WC_1024(x) REPEAT_WC_512 (x), REPEAT_WC_512 (x)


#define REPEAT_WC(count, text)   REPEAT_WC_##count (text)


#define UNIQUE_NAME_1(prefix, x)   prefix##x
#define UNIQUE_NAME_2(prefix, x)   UNIQUE_NAME_1 (prefix, x)

#define UNIQUE_NAME_WP(prefix)  UNIQUE_NAME_2 (prefix, __LINE__)

#define UNIQUE_NAME           UNIQUE_NAME_WP (uniqueNameOnLine_)


#define LINE_STRING_1(x)   #x
#define LINE_STRING_2(x)   LINE_STRING_1 (x)

#define LINE_STRING        LINE_STRING_2 (__LINE__)


#define HERE  __FILE__ "("  LINE_STRING "):"


#define ONCE(execution_code)           \
   {                                   \
   static int UNIQUE_NAME = 0;         \
   if( !UNIQUE_NAME )                  \
      {                                \
      UNIQUE_NAME = 1;                 \
         { execution_code }            \
      }                                \
   }


#define SKIP(skip_count, execution_code)        \
   {                                            \
   static int UNIQUE_NAME = 0;                  \
   if( ++UNIQUE_NAME >= (skip_count) )          \
      {                                         \
      UNIQUE_NAME = 0;                          \
         { execution_code }                     \
      }                                         \
   }


#define REV_SKIP(skip_count, execution_code)    \
   {                                            \
   static int UNIQUE_NAME = 0;                  \
   if( ++UNIQUE_NAME >= (skip_count) )          \
      UNIQUE_NAME = 0;                          \
   else                                         \
      {                                         \
      execution_code                            \
      }                                         \
   }


#define LOOP_C(count, loop_code)                \
                                                \
   {                                            \
   int UNIQUE_NAME = (count);                   \
   for(; UNIQUE_NAME > 0; --UNIQUE_NAME)        \
       { loop_code }                            \
   }


#define LOOP(count)    for(int UNIQUE_NAME = (count);     \
                                UNIQUE_NAME > 0;          \
                                --UNIQUE_NAME)                 
                         /* loop body here*/


#define AT_START(execution_code)                \
                                                \
   static struct t_UNIQUE_NAME                  \
            {                                   \
            UNIQUE_NAME()                       \
               {                                \
               execution_code                   \
               }                                \
            }                                   \
      UNIQUE_NAME_WP (atStartVarOnLine_);                       


#define AT_END(execution_code)                  \
                                                \
   static struct t_UNIQUE_NAME                  \
            {                                   \
            ~UNIQUE_NAME()                      \
               {                                \
               execution_code                   \
               }                                \
            }                                   \
      UNIQUE_NAME_WP (atStartVarOnLine_);  


class DelayedAssigner_T_Base
{
public:
virtual ~DelayedAssigner_T_Base()
   {}
};


template <class Type>
class DelayedAssigner_T : public DelayedAssigner_T_Base
{
Type& itsVarRef;    /* Reference to be assigned to*/
Type  itsValue;     /* Value to be remembered and assigned*/
     
public:
DelayedAssigner_T (Type &var_ref) 
   : itsVarRef (var_ref)
   , itsValue  (var_ref)
   {}

DelayedAssigner_T (Type &var_ref, const Type &value) /* separate*/
   : itsVarRef (var_ref)
   , itsValue  (value)
   {}

~DelayedAssigner_T()
   {
   itsVarRef = itsValue;  
   }
};


#define DELAYED_ASSIGN_T(Type, var_ref, value)            \
                                                          \
   DelayedAssigner_T<Type> UNIQUE_NAME (var_ref, value);


#define SAVE_T(Type, var_ref)                             \
                                                          \
      DelayedAssigner_T<Type> UNIQUE_NAME (var_ref);


template <class Type> inline 
DelayedAssigner_T<Type> makeDelayedAssigner_T (Type &var)
   {
   return DelayedAssigner_T<Type> (var);
   } 

template <class Type> inline 
DelayedAssigner_T <Type>
makeDelayedAssigner_T (Type &var, const Type& value)
   {
   return DelayedAssigner_T<Type> (var, value);
   } 


template <class Type> inline 
DelayedAssigner_T_Base* newDelayedAssigner_T (Type &var)
   {
   return new DelayedAssigner_T<Type> (var);
   } 


template <class Base, size_t SIZE>
class UnivesalStorage_T
{
char itsStorage [SIZE];  /* binary storage*/
public:

template <class From>   
UnivesalStorage_T (const From& from)
   {
   /* Static checks for mismatched parameter type:*/
   typedef char assertSize [sizeof (from) == SIZE];
        /* will not compile if sizeof 'From' is wrong*/
   if(const Base* assertInheritence = &from)
      (void)0;/* will not compile if 'From' is not : public Base */

   new (itsStorage) From (from); /* placement new & copy ctor*/
   }

~UnivesalStorage_T()
   {
   ((Base*)itsStorage)->~Base(); /* hopefully virtual*/
   }
};


#define SAVE(var_ref)                                          \
                                                               \
   UnivesalStorage_T                                           \
         < DelayedAssigner_T_Base,                             \
           sizeof (makeDelayedAssigner_T (var_ref)) >          \
      UNIQUE_NAME (makeDelayedAssigner_T (var_ref));


#define DELAYED_ASSIGN(var_ref, value)                         \
                                                               \
   UnivesalStorage_T                                           \
         < DelayedAssigner_T_Base,                             \
           sizeof (makeDelayedAssigner_T (var_ref)) >          \
      UNIQUE_NAME (makeDelayedAssigner_T ((var_ref), (value)));


/* ---------------------- end of file ------------------------*/

#endif /* _UTILITYMACROS_H_ */

---