persist/test/base.hpp

Go to the documentation of this file.

// See ../../license.txt for license information.
//
// base.hpp
//
// 4-Jul-2003  phamilton  Created
//

#ifndef incBASE
#define incBASE

// forwards
#include "../../common/object.hpp"
#include "../../common/persistable_object.hpp"
#include "../../common/outerable_object.hpp"
#include "../../common/composition_object.hpp"

namespace persist_test {

class base :
        public ph::common::object_base,
        public ph::common::persistable_object_base,
        public ph::common::outerable_object_base,
                ph::common::outerable_helper,
        public ph::common::composition_object_base
{
public:
        base(const std::string &type, const std::string &name) :
                _type(type), _name(name)
                        {};
        virtual ~base() {};
        
        // ph::common::object_base overrides
        virtual ph::common::outerable_object_base *outerable() 
                { return this; }
        virtual const ph::common::outerable_object_base *outerable() const 
                { return this; }
        virtual const ph::common::composition_object_base *composition() const 
                { return this; }
        virtual ph::common::composition_object_base *composition() 
                { return this; }
        virtual const persistable_object_base *persistable() const 
                { return this; }
        virtual persistable_object_base *persistable() 
                { return this; }

        // persistable_object_base overrides
        virtual ph::common::object_base *create(
                const std::string &type, 
                const std::string &name, 
                ph::common::persistable_object_context *context) 
        { 
                if (outer() && outer()->persistable())
                        return outer()->persistable()->create(type, name, context);
                return 0; 
        }

        // ph::common::outerable_object_base<object> overides
        virtual ph::common::object_base *outer() const { return outer_helper(); }
        virtual void outer(ph::common::object_base *outer) { outer_helper(outer); }
        
protected:
        std::string _type;
        std::string _name;
};

};

#endif // incBASE

---