objectptr.h

/*
 * Licensed to the Apache Software Foundation (ASF) under one or more
 * contributor license agreements.  See the NOTICE file distributed with
 * this work for additional information regarding copyright ownership.
 * The ASF licenses this file to You under the Apache License, Version 2.0
 * (the "License"); you may not use this file except in compliance with
 * the License.  You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

#ifndef _LOG4CXX_HELPERS_OBJECT_PTR_H
#define _LOG4CXX_HELPERS_OBJECT_PTR_H

#include <log4cxx/log4cxx.h>

//
//   Helgrind (race detection tool for Valgrind) will complain if pointer
//   is not initialized in an atomic operation.  Static analysis tools
//   (gcc's -Weffc++, for example) will complain if pointer is not initialized
//   in member initialization list.  The use of a macro allows quick
//   switching between the initialization styles.
//
#if LOG4CXX_HELGRIND
    #define _LOG4CXX_OBJECTPTR_INIT(x) : ObjectPtrBase() { exchange(x);
#else
    #define _LOG4CXX_OBJECTPTR_INIT(x) : ObjectPtrBase(), p(x) {
#endif

namespace log4cxx
{
namespace helpers
{
class Class;

class LOG4CXX_EXPORT ObjectPtrBase
{
    public:
        ObjectPtrBase();
        virtual ~ObjectPtrBase();
        static void checkNull(const int& null);
        static void* exchange(void** destination, void* newValue);
        virtual void* cast(const Class& cls) const = 0;
};


template<typename T> class ObjectPtrT : public ObjectPtrBase
{
    public:
        ObjectPtrT(const int& null)
        _LOG4CXX_OBJECTPTR_INIT(0)
        ObjectPtrBase::checkNull(null);
}

ObjectPtrT()
_LOG4CXX_OBJECTPTR_INIT(0)
}

ObjectPtrT(T* p1)
_LOG4CXX_OBJECTPTR_INIT(p1)

if (this->p != 0)
{
    this->p->addRef();
}
}


ObjectPtrT(const ObjectPtrT& p1)
_LOG4CXX_OBJECTPTR_INIT(p1.p)

if (this->p != 0)
{
    this->p->addRef();
}
}

ObjectPtrT(const ObjectPtrBase& p1)
_LOG4CXX_OBJECTPTR_INIT(reinterpret_cast<T*>(p1.cast(T::getStaticClass())))

if (this->p != 0)
{
    this->p->addRef();
}
}

ObjectPtrT(ObjectPtrBase& p1)
_LOG4CXX_OBJECTPTR_INIT(reinterpret_cast<T*>(p1.cast(T::getStaticClass())))

if (this->p != 0)
{
    this->p->addRef();
}
}


~ObjectPtrT()
{
    if (p != 0)
    {
        p->releaseRef();
    }
}

ObjectPtrT& operator=(const ObjectPtrT& p1)
{
    T* newPtr = p1.p;

    if (newPtr != 0)
    {
        newPtr->addRef();
    }

    T* oldPtr = exchange(newPtr);

    if (oldPtr != 0)
    {
        oldPtr->releaseRef();
    }

    return *this;
}

ObjectPtrT& operator=(const int& null)   //throw(IllegalArgumentException)
{
    //
    //   throws IllegalArgumentException if null != 0
    //
    ObjectPtrBase::checkNull(null);
    T* oldPtr = exchange(0);

    if (oldPtr != 0)
    {
        oldPtr->releaseRef();
    }

    return *this;
}

ObjectPtrT& operator=(T* p1)
{
    if (p1 != 0)
    {
        p1->addRef();
    }

    T* oldPtr = exchange(p1);

    if (oldPtr != 0)
    {
        oldPtr->releaseRef();
    }

    return *this;
}


ObjectPtrT& operator=(ObjectPtrBase& p1)
{
    T* newPtr = reinterpret_cast<T*>(p1.cast(T::getStaticClass()));
    return operator=(newPtr);
}

ObjectPtrT& operator=(const ObjectPtrBase& p1)
{
    T* newPtr = reinterpret_cast<T*>(p1.cast(T::getStaticClass()));
    return operator=(newPtr);
}

bool operator==(const ObjectPtrT& p1) const
{
    return (this->p == p1.p);
}
bool operator!=(const ObjectPtrT& p1) const
{
    return (this->p != p1.p);
}
bool operator<(const ObjectPtrT& p1) const
{
    return (this->p < p1.p);
}
bool operator==(const T* p1) const
{
    return (this->p == p1);
}
bool operator!=(const T* p1) const
{
    return (this->p != p1);
}
bool operator<(const T* p1) const
{
    return (this->p < p1);
}
T* operator->() const
{
    return p;
}
T& operator*() const
{
    return *p;
}
operator T* () const
{
    return p;
}



private:
T* p;
virtual void* cast(const Class& cls) const
{
    if (p != 0)
    {
        return const_cast<void*>(p->cast(cls));
    }

    return 0;
}
T* exchange(const T* newValue)
{
    // Avoid GCC strict aliasing warnings
    union
    {
        T** in;
        void** out;
    } temp = { &p };
    return static_cast<T*>(ObjectPtrBase::exchange(
                temp.out,
                const_cast<T*>(newValue)));
}

};


}
}

#endif //_LOG4CXX_HELPERS_OBJECT_PTR_H