---

SmartPtr.h

/*****************************************************************************
 * Author:   Valient Gough <vgough@pobox.com>
 *
 *****************************************************************************
 * Copyright (c) 2001, Valient Gough
 *
 * This library is free software; you can distribute it and/or modify it under
 * the terms of the GNU Lesser General Public License (LGPL), as published by
 * the Free Software Foundation; either version 2.1 of the License, or (at your
 * option) any later version.
 *
 * This library is distributed in the hope that it will be useful, but WITHOUT
 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
 * FITNESS FOR A PARTICULAR PURPOSE.  See the LGPL in the file COPYING for more
 * details.
 *
 */
                                                                                                
#ifndef _OpaqueValue_incl_
#define _OpaqueValue_incl_

#include <unistd.h>

#include <rel/SmartPtrImpl.h>


namespace rel
{

    class OpaqueValue
    {
    public:
        enum DestructorFlag
        {
            No_Destructor
        };



        OpaqueValue();
        OpaqueValue(const OpaqueValue &value);
        OpaqueValue(OpaqueValueData *value);
        ~OpaqueValue();

        const std::type_info &type() const;
        bool interpret(const std::type_info &attemptedResultType,
                const OpaqueValue *args, OpaqueValue *output);

        OpaqueValue &operator=(const OpaqueValue &src);

        /*
            Get a pointer to the data being stored
         */
        inline void *get() const    { return data ? data->getValue() : NULL; }

        // check that the current type matches the destination type.  Returns
        // false if they do not match.
        bool checkType(const std::type_info &dst);
        // just like checkType, except that it throws a bad_cast error if the
        // types do not match.
        void assertType(const std::type_info &dst);
        // throw a bad_operation error if value is NULL
        void assertNotNull(const void *value) const;

        void reset(OpaqueValueData *value = NULL);

    private:
        OpaqueValueData *data;
    };


    template<typename Type>
    void defaultDestructorFunc(Type *data)
    {
        delete data;
    }

    // destructor which can be used for malloc allocated string
    void freeDestructor(char *data);

    template<class Type>
    class SmartPtr : public OpaqueValue
    {
    public:
        SmartPtr() {}

        ~SmartPtr() {}

        SmartPtr( const OpaqueValue &untyped ) 
            : OpaqueValue(untyped)
            { 
                assertType(typeid(Type));
            }

        SmartPtr( const SmartPtr<Type> &src ) 
            : OpaqueValue(src)
            {}

        // don't want automatic conversion from Type*, since that conversion is
        // a change of ownership - it must be explicit!
        explicit SmartPtr(Type *value)
            : OpaqueValue(new OVDPtrImpl<Type>(value, 
                        &defaultDestructorFunc<Type>))
            {}

        // for specifying no destructor
        SmartPtr(Type *value, DestructorFlag)
            : OpaqueValue(new OVDPtrImpl<Type>(value, (void(*)(Type*))NULL))
            {}
        // for specifying no destructor for by-value information..
        SmartPtr(Type value, DestructorFlag)
            : OpaqueValue(new OVDValueImpl<Type>(value, (void(*)(Type))NULL))
            {}

        // for specifying destructor function directly.  This is useful if the
        // map should not own the value.
        SmartPtr(Type *value, void (*destructorFunc)(Type *))
            : OpaqueValue(new OVDPtrImpl<Type>(value, destructorFunc))
            {}

        // for pointer types.  Rather then having to store a pointer to a
        // pointer, conver the pointer to a void* directly..
        SmartPtr(Type value, void(*destructor)(Type))
            : OpaqueValue(new OVDValueImpl<Type>(value, destructor))
            {}

#if 0
        SmartPtr &operator=(const SmartPtr<Type> &src)
        {
            OpaqueValue::operator=(src);
            return *this;
        }
#endif

        Type *get() const          
        { 
            return (Type*)OpaqueValue::get();
        }

        Type &operator *() const   
        { 
            Type *value = get();
            assertNotNull((void*)value);
            return *value;
        }
        Type *operator ->() const  
        { 
            Type *value = get();
            assertNotNull((void*)value);
            return value;
        }
        operator Type*() const     { return   get(); }

        void reset(Type *value = NULL)
        {
            if(!value)
                OpaqueValue::reset();
            else
            {
                OpaqueValue::reset(new OVDPtrImpl<Type>(value,
                            &defaultDestructorFunc<Type>));
            }
        }

        void reset(Type &value, void(*destructor)(Type))
        {
            OpaqueValue::reset(new OVDValueImpl<Type>(value,destructor));
        }
    };


    // Should be moved out of OpaqueValue and somewhere more general..
    class bad_cast : public std::exception
    {
        SmartPtr<char*> _what;
    public:
        bad_cast(const char *fromType, const char *toType);
        const char *what() const;
    };

    class bad_operation : public std::exception
    {
        SmartPtr<char*> _what;
    public:
        bad_operation(const char *what);
        const char *what() const;
    };


} // namespace rel

#endif

---