root/library/bdm/base/user_info.h @ 620

Revision 620, 22.8 kB (checked in by smidl, 15 years ago)

replace assert_debug by assert in classes interacting with users (from_setting, set_parameters, validate)

  • Property svn:eol-style set to native
RevLine 
[396]1/*!
2  \file
[471]3  \brief UI (user info) class for loading/saving objects from/to configuration files.
[399]4  It is designed with use of libconfig C/C++ Configuration File Library
[471]5  \ref ui_page
[396]6  \author Vaclav Smidl.
7
8  -----------------------------------
9  BDM++ - C++ library for Bayesian Decision Making under Uncertainty
10
11  Using IT++ for numerical operations
12  -----------------------------------
13*/
14
[357]15#ifndef USER_INFO_H
16#define USER_INFO_H
[254]17
[344]18#include <stdio.h>
19#include <string>
20#include <typeinfo>
21#include <map>
[396]22#include <stdexcept>
[243]23
[351]24#include "libconfig/libconfig.h++"
[384]25#include "../bdmroot.h"
[527]26#include "../shared_ptr.h"
[357]27#include "itpp/itbase.h"
[351]28
29
[344]30using std::string;
31using namespace std;
[281]32using namespace libconfig;
[246]33
[471]34namespace bdm {
[246]35
[540]36//! Generic exception for reporting configuration errors
[471]37//!
38//!  \ref ui_page
39class UIException : public std::exception {
[540]40private:
[396]41        //! Error message
42        const string message;
[271]43
[540]44public:
45        /*!
46          \brief The constructor
47          \param message the reason for throwing the exception. Should be a complete English sentence (or a couple sentences), starting with "UIException: ".
48        */
49        UIException ( const string &message ) :
50                message ( message ) {
51        }
[471]52
[540]53        //! Overriden method for reporting the error message
54        virtual const char* what() const throw() {
55                return message.c_str();
56        }
[483]57
[540]58        ~UIException() throw() {};
59
60protected:
61        /*!
62          Formats error messages for derived classes, which use a
63          Setting path in addition to the message.
64        */
65        static string format_message( const string &reason, const string &path );
66};
67
68//! Exception for reporting configuration errors related to some concrete Setting path
69//!
70//!  \ref ui_page
71class UISettingException : public UIException {
[483]72public:
[396]73        //! Use this constructor when you can pass the problematical Setting as a parameter
[540]74        UISettingException ( const string &message, const Setting &element ):
75                UIException ( format_message ( message, string ( element.getPath() ) ) ) {
[396]76        }
77
78        //! This constructor is for other occasions, when only path of problematical Setting is known
[540]79        UISettingException ( const string &message, const string &path ):
80                UIException ( format_message ( message, path ) ) {
[396]81        }
82
[540]83        ~UISettingException() throw() {};
84};
85
86//! Exception for reporting configuration errors in the "class" attribute
87//!
88//!  \ref ui_page
89class UIClassException : public UIException {
90public:
91        //! Use this constructor when you can pass the problematical Setting as a parameter
92        UIClassException ( const string &message, const Setting &element ):
93                UIException ( format_message ( message, string ( element.getPath() ) ) ) {
[396]94        }
[483]95
[540]96        //! This constructor is for other occasions, when only path of problematical Setting is known
97        UIClassException ( const string &message, const string &path ):
98                UIException ( format_message ( message, path ) ) {
99        }
[483]100
[540]101        ~UIClassException() throw() {};
[392]102};
[246]103
[394]104/*!
[471]105@brief This class serves to load and/or save user-infos into/from
[394]106configuration files stored on a hard-disk.
[357]107
[471]108Firstly, save some user-infos into the new UIFile instance. Then,
[394]109call the save method with a filename as its only argument:
[351]110
[344]111\code
112        CAudi audi;
[394]113        UIFile file;
114        UI::save( audi, file, "TT");
115        file.save("cars.cfg");
[344]116\endcode
117
[471]118In the other way round, when loading object from a configuration file,
[394]119the appropriate code looks like this:
120
[344]121\code
[394]122        UIFile file("cars.cfg");
123        CAudi *audi = UI::build<CAudi>(file,"TT");
[344]124\endcode
[471]125
126\ref ui_page
[344]127*/
[471]128class UIFile : public Config {
[394]129public:
[396]130        //! Create empty file instance prepared to store Settings
[394]131        UIFile();
[344]132
[396]133        //! Creates instance and fills it from the configuration file file_name
[471]134        UIFile ( const string &file_name );
[344]135
[396]136        //! Save all the stored Settings into the configuration file file_name
[471]137        void save ( const string &file_name );
[394]138
[396]139        //! This operator allows the ability of substituting Setting parameter by UIFile instance
[394]140        operator Setting&();
141};
142
[396]143/*!
[471]144@brief This class serves to expand links used within configuration files.
[394]145
[396]146Value of any type but string can be linked to some other value of the same type
147defined elsewhere in the current configuration file or even in some different
[471]148configuration file.
[394]149
[471]150Link have three parts, \<name\> : \<path\> \<\@filename\>. Field \<name\> contains the
[396]151name of the new setting, \<path\> is the relative path to the referenced setting, which
[471]152has to be taken from the %root Setting element. The last part \<\@filename\> is optional,
[396]153it contains filename in the case the link should refer to a variable stored in a different
154file. From the previous part \<path\>, it has to be separated by '@'.
155
156\code
157    ...
[471]158        jardovo :
[396]159        {
160          class = "Car";
161          year = 1992;
162          manufacturer = "liaz";
163          kilometers = 1555000;
164        };
[471]165        ondrejovo :
[396]166        {
167          class = "Bike";
168          year = 1996;
169          manufacturer = "author";
170          electricLights = true;
171          matr = ( 2, 2, [ 1.0, 0.0, 0.0, 1.0 ] );
172        };
[471]173
174        #this is the example of local link to another mean of transport
[396]175        elisky = "jardovo";
176
177        ...
178
[471]179        # And this link is external link pointing to the file "other_cars.cfg" stored in the
180        # same directory. In that file, it refers to the local Setting "magic_cars.skubankovo".
[396]181        kati = "magic_cars.skubankovo@other_cars.cfg";
182
183    ...
184\endcode
185
186When you want to expand a possible linked setting "element" within your code, it has to be treated this way:
187
188\code
189        ...
190
191        const SettingResolver link( element );
192
193        ...
194
195        int len = link.result.getLength();
196
197        ...
198\endcode
199
[471]200The whole point is that a resolved link (class member #result, i.e., "link.result" in the previous example) could point
[396]201into a different configuration file. In that case there has to be an UIFile instance managing reading from this
[471]202file. As the libconfig::Config deletes all its Settings when dealocated, UIFile must not be dealocated until all
203the necessary operation on the linked Setting are finished (otherwise, the link #result would be invalid just after
204the UIFile dealocation). And that is exactly the mechanism implemented within SettingResolver class. It assures,
[396]205that the #result Setting reference is valid within the scope of SettingResolver instance.
[477]206
[471]207\ref ui_page
[396]208 */
[471]209class SettingResolver : root {
[396]210private:
211        //! If necessary, this pointer stores an addres of an opened UIFile, else it equals NULL
212        UIFile *file;
213
214        //! This method initialize #result reference, i.e., it executes the main code of SettingResolver class
215        //!
[471]216        //! This code could be also located directly in constructor. The only reason why we made this
[396]217        //! method is the keyword 'const' within the declaration of #result reference . Such a reference
218        //! have to be intialized before any other constructor command, exactly in the way it is implemented now.
[471]219        const Setting &initialize_reference ( UIFile* &file, const Setting &potential_link );
[396]220
221public:
222        //! Reference to a resolved link or to the original Setting in the case it does not contain a link
223        const Setting &result;
224
225        //! If potential_link contains a link to some other setting, it is resolved here. Anyway, the Setting reference #result is prepared for use.
[471]226        SettingResolver ( const Setting &potential_link );
227
[396]228        //! An opened UIFile file is closed here if necessary.
[471]229        ~SettingResolver();
[396]230};
231
[344]232/*!
[471]233@brief UI is an abstract class which collects all the auxiliary functions useful to prepare some concrete
234user-infos.
[344]235
[600]236See static methods 'build', 'get' and 'save'. Writing user-infos with these methods is rather simple. The
[471]237rest of this class is intended for internal purposes only. Its meaning is to allow pointers to its templated
238descendant ParticularUI<T>.
239
240\ref ui_page
[344]241*/
[471]242class UI {
[344]243private:
[417]244        //! Class with state shared across all its instances ("monostate"), encapsulating two maps, one mapping names to UI instances and the other mapping type_infos to class names
[471]245        //!
[417]246        //! The key property of this class is that it initializes the internal maps on global init,
[471]247        //! before the instance is used for a first time. Therefore, we do not have to care about initialization
[396]248        //! during a call of UIREGISTER macro operating with both these mappings.
[471]249        class MappedUI {
[344]250        private:
[394]251                //! Type definition of mapping which transforms class names to the related UI instances
252                typedef map< const string, const UI* const > StringToUIMap;
[344]253
[394]254                //! Type definition of mapping which transforms RTTI type_infos to the related class names
255                typedef map< const type_info * const, const string > TypeInfoToStringMap;
[344]256
[396]257                //! Immediately initialized instance of type StringToUIMap
[394]258                static StringToUIMap& mapped_strings();
[351]259
[396]260                //! Immediately initialized instance of type TypeInfoToStringMap
[394]261                static TypeInfoToStringMap& mapped_type_infos();
[351]262
[396]263                //! Method for reporting a error when an attempt to operate with an unregistered class occures
[471]264                static void unregistered_class_error ( const string &unregistered_class_name );
[394]265
[344]266        public:
[396]267                //! Add a pair key-userinfo into the internal map
[471]268                static void add_class ( const string &class_name, const type_info * const class_type_info, const UI* const ui );
[344]269
[396]270                //! Search for an userinfo related to the passed class name within the internal map
[471]271                static const UI& retrieve_ui ( const string &class_name );
[351]272
[396]273                //! Search for an class name related to the passed type_info within the internal map
[471]274                static const string& retrieve_class_name ( const type_info* const class_type_info );
[344]275        };
[351]276
[396]277        //! Function assertting that the setting element is of the SettingType type
[471]278        static void assert_type ( const Setting &element, Setting::Type type );
[396]279
[527]280        /*!
281          \brief Method constructing a configured instance
282
283          The returned pointer must be allocated using operator new
284          (it's deleted at the end of its life cycle). The method is
285          implemented in descendant class ParticularUI<T>, which knows
286          the correct type T.
287        */
[390]288        virtual root* new_instance() const = 0;
[246]289
[471]290        //! Method switching from the \a element to its child Setting according the passed \a index, it also does all the necessary error-checking
291        static const Setting& to_child_setting ( const Setting &element, const int index );
[351]292
[471]293        //! Method switching from the \a element to its child Setting according the passed \a name, it also does all the necessary error-checking
294        static const Setting& to_child_setting ( const Setting &element, const string &name );
295
296        //! This method converts a Setting into a matrix
297        static void from_setting ( mat& matrix, const Setting &element );
[396]298        //! This method converts a Setting into an integer vector
[471]299        static void from_setting ( ivec &vector, const Setting &element );
[396]300        //! This method converts a Setting into a string
[471]301        static void from_setting ( string &str, const Setting &element );
[396]302        //! This method converts a Setting into a real vector
[471]303        static void from_setting ( vec &vector, const Setting &element );
304        //! This method converts a Setting into a integer scalar
305        static void from_setting ( int &integer, const Setting &element );
306        //! This method converts a Setting into a real scalar
307        static void from_setting ( double &real, const Setting &element );
[527]308
[396]309        //! This method converts a Setting into a class T descendant
[471]310        template<class T> static void from_setting ( T* &instance, const Setting &element ) {
311                const SettingResolver link ( element );
312                assert_type ( link.result, Setting::TypeGroup );
[246]313
[471]314                // we get a value stored in the "class" attribute
[345]315                string class_name;
[471]316                if ( !link.result.lookupValue ( "class", class_name ) )
[540]317                        throw UIClassException ( "UIException: the obligatory \"class\" identifier is missing.", link.result );
[471]318
[394]319                // then we find a user-info related to this type
[471]320                const UI& related_UI = MappedUI::retrieve_ui ( class_name );
321
[527]322                root *typeless_instance = related_UI.new_instance();
[620]323                bdm_assert ( typeless_instance, "UI::new_instance failed" );
[344]324
[471]325                instance = dynamic_cast<T*> ( typeless_instance );
[527]326                if ( !instance ) {
327                        delete typeless_instance;
[540]328                        throw UIClassException ( "UIException: class " + class_name + " is not a descendant of the desired output class. Try to call the UI::build<T> function with a different type parameter.", link.result );
[527]329                }
[471]330
331                try {
332                        instance->from_setting ( link.result );
[544]333                } catch ( SettingException &sttng_xcptn ) {
334                        delete instance;
335                        instance = 0;
[540]336                        string msg = "UIException: method ";
337                        msg += class_name;
338                        msg += ".from_setting(Setting&) has thrown a SettingException.";
339                        throw UISettingException(msg, sttng_xcptn.getPath());
[544]340                } catch (...) {
341                        delete instance;
342                        instance = 0;
343                        throw;
[344]344                }
[471]345        }
[344]346
[527]347        //! This method converts a Setting into a descendant of class
348        //! T, wrapped in an instance of shared_ptr<T> .
349        template<class T>
350        static void from_setting ( shared_ptr<T> &instance, const Setting &element ) {
351                T *tmp_inst = 0;
352                from_setting ( tmp_inst, element );
[620]353                bdm_assert ( tmp_inst, "UI::from_setting failed" );
[527]354                instance = tmp_inst;
355        }
356
[396]357        //! This methods converts a Setting into a new templated array of type Array<T>
[478]358        template<class T> static void from_setting ( Array<T> &array_to_load, const Setting &element ) {
[471]359                const SettingResolver link ( element );
[345]360
[471]361                assert_type ( link.result, Setting::TypeList );
[344]362
[377]363                int len = link.result.getLength();
[471]364                array_to_load.set_length ( len );
365                if ( len == 0 ) return;
366
367                for ( int i = 0; i < len; i++ )
368                        from_setting ( array_to_load ( i ), link.result[i] );
[281]369        }
[243]370
[471]371        //! This is dummy version of the from_setting method for other, unsupported types. It just throws an exception.
372        //!
373        //! At the moment, this is the only way how to compile the library without obtaining the compiler error c2665.
374        //! The exception can help to find the place where the template is misused and also to correct it.
[478]375        template<class T> static void from_setting ( T &variable_to_load, const Setting &element ) {
[540]376                std::string msg = "UIException: from_setting is not implemented for type ";
[527]377                msg += typeid(T).name();
[540]378                msg += '.';
379                throw UISettingException ( msg, element );
[471]380        }
381
382
[345]383protected:
[534]384        //! Constructor for internal use only, see \sa ParticularUI<T>
[471]385        UI ( const string& class_name, const type_info * const class_type_info ) {
386                MappedUI::add_class ( class_name, class_type_info, this );
[345]387        }
388
[471]389public:
[281]390
[534]391        //! Enum type used to determine whether the data for concrete Settingis is compulsory or optional
[471]392        enum SettingPresence { optional, compulsory } ;
393
394        //! \name Initialization of classes
[396]395        //!@{
[471]396        //! The type T has to be a #bdm::root descendant class
[394]397
[396]398        //! The new instance of type T* is constructed and initialized with values stored in the Setting element[name]
[471]399        //!
[527]400        //! If there is not any sub-element named #name and settingPresence is #optional, an empty shared_ptr<T> is returned. When settingPresence is #compulsory, the returned shared_ptr<T> is never empty (an exception is thrown when the object isn't found).
401        template<class T>
402        static shared_ptr<T> build ( const Setting &element, const string &name, SettingPresence settingPresence = optional ) {
[477]403                if ( !element.exists ( name ) ) {
404                        if ( settingPresence == optional )
[527]405                                return shared_ptr<T>();
[471]406                        else
[540]407                                throw UISettingException ( "UIException: the compulsory Setting named \"" + name + "\" is missing.", element );
[471]408                }
409
[527]410                shared_ptr<T> instance;
[471]411                from_setting<T> ( instance, to_child_setting ( element, name ) );
[396]412                return instance;
413        }
[471]414
[396]415        //! The new instance of type T* is constructed and initialized with values stored in the Setting element[index]
[471]416        //!
[534]417        //! If there is not any sub-element indexed by #index, and settingPresence is #optional, an empty shared_ptr<T> is returned. When settingPresence is #compulsory, the returned shared_ptr<T> is never empty (an exception is thrown when the object isn't found).
418        template<class T>
419        static shared_ptr<T> build ( const Setting &element, const int index, SettingPresence settingPresence = optional ) {
[477]420                if ( element.getLength() <= index ) {
421                        if ( settingPresence == optional )
[534]422                                return shared_ptr<T>();
[477]423                        else {
[471]424                                stringstream stream;
425                                stream << index;
[540]426                                throw UISettingException ( "UIException: the compulsory Setting with the index " + stream.str() + " is missing.", element );
[471]427                        }
428                }
429
[534]430                shared_ptr<T> instance;
[471]431                from_setting<T> ( instance, to_child_setting ( element, index ) );
[351]432                return instance;
[344]433        }
[471]434
[394]435        //!@}
[281]436
[471]437        //! \name Initialization of structures
[394]438        //!@{
[396]439        //! The type T has to be int, double, string, vec, ivec or mat.
440
441        //! The existing instance of type T is initialized with values stored in the Setting element[name]
[471]442        //! If there is not any sub-element named #name, this method returns false.
443        template<class T> static bool get ( T &instance, const Setting &element, const string &name, SettingPresence settingPresence = optional ) {
[477]444                if ( !element.exists ( name ) ) {
445                        if ( settingPresence == optional )
[471]446                                return false;
447                        else
[540]448                                throw UISettingException ( "UIException: the compulsory Setting named \"" + name + "\" is missing.", element );
[471]449                }
450
451                from_setting ( instance, to_child_setting ( element, name ) );
452                return true;
[344]453        }
454
[471]455        //! The existing instance of type T is initialized with values stored in the Setting element[index]
456        //! If there is not any sub-element indexed by #index, this method returns false.
457        template<class T> static bool get ( T &instance, const Setting &element, const int index, SettingPresence settingPresence = optional ) {
[477]458                if ( element.getLength() <= index ) {
459                        if ( settingPresence == optional )
[471]460                                return false;
[477]461                        else {
[471]462                                stringstream stream;
[540]463                                stream << "UIException: the compulsory Setting with the index " << index << " is missing.";
[471]464                                stream << index;
[540]465                                throw UISettingException (stream.str(), element );
[471]466                        }
467                }
468
469                from_setting ( instance, to_child_setting ( element, index ) );
470                return true;
[344]471        }
472
[396]473        //! The existing instance of type T is initialized with values stored in the Setting element directly
[471]474        template<class T> static bool get ( T &instance, const Setting &element ) {
475                from_setting ( instance, element );
476                return true;
[394]477        }
[396]478        //!@}
[394]479
[396]480        //! \name Initialization of arrays Array<T>
481        //!@{
482        //! The type T has to be int, double, string, vec, ivec or mat, or pointer to any root descendant.
483
484        //! The existing array of type T is initialized with values stored in the Setting element[name]
[471]485        //! If there is not any sub-element named #name, this method returns false.
486        template<class T> static bool get ( Array<T> &array_to_load, const Setting &element, const string &name, SettingPresence settingPresence = optional ) {
487                if ( !element.exists ( name ) )
488                        return false;
489
490                from_setting ( array_to_load, to_child_setting ( element, name ) );
491                return true;
[344]492        }
493
[396]494        //! The existing array of type T is initialized with values stored in the Setting element[index]
[471]495        //! If there is not any sub-element indexed by #index, this method returns false.
496        template<class T> static bool get ( Array<T> &array_to_load, const Setting &element, const int index, SettingPresence settingPresence = optional ) {
497                if ( element.getLength() <= index )
498                        return false;
499
500                from_setting ( array_to_load, to_child_setting ( element, index ) );
501                return true;
[344]502        }
503
[396]504        //! The existing array of type T is initialized with values stored in the Setting element
[471]505        template<class T> static bool get ( Array<T> &array_to_load, const Setting &element ) {
506                from_setting ( array_to_load, element );
507                return true;
[394]508        }
509        //!@}
510
[471]511        //! \name Serialization of objects and structures into a new Setting
[396]512        //!@{
513        //! The new child Setting can be accessed either by its name - if some name is passed as a parameter -
514        //! or by its integer index. In that case, the new element is added at the very end of the current list of child Settings.
515
516        //! A root descendant instance is stored in the new child Setting appended to the passed element
[471]517        template< class T> static void save ( const T * const instance, Setting &element, const string &name = "" ) {
518                Setting &set = ( name == "" ) ? element.add ( Setting::TypeGroup )
519                               : element.add ( name, Setting::TypeGroup );
[344]520
[471]521                const string &class_name = MappedUI::retrieve_class_name ( &typeid ( *instance ) );
522
523                // add attribute "class"
524                Setting &type = set.add ( "class", Setting::TypeString );
[351]525                type = class_name;
[344]526
[471]527                try {
528                        instance->to_setting ( set );
[544]529                } catch ( SettingException &sttng_xcptn ) {
[540]530                        string msg = "UIException: method ";
531                        msg += class_name;
532                        msg += ".to_setting(Setting&) has thrown a SettingException.";
533                        throw UISettingException(msg, sttng_xcptn.getPath());
[351]534                }
[344]535        }
536
[527]537        template< class T> static void save ( const shared_ptr<T> &instance, Setting &element, const string &name = "" ) {
538                save<T> ( instance.get(), element, name );
539        }
540
[396]541        //! An Array<T> instance is stored in the new child Setting appended to the passed element
[471]542        template<class T> static void save ( const Array<T> &array_to_save, Setting &element, const string &name = "" ) {
543                assert_type ( element, Setting::TypeGroup );
544                Setting &list = ( name == "" ) ? element.add ( Setting::TypeList )
545                                : element.add ( name, Setting::TypeList );
546                for ( int i = 0; i < array_to_save.length(); i++ )
547                        save ( array_to_save ( i ), list );
[344]548        }
[351]549
[396]550        //! A matrix(of type mat) is stored in the new child Setting appended to the passed element
[471]551        static void save ( const mat &matrix, Setting &element, const string &name = "" );
[351]552
[396]553        //! An integer vector (of type ivec) is stored in the new child Setting appended to the passed element
[471]554        static void save ( const ivec &vec, Setting &element, const string &name = "" );
555
[396]556        //! A double vector (of type vec) is stored in the new child Setting appended to the passed element
[471]557        static void save ( const vec &vector, Setting &element, const string &name = "" );
[396]558
559        //! A string is stored in the new child Setting appended to the passed element
[471]560        static void save ( const string &str, Setting &element, const string &name = "" );
[351]561
[396]562        //! An integer is stored in the new child Setting appended to the passed element
[471]563        static void save ( const int &integer, Setting &element, const string &name = "" );
[394]564
[396]565        //! A double is stored in the new child Setting appended to the passed element
[471]566        static void save ( const double &real, Setting &element, const string &name = "" );
[396]567        //!@}
[394]568
[281]569};
570
571
[493]572//! The only UI descendant class which is not intended for direct use. It should be accessed within the UIREGISTER macro only.
[471]573//! \ref ui_page
574template<typename T> class ParticularUI : private UI {
[493]575public:
576        //! Constructor used by the UIREGISTER macro.
[471]577        ParticularUI<T> ( const string &class_name ) : UI ( class_name, &typeid ( T ) ) {};
[344]578
[529]579        //! A method returning a brand new instance of class T, this method is the reason why there have to be a parameterless constructor in class T
[471]580        root* new_instance() const {
[344]581                return new T();
582        }
[281]583};
584
[344]585}
586
[471]587/*!
588  \def UIREGISTER(class_name)
589  \brief Macro for registration of class into map of user-infos, registered class is scriptable using UI static methods
590
[529]591  Argument \a class_name has to be a descendant of root class and also to have a default constructor.
[471]592  This macro should be used in header file, immediately after a class declaration.
593
594  \ref ui_page
595*/
596#ifndef BDMLIB
[535]597#define UIREGISTER(class_name) static bdm::ParticularUI<class_name> UI##class_name(#class_name)
[471]598#else
599#define UIREGISTER(class_name)
600#endif
601
[535]602//! Instrumental macro for UIREGISTER2
603#define QUOTEME(x) #x
604
605/*!
606  \def UIREGISTER2(class_name,template_name)
607  \brief Variant of UIREGISTER for templated classes
608
609  Technical meann of registering UIREGISTER(class_name<template_name>).
610
611  \ref ui_page
612 */
613#ifndef BDMLIB
614#define UIREGISTER2(class_name, temp_name) static bdm::ParticularUI<class_name<temp_name> > UI##class_name##_##temp_name( QUOTEME(class_name<temp_name>) )
615#else
616#define UIREGISTER2(class_name,temp_name)
617#endif
618
[358]619#endif // #ifndef USER_INFO_H
Note: See TracBrowser for help on using the browser.