sparkmacro.h

Go to the documentation of this file.

/////////////////////////////////////////////////////////////////////////////////////////
/// \file  sparkmacro.h  
/// \brief Header file defining the preprocessor macros required to build a static 
///        %SPARK problem from the *.cpp file describing the problem topology.
///
/// This file is included in the "problem.cpp" file by setupcpp. It defines the macros 
/// required to compile the problem. There is a one-to-one matching between the XML
/// DTD used in the *.xml file and the preprocessor macros for each section.
/// See the file "spark2.dtd" in the example section.
///
/////////////////////////////////////////////////////////////////////////////////////////
///
/// \author  Dimitri Curtil (LBNL/SRG)
/// \date    July 9, 2002
///
/////////////////////////////////////////////////////////////////////////////////////////
/// \attention
/// PORTIONS COPYRIGHT (C) 2003 AYRES SOWELL ASSOCIATES, INC. \n
/// PORTIONS COPYRIGHT (C) 2003 THE REGENTS OF THE UNIVERSITY OF CALIFORNIA .
///   PENDING APPROVAL BY THE US DEPARTMENT OF ENERGY. ALL RIGHTS RESERVED.
///
/////////////////////////////////////////////////////////////////////////////////////////


#if !defined(__SPARKMACRO_H__)
#define __SPARKMACRO_H__


#include "variable.h"  // for class TVariable, class TUnknown
#include "callback.h"  // for class TArgument and class TTarget
#include "inverse.h"   // for class TInverse
#include "object.h"    // for class TObject
#include "component.h" // for class TComponent
#include "problem.h"   // for class TProblem
#include "sparkapi.h"
#include "spark.h"     // for predefined macros


/////////////////////////////////////////////////////////////////////////////////////////
// Macros for precompiled SPARK problem 
/////////////////////////////////////////////////////////////////////////////////////////


/// Causes the corresponding actual argument to be enclosed in double quotation marks
#define _QUOTE_(x)         #x

/// Prefixes name with underscore to make it a valid qualifier for a namespace
#define _NAMESPACE_(name)  _##name


///////////
// ARRAY //
///////////

/// \brief Defines a non-empty array for elements of the pre-defined type element_type. 
///        See #END_ARRAY.
#define START_ARRAY( size ) \
        const unsigned Size = size; \
        element_type Array[] = { \

/// Defines the end of a non-empty array. See #START_ARRAY.
#define END_ARRAY }; 

/// Defines an empty array of pre-defined type element_type
#define EMPTY_ARRAY \
        const unsigned Size = 0; \
        element_type* Array = 0; \



/////////////
// PROBLEM //
/////////////

/// \brief Starts the definition of a TProblem object named name. 
///        See #END_PROBLEM.
#define START_PROBLEM( name )   \
        namespace Problem__##name  {  \
                const char* Name = _QUOTE_(name); \

/// \brief Ends the definition of a TProblem object. 
///        Also takes care of registering the compiled problem pointer with SPARK environment.
///        See #START_PROBLEM.
#define END_PROBLEM \
        SPARK::TProblem Element( \
                        Inverses::Size, Inverses::Array, \
                        Variables::Size, Variables::Array, \
                        Components::Size, Components::Array \
                ); \
                bool IsRegistered = SPARK::Problem::RegisterStaticInstance( Name, &Element ); \
        }; \


//////////////
// INVERSES //
//////////////

/// \brief Start the declaration of list of inverse functions.
///        See #END_INVERSES.
#define START_INVERSES  namespace Inverses { \
        typedef SPARK::TInverse*  element_type; \

/// \brief Terminates the declaration of the list of inverse functions. 
///        See #START_INVERSES.
#define END_INVERSES    };

#define START_INVERSE( handle, name, className, fileName, type ) \
        namespace Inverse_##handle { \
                unsigned Handle = handle; \
                const char* Name = name; \
                const char* ClassName = className; \
                const char* FileName = fileName; \
                SPARK::AtomicTypes Type = SPARK::type; \

