Changeset 1064 for library/bdm/bdmroot.h

Timestamp:

06/09/10 14:00:40 (14 years ago)

Author:

mido

Message:

astyle applied all over the library

Files:

• library/bdm/bdmroot.h (modified) (4 diffs)

library/bdm/bdmroot.h

@@ -22 +22 @@
 
 #ifdef MEX
-        #include "base/libconfig/lib/libconfig.h++"     
-        // TODO DODELAT A NAHRADIT #include "base/libconfig_mex.h"
+#include "base/libconfig/lib/libconfig.h++"
+// TODO DODELAT A NAHRADIT #include "base/libconfig_mex.h"
 #else
-        #include "base/libconfig/lib/libconfig.h++"
+#include "base/libconfig/lib/libconfig.h++"
 #endif
 
@@ -34 +34 @@
 
 namespace bdm {
-        
+
 //! auxiliary function for debugging
 void UI_DBG (const Setting &S, const string &spc, ostream &out );
@@ -45 +45 @@
 class root {
 private:
-        //! It is necessary to allow calling of from_setting and to_setting within the UI class ++ i log_options
-        friend class UI;
+    //! It is necessary to allow calling of from_setting and to_setting within the UI class ++ i log_options
+    friend class UI;
 
 protected:
 
-        /*!     
-        \brief Read instance properties according the data stored in the Setting structure.
-        It has to be called only through UI class, therefore it is protected 
-
-        At the begining of this method, it is obligatory to call
-        the corresponding base::from_setting method. Sometimes, there can be 
-        an exception from this rule. If so, the programmer is encouraged 
-        to describe the reasons for this exception in the documentation in detail.
-        
-        Then, all the configuration     components should be read through the UI mechanism. 
-        Those with UI::SettingPresence set to optional shoud have their defaults fulfilled 
-        within the body of this method.
-
-        For instance, declaring a class \c trunk derived from our #root class, 
-        the implementation of the from_setting method should look like this
-
-        \code
-
-        public trunk : public root {
-
-                anytype xxx, yyy;
-
-                virtual void from_setting ( const Setting &set ) {
-                        root::from_setting( set );
-                        
-                        UI::get ( xxx, set, "xxx", UI::compulsory );
-
-                        if ( !UI::get ( yyy, set, "yyy", UI::optional ) ) {
-                                ... // here, it is necessary to set the default of attribute yyy                                                
-                        }
-
-                        ... // another stuff related to trunk class
-                }
-
-                ... // other members of this class
-        };
-
-        \endcode
-        */
-        virtual void from_setting ( const Setting &set ) {
-        }
-
-        /*!     
-        \brief  Save all the instance properties into the Setting structure.
-        It has to be called only through UI class, therefore it is protected 
-
-        The only obligatory rule concerning the body of this method is to call
-        the corresponding base::to_setting method first.        Sometimes, there can 
-        be an exception from this rule. If so, the programmer is encouraged 
-        to describe the reasons for this exception in the documentation in detail.
-        
-        For instance, declaring
-        a class \c trunk derived from our #root class, the implementation of 
-        the to_setting method should look like this
-
-        \code
-        public trunk : public root {
-
-                anytype xxx;
-
-                virtual void to_setting ( const Setting &set ) {
-                        root::to_setting( set );
-
-                        UI::save ( xxx, set, "xxx" );
-                        
-                        ... // another stuff related directly to trunk class
-
-                }
-
-                ... // other members of this class
-
-        };
-
-        \endcode
-        */
-        virtual void to_setting ( Setting &set ) const {
-        }
+    /*!
+    \brief Read instance properties according the data stored in the Setting structure.
+    It has to be called only through UI class, therefore it is protected
+
+    At the begining of this method, it is obligatory to call
+    the corresponding base::from_setting method. Sometimes, there can be
+    an exception from this rule. If so, the programmer is encouraged
+    to describe the reasons for this exception in the documentation in detail.
+
+    Then, all the configuration components should be read through the UI mechanism.
+    Those with UI::SettingPresence set to optional shoud have their defaults fulfilled
+    within the body of this method.
+
+    For instance, declaring a class \c trunk derived from our #root class,
+    the implementation of the from_setting method should look like this
+
+    \code
+
+    public trunk : public root {
+
+        anytype xxx, yyy;
+
+        virtual void from_setting ( const Setting &set ) {
+                root::from_setting( set );
+
+                UI::get ( xxx, set, "xxx", UI::compulsory );
+
+                if ( !UI::get ( yyy, set, "yyy", UI::optional ) ) {
+                        ... // here, it is necessary to set the default of attribute yyy
+                }
+
+                ... // another stuff related to trunk class
+        }
+
+        ... // other members of this class
+    };
+
+    \endcode
+    */
+    virtual void from_setting ( const Setting &set ) {
+    }
+
+    /*!
+    \brief      Save all the instance properties into the Setting structure.
+    It has to be called only through UI class, therefore it is protected
+
+    The only obligatory rule concerning the body of this method is to call
+    the corresponding base::to_setting method first.    Sometimes, there can
+    be an exception from this rule. If so, the programmer is encouraged
+    to describe the reasons for this exception in the documentation in detail.
+
+    For instance, declaring
+    a class \c trunk derived from our #root class, the implementation of
+    the to_setting method should look like this
+
+    \code
+    public trunk : public root {
+
+        anytype xxx;
+
+        virtual void to_setting ( const Setting &set ) {
+                root::to_setting( set );
+
+                UI::save ( xxx, set, "xxx" );
+
+                ... // another stuff related directly to trunk class
+
+        }
+
+        ... // other members of this class
+
+    };
+
+    \endcode
+    */
+    virtual void to_setting ( Setting &set ) const {
+    }
 
 public:
-        
-        //!default constructor
-        root() {};
-
-        //! make sure this is a virtual object
-        virtual ~root() {
-        }
-
-        //! Returns basic textual info about the current instance
-        virtual string to_string() const {
-                Config C;
-                Setting &set=C.getRoot();
-                this->to_setting(set);
-                ostringstream os;
-                UI_DBG(set, "", os);
-                return os.str();
-        }
-        //! Register log levels of each inheritance layer to a logger, i.e. allocate space for data from this class
-        virtual void log_register ( logger &L, const string &prefix ) {
-        }
-
-        //! Write current information into the given logger
-        virtual void log_write() const {
-        } 
-
-        /*!     
-        \brief  This method checks that all internal structures has been set up correctly.
-
-        It is called automatically after the call of the #from_setting method by the mechanism of the UI class. 
-        However, it can be called in any other situation to assure the correctness of an instance.
-        
-        The only obligatory rule concerning the body of this method is to call
-        the corresponding base::validate method first. Sometimes, there can be 
-        an exception from this rule. If so, the programmer is encouraged 
-        to describe the reasons for this exception in the documentation in detail.      
-        
-        Then, only those checks which are not implemented in the base method 
-        are implemented here. For instance, declaring a class \c trunk derived from our 
-        #root class, the implementation of the method validate should 
-        look like this
-
-        \code
-        public trunk : public root {
-
-                virtual void validate ( ) {
-                        root::validate( );
-
-                        ... // checks related directly to trunk class
-                }
-
-                ... // other members of this class
-
-        };
-
-        \endcode
-
-        */
-        virtual void validate() {
-        }
-
-        //! Virtual method providing deep copy of instances
-        virtual root* _copy() const NOT_IMPLEMENTED(NULL);
-        
+
+    //!default constructor
+    root() {};
+
+    //! make sure this is a virtual object
+    virtual ~root() {
+    }
+
+    //! Returns basic textual info about the current instance
+    virtual string to_string() const {
+        Config C;
+        Setting &set=C.getRoot();
+        this->to_setting(set);
+        ostringstream os;
+        UI_DBG(set, "", os);
+        return os.str();
+    }
+    //! Register log levels of each inheritance layer to a logger, i.e. allocate space for data from this class
+    virtual void log_register ( logger &L, const string &prefix ) {
+    }
+
+    //! Write current information into the given logger
+    virtual void log_write() const {
+    }
+
+    /*!
+    \brief      This method checks that all internal structures has been set up correctly.
+
+    It is called automatically after the call of the #from_setting method by the mechanism of the UI class.
+    However, it can be called in any other situation to assure the correctness of an instance.
+
+    The only obligatory rule concerning the body of this method is to call
+    the corresponding base::validate method first. Sometimes, there can be
+    an exception from this rule. If so, the programmer is encouraged
+    to describe the reasons for this exception in the documentation in detail.
+
+    Then, only those checks which are not implemented in the base method
+    are implemented here. For instance, declaring a class \c trunk derived from our
+    #root class, the implementation of the method validate should
+    look like this
+
+    \code
+    public trunk : public root {
+
+        virtual void validate ( ) {
+                root::validate( );
+
+                ... // checks related directly to trunk class
+        }
+
+        ... // other members of this class
+
+    };
+
+    \endcode
+
+    */
+    virtual void validate() {
+    }
+
+    //! Virtual method providing deep copy of instances
+    virtual root* _copy() const NOT_IMPLEMENTED(NULL);
+
 };
 
@@ -200 +200 @@
 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; 
+    //! this is necessary to allow logger to set ids vector appropriately and also to set registered_logger
+    friend class logger;
 
 protected:
-        //! internal pointer to the logger to which this log_level is registered
-        //! 
-        //! it is set to NULL at the beginning
-        logger * registered_logger;
-                
-        //! 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;
-
-
-        //! default constructor�which is intentionaly declared as protected
-        log_level_base( ) {
-                registered_logger = NULL;
-        }
+    //! internal pointer to the logger to which this log_level is registered
+    //!
+    //! it is set to NULL at the beginning
+    logger * registered_logger;
+
+    //! 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;
+
+
+    //! default constructor�which is intentionaly declared as protected
+    log_level_base( ) {
+        registered_logger = NULL;
+    }
 };
 //UIREGISTER IS FORBIDDEN FOR THIS CLASS,  AS IT SHOULD BE LOADED ONLY THROUGH THE SPECIALIZED UI::GET(...) METHOD