coherence/lang/BoxHandle.hpp

/*
* BoxHandle.hpp
*
* Copyright 2001-2008 by Oracle. All rights reserved.
*
* Oracle is a registered trademarks of Oracle Corporation and/or its
* affiliates.
*
* This software is the confidential and proprietary information of Oracle
* Corporation. You shall not disclose such confidential and proprietary
* information and shall use it only in accordance with the terms of the
* license agreement you entered into with Oracle.
*
* This notice may not be removed or altered.
*/
#ifndef COH_BOX_HANDLE_HPP
#define COH_BOX_HANDLE_HPP

#include "coherence/lang/compatibility.hpp"

#include "coherence/lang/TypedHandle.hpp"

COH_OPEN_NAMESPACE2(coherence,lang)


/**
* A TypedHandle implementation which supports auto-boxing.
*
* To support boxing a managed class defines an inner-type named "BoxedType",
* and includes a public static "create" method which takes that type. The
* BoxedType defines the type which the BoxHandle can use to create a managed
* object from. Alternatively the BoxHandle declaration can identify the
* "BoxedType" via a secondary template parameter.
*
* Managed classes which wish to be auto-boxing may use this handle type
* when defining their Handle and View definitions. See String as an
* example.
*
* When used with integral types a natural ambiguity is introduced when
* setting or comparing a BoxHandle to NULL, as it also an integral type. In
* such cases one may the is_null(h) and clear_handle(h) helper functions to
* ensure the correct behavior.
*
* BoxHandle can be configured as strict, or non-strict. In strict mode
* (the default), derefencing a NULL BoxHandle will result in a
* NullPointerException. In non-strict mode, dereferencing a BoxHandle will
* result in the BoxedType's default value being returned.
*
* @author mf  2007.07.05
*/
template<class T, class B = typename T::BoxedType, bool fStrict = true>
class BoxHandle
    : public TypedHandle<T>
    {
    // ----- typedefs -------------------------------------------------------

    typedef B BoxedType;


    // ----- constructors ---------------------------------------------------

    public:
        /**
        * Create an empty BoxHandle.
        */
        BoxHandle()
                : TypedHandle<T>()
            {
            }

        /**
        * Create a new BoxHandle from the supplied BoxedType
        */
        BoxHandle(const B& b)
                : TypedHandle<T>()
            {
            TypedHandle<T>::set(get_pointer(T::create(b)));
            }

        /**
        * Create a new BoxHandle from the TypedHandle with a type conversion.
        */
        template<class O> BoxHandle(const TypedHandle<O>& h)
                : TypedHandle<T>()
            {
            TypedHandle<T>::set(get_pointer(h));
            }

        /**
        * Create a new BoxHandle from the TypedHandle with a type conversion.
        */
        template<class O> BoxHandle(TypedHandle<O>& h)
                : TypedHandle<T>()
            {
            TypedHandle<T>::set(get_pointer(h));
            }

        /**
        * Create a new BoxHandle from the raw pointer.
        */
        BoxHandle(T* o)
                : TypedHandle<T>()
            {
            TypedHandle<T>::set(o);
            }

        /**
        * The copy constructor.
        */
        BoxHandle(const BoxHandle& h)
                : TypedHandle<T>(h)
            {
            TypedHandle<T>::set(h.get());
            }

        /**
        * The destructor.
        */
        ~BoxHandle()
            {
            }

    // ----- operators ------------------------------------------------------

    public:
        /**
        * The "boxing" operator.
        */
        BoxHandle& operator=(const BoxedType& b)
            {
            TypedHandle<T>::set(get_pointer(T::create(b)));
            return *this;
            }

        /**
        * The "unboxing" operator.
        *
        * @return a copy of the referenced Object
        */
        operator BoxedType() const
            {
            const T* pT = TypedHandle<T>::get();
            if (NULL == pT)
                {
                if (fStrict)
                    {
                    coh_throw_npe(typeid(T));
                    }
                return BoxedType();
                }
            return (BoxedType) *pT;
            }

        /**
        * The equality operator.
        */
        template<class O>
        bool operator==(const TypedHandle<O>& v) const
            {
            return (const Object*) get_pointer(*this) ==
                   (const Object*) get_pointer(v);
            }

        /**
        * The equality operator.
        */
        bool operator==(const Object* cpo) const
            {
            return ((const Object*) get_pointer(*this)) ==
                   ((const Object*) cpo);
            }

        /**
        * The equality operator.
        */
        bool operator==(const BoxedType& b) const
            {
            const T* pT = TypedHandle<T>::get();
            return NULL == pT ? BoxedType() == b : ((BoxedType) *pT) == b;
            }

        /**
        * The inequality operator.
        */
        template<class O>
        bool operator!=(const TypedHandle<O>& h) const
            {
            return !operator==(h);
            }

         /**
         * The inequality operator.
         */
         bool operator!=(const Object* cpo) const
             {
             return !operator==(cpo);
             }

        /**
        * The inequality operator.
        */
        bool operator!=(const BoxedType& b) const
            {
            return !operator==(b);
            }
    };

COH_CLOSE_NAMESPACE2

#endif // COH_BOX_HANDLE_HPP

Copyright (c) 2000-2008 Oracle. All rights reserved.