#define END_INVERSE \
                SPARK::TInverse Element( \
                        Handle, Name, ClassName, FileName, Type, \
                        Predict::Callback, Evaluate::Callback, \
                        Construct::Callback, Destruct::Callback, \
                        PrepareStep::Callback, CheckIntegrationStep::Callback, \
                        Rollback::Callback, Commit::Callback, \
                        StaticConstruct::Callback, StaticDestruct::Callback, \
                        StaticPrepareStep::Callback, StaticCheckIntegrationStep::Callback, \
                        StaticRollback::Callback, StaticCommit::Callback \
                ); \
        }; \

#define INVERSE( handle )  &Inverses::Inverse_##handle::Element


///////////////
// CALLBACKS //
///////////////

// Modifiers
#define DECL_MODIFIER_CALLBACK( type, name, function, returnType )  \
        namespace name { \
                SPARK::TModifierCallback Callback( SPARK::type, _QUOTE_(function), &function, SPARK::returnType); \
        }; \

#define NO_MODIFIER_CALLBACK( type, name )  \
        namespace name { \
                SPARK::TModifierCallback Callback( SPARK::type ); \
        }; \

#define DECL_EVALUATE_CALLBACK( function, returnType )   DECL_MODIFIER_CALLBACK( CallbackType_EVALUATE, Evaluate, function, returnType )
#define NO_EVALUATE_CALLBACK                             NO_MODIFIER_CALLBACK( CallbackType_EVALUATE, Evaluate )

#define DECL_PREDICT_CALLBACK( function, returnType )    DECL_MODIFIER_CALLBACK( CallbackType_PREDICT, Predict, function, returnType )
#define NO_PREDICT_CALLBACK                              NO_MODIFIER_CALLBACK( CallbackType_PREDICT, Predict )


// Non-Modifiers
#define DECL_NON_MODIFIER_CALLBACK( type, name, function )  \
        namespace name { \
                SPARK::TNonModifierCallback Callback( SPARK::type, _QUOTE_(function), &function ); \
        }; \

#define NO_NON_MODIFIER_CALLBACK( type, name )  \
        namespace name { \
                SPARK::TNonModifierCallback Callback( SPARK::type ); \
        }; \

#define DECL_CONSTRUCT_CALLBACK( function )          DECL_NON_MODIFIER_CALLBACK( CallbackType_CONSTRUCT, Construct, function )
#define NO_CONSTRUCT_CALLBACK                        NO_NON_MODIFIER_CALLBACK( CallbackType_CONSTRUCT, Construct )

#define DECL_DESTRUCT_CALLBACK( function )           DECL_NON_MODIFIER_CALLBACK( CallbackType_DESTRUCT, Destruct, function )
#define NO_DESTRUCT_CALLBACK                         NO_NON_MODIFIER_CALLBACK( CallbackType_DESTRUCT, Destruct )

#define DECL_PREPARE_STEP_CALLBACK( function )       DECL_NON_MODIFIER_CALLBACK( CallbackType_PREPARE_STEP, PrepareStep, function )
#define NO_PREPARE_STEP_CALLBACK                     NO_NON_MODIFIER_CALLBACK( CallbackType_PREPARE_STEP, PrepareStep )

#define DECL_ROLLBACK_CALLBACK( function )           DECL_NON_MODIFIER_CALLBACK( CallbackType_ROLLBACK, Rollback, function )
#define NO_ROLLBACK_CALLBACK                         NO_NON_MODIFIER_CALLBACK( CallbackType_ROLLBACK, Rollback )

#define DECL_COMMIT_CALLBACK( function )             DECL_NON_MODIFIER_CALLBACK( CallbackType_COMMIT, Commit, function )
#define NO_COMMIT_CALLBACK                           NO_NON_MODIFIER_CALLBACK( CallbackType_COMMIT, Commit )


