Changeset 942 for library/bdm/base/user_info.h

Timestamp:

05/14/10 12:16:00 (14 years ago)

Author:

mido

Message:

the functionality of user info was improved, it supports an initialization of root descendant via UI::get directly, however it is save only for static attributes, for dynamically allocated attributes UI::build should be called to handle with intahrence issues

Files:

• library/bdm/base/user_info.h (modified) (13 diffs)

library/bdm/base/user_info.h

@@ -228 +228 @@
 };
 
+
+//! This class stores the details which will be logged to a logger
+//!
+//! This is only the first part of the whole declaration, which has to be however separated into
+//! two different classes for allowing the compilation of source code. For more details
+//! see logger::add_setting(...) method and mainly log_level_template<T>::template<class U> void store( const enum T::log_level_enums log_level_enum, const U data ) const
+//! method. For the reason the second one is templated, it was necessary to declare this whole class. 
+template<class T> class log_level_base : public root {
+private:
+        //! this is necessary to allow logger to set ids vector appropriately and also to set registered_logger
+        friend class logger; 
+
+protected:
+        //! boolean flags related indicating which details will be logged to a logger
+        bitset<32> values;
+        
+        //! vector of vectors of log IDs - one element for each entry and multiple entries can be stored on the position of one enum
+        Vec<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_base( ) {
+                registered_logger = NULL;
+                int len = names().length();
+                ids.set_size( len );
+                for( int i = 0; i<len; i++ )
+                {
+                        ids(i).set_size ( 1 );
+                        ids(i) = -1;
+                }
+        }
+
+        //! a general utility transforming a comma-separated sequence of strings into an instance of Array<strings>
+        static Array<string> string2Array( const string &input )
+        {
+                string result = input;
+                string::size_type loc;
+                while( loc = result.find( ',' ), loc != string::npos )
+                        result[loc] = ' ';
+                return Array<string>("{ " + result + " }" );
+        }
+
+
+
+        //! Set log_levels according to the Setting element
+        void from_setting ( const Setting &element )
+        {
+                string raw_log_level;
+                UI::get( raw_log_level, element );
+                Array<string> loaded_log_level = log_level_base::string2Array( raw_log_level );
+        
+                values.reset();
+
+                for( int i = 0; i < loaded_log_level.length(); i++ )
+                        for( int j = 0; j < names().length(); j++ ){
+                                if( loaded_log_level(i) == names()(j)  ) 
+                                {
+                                        values[j] = true;
+                                        break;
+                                } 
+                        }
+        }
+
+        //! Store log_levels into the Setting element
+        void to_setting ( Setting &element ) const 
+        {
+                // HERE WE WANT NOT TO DELETE PREVIOUS DATA STORED BY OTHER LOG_LEVELS, SEE SPECIAL IMPLEMENTATION OF UI::GET(...) FOR THIS CLASS
+                string string_to_write =  ( const char* ) element;
+
+                for( unsigned int i = 0; i < values.size(); i++ )
+                        if( values[i] ) 
+                        {
+                                if( string_to_write.length() > 0 )
+                                        string_to_write = string_to_write + ',';
+                                string_to_write = string_to_write + names()(i);
+                        }
+                        
+                element = string_to_write;
+        }
+
+        //! this method adds new id to its proper position and return the name of this position
+        string store_id_and_give_name( enum T::log_level_enums const log_level_enum,  int enum_subindex, int id ) {
+                if( ids(log_level_enum).length() <= enum_subindex )
+                        ids(log_level_enum).set_size( enum_subindex+1, true );
+                ids(log_level_enum)(enum_subindex) = id; 
+
+                // here we remove a "log" prefix from name, i.e., for instance it transforms "logevidence" to "evidence"
+                ostringstream stream;
+                string name_with_prefix = names()(log_level_enum);
+                string possible_log_prefix = name_with_prefix.substr(0,3);
+                if( possible_log_prefix == "log" )
+                        stream << name_with_prefix.substr(3,name_with_prefix.length()-3);
+                else 
+                        stream << name_with_prefix;
+
+                // add number to name only in the case there are more registered vectors with the same log_level_enum
+                if( ids(log_level_enum).length() > 1 )
+                        stream << "*" << enum_subindex;
+                
+                return stream.str();
+        }
+
+        //! 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];
+        }
+};
+//UIREGISTER IS FORBIDDEN FOR THIS CLASS,  AS IT SHOULD BE LOADED ONLY THROUGH THE SPECIALIZED UI::GET(...) METHOD
+
 /*!
 @brief UI is an abstract class which collects all the auxiliary functions useful to prepare some concrete
@@ -292 +424 @@
         static const Setting& to_child_setting ( const Setting &element, const string &name );
 
+        //! A shortcut for calling instance.from_setting( set ); with some error catches added
+        static void call_from_setting( root &instance, const Setting &set, string class_name = "unknown");
+
+        //! A shortcut for calling instance.to_setting( set ); with some error catches added
+        static void call_to_setting( const root &instance, Setting &set, string class_name = "unknown" );
+
         //! This method converts a Setting into a matrix
         static void from_setting ( mat& matrix, const Setting &element );
@@ -304 +442 @@
         //! This method converts a Setting into a real scalar   
         static void from_setting ( double &real, const Setting &element );
-        //! This method converts a Setting into a log_level variant and initialize options properly
-        static void from_setting ( log_level_base &log_level, const Setting &element );
-
+        //! This method converts a Setting into a class T descendant
+        static void from_setting ( root &instance, const Setting &element );
         //! This method converts a Setting into a class T descendant
         template<class T> static void from_setting ( T* &instance, const Setting &element ) {
@@ -330 +467 @@
 
                 try {
-                        instance->from_setting ( link.result );
-                } catch ( SettingException &sttng_xcptn ) {
-                        delete instance;
-                        instance = 0;
-                        string msg = "UIException: method ";
-                        msg += class_name;
-                        msg += ".from_setting(Setting&) has thrown a SettingException.";
-                        throw UISettingException ( msg, sttng_xcptn.getPath() );
-                } catch ( std::runtime_error &e ) {
-                        delete instance;
-                        instance = 0;
-                        string msg = "UIException: method ";
-                        msg += class_name;
-                        msg += " says: ";
-                        msg += e.what();
-                        throw UISettingException ( msg, link.result );
+                        call_from_setting( *instance, link.result, class_name );
                 } catch ( ... ) {
                         delete instance;
@@ -351 +473 @@
                         throw;
                 }
-
-                // validate the new instance
-                instance->validate();
         }
 
         //! This method converts a Setting into a descendant of class
         //! T, wrapped in an instance of bdm::shared_ptr<T> .
-        template<class T>
-        static void from_setting ( bdm::shared_ptr<T> &instance, const Setting &element ) {
+        template<class T> static void from_setting ( bdm::shared_ptr<T> &instance, const Setting &element ) {
                 T *tmp_inst = 0;
                 from_setting ( tmp_inst, element );
@@ -372 +490 @@
                 assert_type ( link.result, Setting::TypeList );
 
-
                 int len = link.result.getLength();
                 array_to_load.set_length ( len );
@@ -380 +497 @@
                         from_setting ( array_to_load ( i ), link.result[i] );
         }
-/*
-        //! This is dummy version of the from_setting method for other, unsupported types. It just throws an exception.
-        //!
-        //! At the moment, this is the only way how to compile the library without obtaining the compiler error c2665.
-        //! The exception can help to find the place where the template is misused and also to correct it.
-        template<class T> static void from_setting ( T &variable_to_load, const Setting &element ) {
-                std::string msg = "UIException: from_setting is not implemented for type ";
-                try{
-                        variable_to_load.from_setting(element);
-                } catch (...){
-                        msg += typeid ( T ).name();
-                        msg += '.';
-                        throw UISettingException ( msg, element );
-                }
-        }
-*/
 
 protected:
