Changeset 907 for library/bdm/base/bdmbase.h

Timestamp:

04/19/10 12:44:57 (14 years ago)

Author:

mido

Message:

LOG LEVEL improved and hopefully finished

Files:

• library/bdm/base/bdmbase.h (modified) (11 diffs)

library/bdm/base/bdmbase.h

@@ -86 +86 @@
         //! Internal global variable storing names of RVs
         static Array<string> NAMES;
-
         //! TODO
         const static int BUFFER_STEP;
-
         //! TODO
         static str2int_map MAP;
@@ -141 +139 @@
         RV() : dsize ( 0 ), len ( 0 ), ids ( 0 ), times ( 0 ) {}
 
-        //! Constructor of a single RV with given id
+        //! Constructor of a single RV 
         RV ( string name, int sz, int tm = 0 );
+
+        //! Constructor of a single nameless RV 
+        RV ( int sz, int tm = 0 );
 
         // compiler-generated copy constructor is used
@@ -295 +296 @@
 RV concat ( const RV &rv1, const RV &rv2 );
 
+
+//! This class stores a details that will be logged to a logger
+template<class T> class log_level_template : public log_level_base {
+        //! this is necessary to allow logger to set ids vector appropriately and also to set registered_logger
+        friend class logger; 
+
+        //! vector of log IDs - one element for each entry
+        ivec ids;
+
+        //! internal pointer to the logger to which this log_level is registered
+        //! 
+        //! it is set to NULL at the beginning
+        logger * registered_logger;
+
+public:
+        //! default constructor
+        log_level_template() {
+                registered_logger = NULL;
+                ids.set_size(  T::log_level_names().length() );
+                ids = -1;
+        }
+
+        //! This method stores a vector to the proper place in registered logger 
+        void store( const enum T::log_level_enums log_level_enum, const vec &vect ) const
+        {
+                bdm_assert_debug( registered_logger != NULL, "You have to register instance to a logger first! Use root::log_register(...) method.");
+                bdm_assert_debug( ids( log_level_enum ) >= 0, "This particular vector was not added to logger! Use logger::add_vector(...) method.");
+                registered_logger->log_vector( ids( log_level_enum ), vect );
+        }
+
+        //! This method stores a double to the proper place in registered logger 
+        void store( const enum T::log_level_enums log_level_enum, const double &dbl ) const
+        {
+                bdm_assert_debug( registered_logger != NULL, "You have to register instance to a logger first! See root::log_register(...) method.");
+                bdm_assert_debug( ids( log_level_enum ) >= 0, "This particular double was not added to logger! Use logger::add_vector(...) method.");
+                registered_logger->log_double( ids( log_level_enum ), dbl );
+        }
+
+        //! This method stores a Setting obtained by call of UI::save( data, .. ) to the proper place in registered logger 
+        template<class U> void store( const enum T::log_level_enums log_level_enum, const U data ) const
+        {                       
+                bdm_assert_debug( registered_logger != NULL, "You have to register instance to a logger first! See root::log_register(...) method.");
+                bdm_assert_debug( ids( log_level_enum ) >= 0, "This particular vector was not added to logger! Use logger::add_setting(...) method.");
+                registered_logger->log_setting( ids( log_level_enum ), data);
+        }
+
+
+        //! string equivalents of the used enumerations which are filled with a help of #LOG_LEVEL macro within class T
+        const Array<string> &names() const
+        {
+                return T::log_level_names();
+        }
+
+        //! read only operator for testing  individual fields of log_level
+        //!
+        //! it is necessary to acces it with a proper enumeration type, thus this approach is type-safe
+        bool operator [] (const enum T::log_level_enums &log_level_enum ) const
+        {
+                return values[log_level_enum];
+        }
+
+        //! operator for setting an individual field of log_level 
+        //!
+        //! it is necessary to acces it with a proper enumeration type, thus this approach is type-safe
+        bitset<32>::reference operator [] (const enum T::log_level_enums &log_level_enum )
+        {
+                return values[log_level_enum];
+        }
+};
+
+/*!
+  \def LOG_LEVEL(classname,...)
+  \brief Macro for defining a log_level attribute with a specific set of enumerations related to a specific class 
+
+  This macro has to be called within a class declaration. Its argument \a classname has to correspond to that wrapping class.
+  This macro defines a log_level instance which can be modified either directly or by the means of #UI class.
+
+  One of the main purposes of this macro is to allow variability in using enumerations. By relating them to their names through
+  an array of strings, we are no more dependant on their precise ordering. What is more, we can add or remove any without harming 
+  any applications which are using this library.
+
+  \todo Write a more detailed explanation including also examples
+
+  \ref ui
+*/
+#define LOG_LEVEL(classname,...) public: enum log_level_enums { __VA_ARGS__ }; log_level_template<classname> log_level; private: friend class log_level_template<classname>; static const Array<string> &log_level_names() { static const Array<string> log_level_names = log_level_base::string2Array( #__VA_ARGS__ ); return log_level_names; }
+
+
 /*!
 @brief Class for storing results (and semi-results) of an experiment
@@ -301 +390 @@
 */
 class logger : public root {
+private:
+        //! this method removes a "log" prefix from a string, i.e., it transforms "logevidence" to "evidence"
+        //!
+        //! for other cases, it keeps string unchanged
+        static string remove_log_prefix_if_possible( string name_with_prefix );
 protected:
         //! RVs of all logged variables.
@@ -310 +404 @@
         //! list of Settings for specific ids
         Array<Setting*> settings;
-public:
-        //!Default constructor
-        logger ( const string separator0 ) : entries ( 0 ), names ( 0 ), separator ( separator0 ) {}
-
+
+        //! log this instance to Setting
+        //!
+        //! this method has to be called only through \c log_level class to assure the validity of the passed id
+        template<class U> void log_setting ( int id, const U data ) {
+                UI::save(data, *settings ( id ) );
+        }
+
+        //! log this vector 
+        //!
+        //! this method has to be called only through \c log_level class to assure the validity of the passed id
+        virtual void log_vector ( int id, const vec &v ) NOT_IMPLEMENTED_VOID;
+
+        //! log this double
+        //!
+        //! this method has to be called only through \c log_level class to assure the validity of the passed id
+        virtual void log_double ( int id, const double &d ) NOT_IMPLEMENTED_VOID;
+
+        //! it is necessary to allow log_levels to call log_setting, log_vector and log_double methods
+        template<class T> friend class log_level_template;
+public:
         //!separator of prefixes of entries
         //!
@@ -319 +430 @@
         const string separator;
 
-
-        //! returns an identifier which will be later needed for calling the \c logit() function
-        //! For empty RV it returns -1, this entry will be ignored by \c logit().
-        virtual int add_vector ( const RV &rv, const string &prefix, const string &name = "" );
-
-        virtual int add_setting ( const string &prefix );
-
-        //! log this vector
-        virtual void log_vector ( int id, const vec &v ) = 0;
-
-        virtual Setting & log_to_setting ( int id ) {
-                return settings ( id )->add ( Setting::TypeGroup );
-        }
-        //! log this double
-        virtual void logit ( int id, const double &d ) = 0;
+        //!Default constructor
+        logger ( const string separator ) : entries ( 0 ), names ( 0 ), separator ( separator ) {}
+
+        //!Destructor calls the finalize method
+        ~logger() {
+                finalize(); 
+        }
+
+        //! sets up the ids identifier in the passed log_level instance to permit future calls of the log_level_template<T>::store(...) method
+        //!
+        //! It also sets a pointer to logger or justify it is correctly assigned from previous call to this procedure 
+        //! Entries with empty RV will be ignored 
+        template<class T> void add_vector ( log_level_template<T> &log_level, enum T::log_level_enums const log_level_enum, const RV &rv, const string &prefix )
+        {
+                if( !log_level.registered_logger )
+                        log_level.registered_logger = this;
+                else
+                        bdm_assert_debug ( log_level.registered_logger == this, "This log_level is already registered to another logger!");
+
+
+                if ( rv._dsize() == 0 ) 
+                        return;
+                
+                int id = entries.length();
+                string adjusted_name = remove_log_prefix_if_possible( log_level.names()(log_level_enum) );
+                names = concat ( names, prefix + separator + adjusted_name ); // diff
+                entries.set_length ( id + 1, true );
+                entries ( id ) = rv;
+                log_level.ids(log_level_enum) = id; 
+        }
+
+        //! sets up the ids identifier in the passed log_level instance to permit future calls of the log_level_template<T>::store(...) method
+        //!
+        //! It also sets a pointer to logger or justify it is correctly assigned from previous call to this procedure 
+        template<class T> void add_setting ( log_level_template<T> &log_level, enum T::log_level_enums const log_level_enum,  const string &prefix ) {
+                if( !log_level.registered_logger )
+                        log_level.registered_logger = this;
+                else
+                        bdm_assert_debug ( log_level.registered_logger == this, "This log_level is already registered to another logger!");
+
+                Setting &root = setting_conf.getRoot(); 
+                int id = root.getLength(); //root must be group!!
+                settings.set_length ( id + 1, true );                   
+                string adjusted_name = remove_log_prefix_if_possible( log_level.names()(log_level_enum) );
+                settings ( id ) = &root.add ( prefix + separator + adjusted_name, Setting::TypeList );          
+                log_level.ids(log_level_enum) = id; 
+        }
 
         //! Shifts storage position for another time step.
@@ -339 +482 @@
 
         //! Finalize storing information
+        //!
+        //! This method is called either directly or via destructor ~logger(), therefore it has to permit repetitive calls for the case it is called twice
         virtual void finalize() {};
 
@@ -344 +489 @@
         virtual void init() {};
 };
-
-
 
 //! Class representing function \f$f(x)\f$ of variable \f$x\f$ represented by \c rv
@@ -907 +1050 @@
 
 class DS : public root {
-        //! \var log_level_enums dt
+        //! \var log_level_enums logdt
         //! TODO DOPLNIT
-        LOG_LEVEL(DS, dt);
+
+        //! \var log_level_enums logut 
+        //! TODO DOPLNIT
+        LOG_LEVEL(DS,logdt,logut);
 
 protected:
@@ -923 +1069 @@
         //! default constructors
         DS() : dtsize ( 0 ), utsize ( 0 ), Drv(), Urv(){
-                log_level[dt] = true;
+                log_level[logdt] = true;
+                log_level[logut] = true;
         };
 
@@ -967 +1114 @@
                 Urv = urv;
         }
+
+        void from_setting ( const Setting &set );
+
+        void validate();
 };