// Predicates
#define DECL_PREDICATE_CALLBACK( type, name, function )  \
        namespace name { \
                SPARK::TPredicateCallback Callback( SPARK::type, _QUOTE_(function), &function ); \
        }; \

#define NO_PREDICATE_CALLBACK( type, name )  \
        namespace name { \
                SPARK::TPredicateCallback Callback( SPARK::type ); \
        }; \

#define DECL_CHECK_INTEGRATION_STEP_CALLBACK( function ) DECL_PREDICATE_CALLBACK( CallbackType_CHECK_INTEGRATION_STEP, CheckIntegrationStep, function )
#define NO_CHECK_INTEGRATION_STEP_CALLBACK               NO_PREDICATE_CALLBACK( CallbackType_CHECK_INTEGRATION_STEP, CheckIntegrationStep )


// Statics
#define DECL_STATIC_NON_MODIFIER_CALLBACK( type, name, function )  \
        namespace name { \
                SPARK::TStaticNonModifierCallback Callback( SPARK::type, _QUOTE_(function), &function ); \
        }; \

#define NO_STATIC_NON_MODIFIER_CALLBACK( type, name )  \
        namespace name { \
                SPARK::TStaticNonModifierCallback Callback( SPARK::type ); \
        }; \

#define DECL_STATIC_CONSTRUCT_CALLBACK( function )    DECL_STATIC_NON_MODIFIER_CALLBACK( CallbackType_STATIC_CONSTRUCT, StaticConstruct, function )
#define NO_STATIC_CONSTRUCT_CALLBACK                  NO_STATIC_NON_MODIFIER_CALLBACK( CallbackType_STATIC_CONSTRUCT, StaticConstruct )

#define DECL_STATIC_DESTRUCT_CALLBACK( function )     DECL_STATIC_NON_MODIFIER_CALLBACK( CallbackType_STATIC_DESTRUCT, StaticDestruct, function )
#define NO_STATIC_DESTRUCT_CALLBACK                   NO_STATIC_NON_MODIFIER_CALLBACK( CallbackType_STATIC_DESTRUCT, StaticDestruct )

#define DECL_STATIC_PREPARE_STEP_CALLBACK( function ) DECL_STATIC_NON_MODIFIER_CALLBACK( CallbackType_STATIC_PREPARE_STEP, StaticPrepareStep, function )
#define NO_STATIC_PREPARE_STEP_CALLBACK               NO_STATIC_NON_MODIFIER_CALLBACK( CallbackType_STATIC_PREPARE_STEP, StaticPrepareStep )

#define DECL_STATIC_ROLLBACK_CALLBACK( function )     DECL_STATIC_NON_MODIFIER_CALLBACK( CallbackType_STATIC_ROLLBACK, StaticRollback, function )
#define NO_STATIC_ROLLBACK_CALLBACK                   NO_STATIC_NON_MODIFIER_CALLBACK( CallbackType_STATIC_ROLLBACK, StaticRollback )

#define DECL_STATIC_COMMIT_CALLBACK( function )       DECL_STATIC_NON_MODIFIER_CALLBACK( CallbackType_STATIC_COMMIT, StaticCommit, function )
#define NO_STATIC_COMMIT_CALLBACK                     NO_STATIC_NON_MODIFIER_CALLBACK( CallbackType_STATIC_COMMIT, StaticCommit )


// Static Predicates
#define DECL_STATIC_PREDICATE_CALLBACK( type, name, function )  \
        namespace name { \
                SPARK::TStaticPredicateCallback Callback( SPARK::type, _QUOTE_(function), &function ); \
        }; \

#define NO_STATIC_PREDICATE_CALLBACK( type, name )  \
        namespace name { \
                SPARK::TStaticPredicateCallback Callback( SPARK::type ); \
        }; \

#define DECL_STATIC_CHECK_INTEGRATION_STEP_CALLBACK( function )   DECL_STATIC_PREDICATE_CALLBACK( CallbackType_STATIC_CHECK_INTEGRATION_STEP, StaticCheckIntegrationStep, function )
#define NO_STATIC_CHECK_INTEGRATION_STEP_CALLBACK                 NO_STATIC_PREDICATE_CALLBACK( CallbackType_STATIC_CHECK_INTEGRATION_STEP, StaticCheckIntegrationStep )