@@ -414 +515 @@
         //! The new instance of type T* is constructed and initialized with values stored in the Setting element[name]
         //!
-        //! If there is not any sub-element named #name and settingPresence is #optional, an empty bdm::shared_ptr<T> is returned. When settingPresence is #compulsory, the returned bdm::shared_ptr<T> is never empty (an exception is thrown when the object isn't found).
+        //! If there does not exist any sub-element named #name and settingPresence is #optional, an empty bdm::shared_ptr<T> is returned. When settingPresence is #compulsory, the returned bdm::shared_ptr<T> is never empty (an exception is thrown when the object isn't found).
         template<class T>
         static bdm::shared_ptr<T> build ( const Setting &element, const string &name, SettingPresence settingPresence = optional ) {
@@ -431 +532 @@
         //! The new instance of type T* is constructed and initialized with values stored in the Setting element[index]
         //!
-        //! If there is not any sub-element indexed by #index, and settingPresence is #optional, an empty bdm::shared_ptr<T> is returned. When settingPresence is #compulsory, the returned bdm::shared_ptr<T> is never empty (an exception is thrown when the object isn't found).
+        //! If there does not exist  any sub-element indexed by #index, and settingPresence is #optional, an empty bdm::shared_ptr<T> is returned. When settingPresence is #compulsory, the returned bdm::shared_ptr<T> is never empty (an exception is thrown when the object isn't found).
         template<class T>
         static bdm::shared_ptr<T> build ( const Setting &element, const int index, SettingPresence settingPresence = optional ) {
@@ -466 +567 @@
 
         //! The existing instance of type T is initialized with values stored in the Setting element[name]
-        //! If there is not any sub-element named #name, this method returns false.
+        //! If there does not exist any sub-element named #name, this method returns false.
         template<class T> static bool get ( T &instance, const Setting &element, const string &name, SettingPresence settingPresence = optional ) {
                 if ( !element.exists ( name ) ) {
@@ -480 +581 @@
 
         //! The existing instance of type T is initialized with values stored in the Setting element[index]
-        //! If there is not any sub-element indexed by #index, this method returns false.
+        //! If there does not exist any sub-element indexed by #index, this method returns false.
         template<class T> static bool get ( T &instance, const Setting &element, const int index, SettingPresence settingPresence = optional ) {
                 if ( element.getLength() <= index ) {
@@ -551 +652 @@
         //! or by its integer index. In that case, the new element is added at the very end of the current list of child Settings.
 
-        //! A root descendant instance is stored in the new child Setting appended to the passed element
-        template< class T> static void save ( const T * const instance, Setting &element, const string &name = "" ) {
-                Setting &set = ( name == "" ) ?  (element.getType()==Setting::TypeArray || element.getType()==Setting::TypeList) ? element.add ( Setting::TypeGroup ) : element 
-                               : element.add ( name, Setting::TypeGroup );
-
-                const string &class_name = MappedUI::retrieve_class_name ( &typeid ( *instance ) );
-
-                // add attribute "class"
-                Setting &type = set.add ( "class", Setting::TypeString );
-                type = class_name;
-
-                try {
-                        instance->to_setting ( set );
-                } catch ( SettingException &sttng_xcptn ) {
-                        string msg = "UIException: method ";
-                        msg += class_name;
-                        msg += ".to_setting(Setting&) has thrown a SettingException.";
-                        throw UISettingException ( msg, sttng_xcptn.getPath() );
-                }
-        }
-
+        //! A root descendant is stored in the new child Setting appended to the passed element
+        static void save ( const root &instance, Setting &element, const string &name = "" );
+
+        //! A pointer to root descendant is stored in the new child Setting appended to the passed element
+        static void save ( const root * const instance, Setting &element, const string &name = "" );
+
+        //! A shared pointer to root descendant is stored in the new child Setting appended to the passed element
         template< class T> static void save ( const bdm::shared_ptr<T> &instance, Setting &element, const string &name = "" ) {
-                save<T> ( instance.get(), element, name );
+                save( instance.get(), element, name );
         }
 
@@ -603 +690 @@
         static void save ( const double &real, Setting &element, const string &name = "" );
 
-// The only difference from classical UserInfo approach to log_level_template is the fact
-        // that the actual UI element related to log_level_template could possibly exists yet. In this case, 
-        // we do not want to throw an exception like in the case of any other type being loaded
-        // from Setting. We rather fill the current log_level into this existig element. This way, it is 
-        // possible that more instances of log_level_template class (templated with different classes)
+    // The only difference from classical UserInfo approach here is the fact
+        // that the actual UI element related to log_level_base could possibly exists yet. In this case, 
+        // we do not want to throw an exception as usually. We rather append current data into the existig element. This way, it is 
+        // possible that more instances of log_level_base  (templated with different classes)
         // can be stored in only one line in a configuration file
-        static void save ( const log_level_base &log_level, Setting &element, const string &name = "log_level"  );
+        template<class T> static void save ( const log_level_base<T> &log_level, Setting &element ) {
+                assert_type ( element, Setting::TypeGroup );            
+                string name = "log_level";
+                
+                if( element.exists( name ) ) 
+                        assert_type ( element[name], Setting::TypeString );
+                else
+                        element.add ( name, Setting::TypeString ); 
+
+                log_level.to_setting( element[name] );
+        }
 
         //!@}