---

SmartPtrImpl.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 _SmartPtrImpl_incl_
#define _SmartPtrImpl_incl_

// smart pointer implementation details - things that are not normally
// necessary to view when looking at how to use a SmartPtr

#include <typeinfo>
#include <assert.h>

namespace rel
{

    class OpaqueValue;

    /*
        Base class for underlying implementation in smart pointer
     */
    class OpaqueValueData
    {
    public:
        virtual ~OpaqueValueData();

        // get pointer to data
        virtual void *getValue() const =0;
        // get type of data
        virtual const std::type_info &type() const =0;

        // clone existing opaque value data.  Returns "this" by default.
        virtual OpaqueValueData *clone();

        // retain opaque value data.  Should be called by anyone wanting to
        // keep this value around.
        virtual void retain() =0;
        // release opaque value data.  Returns true if this OpaqueValueData can
        // now be freed.
        virtual bool release() =0;

        // special support for interpretable results (can act as a function -
        // taking a set of arguments and returning another type).
        virtual bool interpret(const std::type_info &attemptedResultType,
                const OpaqueValue *args, OpaqueValue *output) =0;
    };


    template<class Type>
    bool smartPtrInterpret(Type * /*value*/, 
            const std::type_info & /*attemptedResultType*/,
            const OpaqueValue * /*args*/ , 
            OpaqueValue * /*output*/)
    {
        return false;
    }

    class OVDPtrImplBase : public OpaqueValueData
    {
    public:
        OVDPtrImplBase(void *src, void (*destructor)(void*));
        ~OVDPtrImplBase();

        void *getValue() const;
        void retain();
        bool release();

    protected:
        int refCnt;
        // raw data pointer.  This is opaque to the map.
        void *value;
        // destructor helper
        void (*destroyOp)(void *);
    };

    /*
        Default implementation of OpaqueValueData, for storing a pointer to
        data.
     */
    template<class Type>
    class OVDPtrImpl : public OVDPtrImplBase
    {
    public:
        OVDPtrImpl(Type *src, void (*destructor)(Type*))
            : OVDPtrImplBase(src, (void(*)(void*))destructor) {}

        ~OVDPtrImpl() {}

        const std::type_info &type() const {return typeid(Type);}

        bool interpret(const std::type_info &resultType,
                const OpaqueValue *args, OpaqueValue *output)
        { return smartPtrInterpret<Type>((Type*)value, resultType, 
                args, output); }
    };

    /*
        implementation of OpaqueValueData for by-value types. 
        This stores the data by value rather then as a pointer.
     */
    template<class Type>
    class OVDValueImpl : public OpaqueValueData
    {
    public:
        OVDValueImpl(Type src, void (*destructor)(Type))
            : refCnt(0), value(src), destroyOp(destructor) {}

        virtual ~OVDValueImpl() 
        {
            // should never happen, or else memory is stuffed
            assert(refCnt == 0);
        }

        virtual void *getValue() const {return (void*)&value;}
        virtual const std::type_info &type() const {return typeid(Type);}

        OpaqueValueData *clone() { return this; }
        void retain() {++refCnt;}
        bool release()
        {
            if(--refCnt == 0)
            {
                if(destroyOp)
                    (*destroyOp)(value);
                return true;
            } else
                return false;
        }

        bool interpret(const std::type_info &resultType,
                const OpaqueValue *args, OpaqueValue *output)
        { return smartPtrInterpret<Type>(&value, resultType, args, output); }

        int refCnt;
        // raw data pointer.  This is opaque to the map.
        Type value;
        // destructor helper
        void (*destroyOp)(Type);
    };

} // namespace rel

#endif

---