///////////////
// VARIABLES // 
///////////////

#define START_VARIABLES   \
        namespace Variables { \
                typedef SPARK::TVariable*  element_type; \

#define END_VARIABLES  }; 

#define VARIABLE( handle )  &Variables::Variable_##handle::Element

#define DECL_VARIABLE( handle, name, unit, type, init, min, max, atol, from_link, rd_url, wr_url ) \
        namespace Variable_##handle { \
                SPARK::TVariable Element( handle, name, unit, SPARK::type, init, min, max, atol, from_link, rd_url, wr_url); \
        }; \


//////////////
// UNKNOWNS //
////////////// 

#define START_UNKNOWNS( name, size ) \
        namespace name { \
                typedef SPARK::TUnknown  element_type; \
                START_ARRAY( size ) \

#define END_UNKNOWNS( name ) \
                END_ARRAY \
        }; \

#define NO_UNKNOWNS( name ) \
        namespace name { \
                typedef SPARK::TUnknown  element_type; \
                EMPTY_ARRAY \
        }; \

#define DECL_UNKNOWN( var_id )  SPARK::TUnknown( VARIABLE( var_id ) )



/////////////
// TARGETS //
/////////////

#define START_TARGETS( size ) \
        namespace Targets { \
                typedef SPARK::TTarget  element_type; \
                START_ARRAY( size ) \

#define END_TARGETS \
                END_ARRAY \
        }; \

#define NO_TARGETS \
        namespace Targets { \
                typedef SPARK::TTarget  element_type; \
                EMPTY_ARRAY \
        }; \

#define DECL_TARGET( var_id )  SPARK::TTarget( VARIABLE( var_id ) ) 



///////////////
// ARGUMENTS //
///////////////

#define START_ARGUMENTS( name, size ) \
        namespace name { \
                typedef SPARK::TArgument  element_type; \
                START_ARRAY( size ) \

#define END_ARGUMENTS( name ) \
                END_ARRAY \
        }; \

#define NO_ARGUMENTS( name ) \
        namespace name { \
                typedef SPARK::TArgument  element_type; \
                EMPTY_ARRAY \
        }; \

#define DECL_ARGUMENT( var_id )  SPARK::TArgument( VARIABLE( var_id ) ) 



////////////////
// COMPONENTS //
////////////////

#define START_COMPONENTS \
        namespace Components { \
                typedef SPARK::TComponent*  element_type; \

#define END_COMPONENTS  };



///////////////
// COMPONENT //
///////////////

#define START_COMPONENT( handle )  \
        namespace Component_##handle { \
                const unsigned Handle = handle; \

#define END_COMPONENT  \
                SPARK::TComponent Element(\
                        Handle, \
                        NormalUnknowns::Size, NormalUnknowns::Array, \
                        BreakUnknowns::Size, BreakUnknowns::Array, \
                        Objects::Size, Objects::Array \
                ); \
        }; \

#define COMPONENT( handle )  &Components::Component_##handle::Element


#define START_NORMAL_UNKNOWNS( size )  START_UNKNOWNS( NormalUnknowns, size )
#define END_NORMAL_UNKNOWNS                END_UNKNOWNS( NormalUnknowns )
#define NO_NORMAL_UNKNOWNS             NO_UNKNOWNS( NormalUnknowns )

#define START_BREAK_UNKNOWNS( size )   START_UNKNOWNS( BreakUnknowns, size )
#define END_BREAK_UNKNOWNS             END_UNKNOWNS( BreakUnknowns )
#define NO_BREAK_UNKNOWNS              NO_UNKNOWNS( BreakUnknowns )


/////////////
// OBJECTS //
///////////// 

