---

SOMEObject.h

/********************************************************************
** Copyright (C) 2000 SOMELib Project
**
** This library is free software; you can redistribute it and/or
** modify it under the terms of the GNU Library General Public
** License as published by the Free Software Foundation; either
** version 2 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 GNU
** Library General Public License for more details.
**
** You should have received a copy of the GNU Library General Public
** License along with this library; if not, write to the
** Free Software Foundation, Inc., 59 Temple Place - Suite 330,
** Boston, MA  02111-1307, USA. 
**
*******************************************************************/

//  SOME::SmartObject based off of boost::shared_ptr from www.boost.org
//  (C) Copyright Greg Colvin and Beman Dawes 1998, 1999. Permission to copy,
//  use, modify, sell and distribute this software is granted provided this
//  copyright notice appears in all copies. This software is provided "as is"
//  without express or implied warranty, and with no claim as to its
//  suitability for any purpose.

#ifndef SOME_OBJ_HEADER
#define SOME_OBJ_HEADER

#include <algorithm>

namespace SOME
{

template < typename BaseClass >
class ObjectBase
{
public:

ObjectBase(const SOME::ClassCatalog& cat): catalog(cat)
    {}




    virtual ~ObjectBase()
    { }


    bool construct()
    {
        reset(0);
        BaseClass* (*ctor0)() = (BaseClass* (*)())catalog.getCtor0();
        if (ctor0 == 0)
            return false;

        reset((*ctor0)());

        return !isNull();
    }


    template < typename ParamType1 >
    bool construct(ParamType1& a)
    {
        reset(0);
        BaseClass* (*ctor1)(ParamType1&) = (BaseClass * (*)(ParamType1&))catalog.getCtor1();
        if (ctor1 == 0)
            return false;

        reset((*ctor1)(a));

        return !isNull();
    }


    template < typename ParamType1, typename ParamType2 >
    bool construct(ParamType1& a, ParamType2& b)
    {
        reset(0);
        BaseClass* (*ctor2)(ParamType1&, ParamType2&) = (BaseClass * (*)(ParamType1&, ParamType2&))catalog.getCtor2();
        if (ctor2 == 0)
            return false;

        reset((*ctor2)(a, b));

        return !isNull();
    }

    bool isNull()
    {
        return get() == NULL;
    }

    const SOME::ClassCatalog& getClassCatalog() const
    {
        return catalog;
    }

    //Pointer overloads
    BaseClass& operator*() const
    {
        return *get();
    }  // never throws
    BaseClass* operator->() const
    {
        return get();
    }  // never throws
    virtual BaseClass* get() const = 0;

private:
    virtual void reset(BaseClass*) = 0;

private:
    SOME::ClassCatalog catalog;
}
;  //ObjectBase

template < typename BaseClass >
class Object: public ObjectBase < BaseClass >
{
public:

Object(const SOME::ClassCatalog& cat): ObjectBase < BaseClass > (cat)
    {}

    virtual BaseClass* get() const
    {
        return p;
    }

    void destroy() const
    {
        delete p;
        reset(0);
    }

private:
    virtual void reset(BaseClass* new_p)
    {
        p = new_p;
    }

private:
    BaseClass* p;
}
;  //Object

template < typename BaseClass >
class SmartObject: public ObjectBase < BaseClass >
{
public:

SmartObject(const SOME::ClassCatalog& cat):
    ObjectBase < BaseClass > (cat),
    p(0)
    {
        pn = new long(1);
    }

SmartObject(const SmartObject& r): ObjectBase < BaseClass > (r), p(r.p)
    {
        ++*(pn = r.pn);
    }

    ~SmartObject()
    {
        dispose();
    }

    SmartObject& operator=(const SmartObject& r)
    {
        share(r.px, r.pn);
        return *this;
    }

    virtual BaseClass* get() const
    {
        return p;
    }

private:
    virtual void reset(BaseClass* new_p)
    {
        if ( p == new_p ) return ;
        if (--*pn == 0)
        {
            delete p;
        }
        else
        { // allocate new reference counter
            try
            {
                pn = new long;
            }  // fix: prevent leak if new throws
            catch (...)
            {
                ++*pn;   // undo effect of --*pn above to meet effects guarantee
                delete new_p;
                throw;
            } // catch
        } // allocate new reference counter



        *pn = 1;
        p = new_p;
    }

    void dispose()
    {
        if (--*pn == 0)
        {
            delete p;
            delete pn;
        }
    }

    void share(BaseClass* rp, long* rpn)
    {
        if (pn != rpn)
        {
            dispose();
            p = rp;
            ++*(pn = rpn);
        }
    }

private:
    BaseClass* p;
    long* pn;
}
;  //SmartObject

} //namespace SOME




#endif //SOME_OBJ_HEADER

---