/*
 * 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;
        };


      /** smart pointer to a Object descendant */
        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