inverse.h

Go to the documentation of this file.

/////////////////////////////////////////////////////////////////////////////////////////
/// \file  inverse.h
/// \brief Declaration of the SPARK::TInverse class 
///
/////////////////////////////////////////////////////////////////////////////////////////
/// \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.
///
/////////////////////////////////////////////////////////////////////////////////////////
/// \author  Dimitri Curtil (LBNL/SRG)
/// \date    January 10, 2003
/////////////////////////////////////////////////////////////////////////////////////////


#if !defined(__INVERSE_H__)
#define __INVERSE_H__

#include <memory>     // for std::auto_ptr<>

#include "callback.h"
#include "types.h"    // for AtomicTypes
#include "compat.h"   // for CLASS_DECLSPEC



/////////////////////////////////////////////////////////////////////////////////////////
namespace SPARK {

        /////////////////////////////////////////////////////////////////////////////////////
        // Forward declaration
        /////////////////////////////////////////////////////////////////////////////////////
        class TProblem;
        class TObject;
        class TInverseHandler;
        class inverse_adaptor;


        /////////////////////////////////////////////////////////////////////////////////////
        /// \class TInverse
        /// \brief Class that defines the callbacks for an inverse.
        ///
        /// Also contains all instances as SPARK::TObject objects of an inverse, as well as the void* 
        /// pointer to the static data. 
        ///
        class CLASS_DECLSPEC TInverse {
        public:
                /////////////////////////////////////////////////////////////////////////////////
                // Structors
                TInverse(
                        unsigned handle,
                        const char* name, 
                        const char* classname, 
                        const char* fileName, 
                        SPARK::AtomicTypes type,
                        const TModifierCallback& predict,           
                        const TModifierCallback& evaluate,
                        const TNonModifierCallback& construct,      
                        const TNonModifierCallback& destruct,
                        const TNonModifierCallback& prepare_step,   
                        const TPredicateCallback& check_integration_step,
                        const TNonModifierCallback& rollback,       
                        const TNonModifierCallback& commit,
                        const TStaticNonModifierCallback& static_construct,    
                        const TStaticNonModifierCallback& static_destruct,
                        const TStaticNonModifierCallback& static_prepare_step, 
                        const TStaticPredicateCallback& static_check_integration_step,
                        const TStaticNonModifierCallback& static_rollback,     
                        const TStaticNonModifierCallback& static_commit
                );
                ~TInverse() SPARK_NOT_THROWING;
                /////////////////////////////////////////////////////////////////////////////////


                /////////////////////////////////////////////////////////////////////////////////
                /// \name Access methods
                //@{
                /// Returns unique inverse handle as specified in XML file 
                unsigned GetHandle() const ;

                /// Returns name of inverse as specified in XML file as <code>const char* </code>
                const char* GetName() const ;
                
                /// Returns class name as specified in XML file as <code>const char* </code>
                const char* GetAtomicClassName() const;
                
                /// Returns file name of atomic class where the inverse is declared as <code>const char* </code>
                const char* GetFileName() const ;
                
                /// Returns the type of the inverse as SPARK::AtomicTypes
                SPARK::AtomicTypes GetAtomicType() const;

                /// Returns the name of the currently active callback, Returns "" if none active!
                const char* GetActiveCallbackName() const;

                /// Returns the number of TObject instances of this inverse
                unsigned GetNumObjects() const;
                
                /// Returns instance idx as a SPARK::TObject pointer 
                SPARK::TObject* GetObject(unsigned idx);
                
                /// Returns pointer to SPARK::TProblem object this inverse belongs to
                const SPARK::TProblem* GetProblem() const;

                /// Returns value of relative tolerance currently used by solver
                double GetTolerance() const ;
                //@}
                /////////////////////////////////////////////////////////////////////////////////


                /////////////////////////////////////////////////////////////////////////////////
                /// \name Data methods
                //@{
                /// Returns static private data as <code>void* </code>
                void* GetStaticData() { return StaticData; }
                
                /// Sets the static private data to \c address
                void SetStaticData(void* address) { StaticData = address; }
                //@}
                /////////////////////////////////////////////////////////////////////////////////


        private:
                /////////////////////////////////////////////////////////////////////////////////
                // Private Methods
                /////////////////////////////////////////////////////////////////////////////////
                TInverse();
                TInverse(const TInverse& ); // Copy constructor
                TInverse& operator=(const TInverse& );

                // Called internally by TObject's constructor to self-register itself
                unsigned RegisterInstance(SPARK::TObject* object);
                friend class SPARK::TObject;


                /////////////////////////////////////////////////////////////////////////////////
                // Private Data
                /////////////////////////////////////////////////////////////////////////////////
        const std::auto_ptr<SPARK::TInverseHandler>  Handler;    ///< Pimpl object
                void*                                        StaticData; ///< void* pointer to hold static private data

                friend class SPARK::inverse_adaptor;
        };
        /////////////////////////////////////////////////////////////////////////////////////


}; // namespace SPARK
/////////////////////////////////////////////////////////////////////////////////////////


#endif // __INVERSE_H__

---