#define START_OBJECTS \
        namespace Objects { \
                typedef SPARK::TObject*  element_type; \

#define END_OBJECTS };  


////////////
// OBJECT //
////////////

#define START_OBJECT( handle, name, inverse ) \
        namespace Object_##handle { \
                const unsigned   Handle = handle; \
                const char*      Name   = name; \
                SPARK::TInverse* Inverse = inverse; \

#define END_OBJECT \
                SPARK::TObject Element( \
                        Handle, Name, Inverse, \
                        Targets::Size, Targets::Array, \
                        ArgList_Predict::Size, ArgList_Predict::Array, \
                        ArgList_Evaluate::Size, ArgList_Evaluate::Array, \
                        ArgList_Construct::Size, ArgList_Construct::Array, \
                        ArgList_Destruct::Size, ArgList_Destruct::Array, \
                        ArgList_PrepareStep::Size, ArgList_PrepareStep::Array, \
                        ArgList_CheckIntegrationStep::Size, ArgList_CheckIntegrationStep::Array, \
                        ArgList_Rollback::Size, ArgList_Rollback::Array, \
                        ArgList_Commit::Size, ArgList_Commit::Array \
                ); \
        }; \

#define OBJECT( handle )  &Object_##handle::Element


#define START_EVALUATE_ARGLIST( size )     START_ARGUMENTS( ArgList_Evaluate, size )
#define END_EVALUATE_ARGLIST               END_ARGUMENTS( ArgList_Evaluate )
#define NO_EVALUATE_ARGLIST                NO_ARGUMENTS( ArgList_Evaluate )

#define START_PREDICT_ARGLIST( size )      START_ARGUMENTS( ArgList_Predict, size )
#define END_PREDICT_ARGLIST                END_ARGUMENTS( ArgList_Predict )
#define NO_PREDICT_ARGLIST                 NO_ARGUMENTS( ArgList_Predict )

#define START_CONSTRUCT_ARGLIST( size )    START_ARGUMENTS( ArgList_Construct, size )
#define END_CONSTRUCT_ARGLIST              END_ARGUMENTS( ArgList_Construct )
#define NO_CONSTRUCT_ARGLIST               NO_ARGUMENTS( ArgList_Construct )

#define START_DESTRUCT_ARGLIST( size )     START_ARGUMENTS( ArgList_Destruct, size )
#define END_DESTRUCT_ARGLIST               END_ARGUMENTS( ArgList_Destruct )
#define NO_DESTRUCT_ARGLIST                NO_ARGUMENTS( ArgList_Destruct )

#define START_PREPARE_STEP_ARGLIST( size ) START_ARGUMENTS( ArgList_PrepareStep, size )
#define END_PREPARE_STEP_ARGLIST           END_ARGUMENTS( ArgList_PrepareStep )
#define NO_PREPARE_STEP_ARGLIST            NO_ARGUMENTS( ArgList_PrepareStep )

#define START_CHECK_INTEGRATION_STEP_ARGLIST( size )  START_ARGUMENTS( ArgList_CheckIntegrationStep, size )
#define END_CHECK_INTEGRATION_STEP_ARGLIST            END_ARGUMENTS( ArgList_CheckIntegrationStep )
#define NO_CHECK_INTEGRATION_STEP_ARGLIST             NO_ARGUMENTS( ArgList_CheckIntegrationStep )

#define START_COMMIT_ARGLIST( size )       START_ARGUMENTS( ArgList_Commit, size )
#define END_COMMIT_ARGLIST                 END_ARGUMENTS( ArgList_Commit )
#define NO_COMMIT_ARGLIST                  NO_ARGUMENTS( ArgList_Commit )

#define START_ROLLBACK_ARGLIST( size )     START_ARGUMENTS( ArgList_Rollback, size )
#define END_ROLLBACK_ARGLIST               END_ARGUMENTS( ArgList_Rollback )
#define NO_ROLLBACK_ARGLIST                NO_ARGUMENTS( ArgList_Rollback )


#endif //__SPARKMACRO_H__

---