Oracle Coherence for C++ API
Release 3.7.1.0
E22845-01

coherence/lang/FinalView.hpp

/*
* FinalView.hpp
*
* Copyright (c) 2000, 2011, Oracle and/or its affiliates. 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_FINAL_VIEW_HPP
#define COH_FINAL_VIEW_HPP

#include "coherence/lang/compatibility.hpp"

#include "coherence/lang/MemberView.hpp"
#include "coherence/lang/TypedHandle.hpp"

COH_OPEN_NAMESPACE2(coherence,lang)

/**
* FinalView is an immutable thread-safe view intended for use as a data-member
* within Objects.
*
* @author mf  2008.12.01
*
* @see FinalHandle
* @see FinalHolder
*/
template<class T>
class FinalView
    : public MemberView<T>
    {
    // ----- typedefs -------------------------------------------------------

    public:
        /**
        * The type of the values the holder can reference.
        */
        typedef T ValueType;

        /**
        * The View type for the referenced Object.
        */
        typedef typename T::View ValueView;


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

    public:
        /**
        * Construct a new FinalView referencing NULL via a handle.
        *
        * @param oGuardian  the object that protects this member
        */
        FinalView(const Object& oGuardian)
            : MemberView<T>(oGuardian)
            {
            }

        /**
        * Construct a new FinalView referencing specified Object.
        *
        * @param oGuardian  the object that protects this member
        * @param that       the object to reference
        */
        FinalView(const Object& oGuardian, const ValueView& that)
            : MemberView<T>(oGuardian, that)
            {
            }

        /**
        * Construct a new FinalView referencing specified Object.
        *
        * @param oGuardian  the object that protects this member
        * @param that       the object to reference
        * @param fMutable   true if the member is declared as mutable, false
        *                   if declared as const
        */
        FinalView(const Object& oGuardian, const ValueView& that, bool fMutable)
            : MemberView<T>(oGuardian, that, fMutable)
            {
            }


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

    public:
        /**
        * Return a View to the referenced Object.
        *
        * @return a View to the referenced Object
        */
        operator ValueView() const
            {
            return ValueView(MemberView<T>::m_cpo);
            }

        /**
        * Return a View to the referenced Object.
        *
        * @return a View to the referenced Object
        */
        template<class PT>
        operator TypedHandle<const PT>() const
            {
            return MemberView<T>::m_cpo;
            }

        /**
        * Return a TypedHolder to the referenced Object.
        *
        * @return a TypedHolder to the referenced Object
        */
        template<class PT>
        operator TypedHolder<PT>() const
            {
            return ValueView(MemberView<T>::m_cpo);
            }

        /**
        * Dereference the FinalView.
        *
        * @return a const pointer to the referenced Object
        */
        const T* operator->() const
            {
            const T* cpo = MemberView<T>::m_cpo;
            if (NULL == cpo)
                {
                coh_throw_npe(typeid(const T));
                }
            return cpo;
            }

    private:
        /**
        * Blocked assignment operator.
        */
        FinalView& operator=(const ValueView& that);

        /**
        * Blocked assignment operator.
        */
        FinalView& operator=(const FinalView<T>& that);


    // ----- helper methods -------------------------------------------------

    protected:
        /**
        * Initialize the value of a FinalView after it is
        * constructed.  A FinalView may be initialized only if the
        * following conditions hold:
        * <ul>
        *   <li> The FinalView has not already been initialized
        *   (either during construction, or via <tt>initialize()</tt>)
        *   <li> The FinalView has not escaped
        * </ul>
        *
        * @param that  the value to initialize this FinalView to
        */
        void initialize(ValueView that)
            {
            if (MemberView<T>::m_cpo != NULL)
                {
                coh_throw_illegal_state(
                    "attempt to multiply initialize FinalView");
                }
            if (MemberView<T>::getGuardian()._isEscaped())
                {
                coh_throw_illegal_state(
                    "attempt to initialize FinalView after it has escaped");
                }
            if (MemberView<T>::m_nMutability >= MemberView<T>::forever_immutable)
                {
                coh_throw_illegal_state(
                    "attempt to initialize const FinalView");
                }

            const T* cpo = get_pointer(that);
            MemberView<T>::m_cpo =
                NULL == cpo || NULL == cpo->_attach(/*fEscaped*/ false) ? NULL : cpo;
            }

    // ----- friends --------------------------------------------------------

    /**
    * @internal
    */
    template<class _T, class V> friend void initialize(FinalView<_T>& fh,
                                              V that);
    };

/**
* Perform a dynamic cast the pointer associated with the FinalView
* to a the specified handle/view type.
*
* @param v       the FinalView from which to perform the cast
* @param fThrow  true if an exception is to be thrown on a failed cast
*
* @return the casted pointer, or NULL if the cast fails and fThrow is false
*
* @throws ClassCastException if the cast fails and fThrow is true
*/
template<class D, class T>
D cast(const FinalView<T>& v, bool fThrow = true)
    {
    return cast<D>((typename FinalView<T>::ValueView) v, fThrow);
    }

/**
* Perform an instanceof check on a FinalView.
*
* @param v   the FinalView from which to perform the test
*
* @return true if the supplied handle is an instance of the specified type
*/
template<class D, class T>
bool instanceof(const FinalView<T>& v)
    {
    return NULL != cast<D>(v, false);
    }

/**
* Initialize the value of a FinalView after it is constructed.  A
* FinalView may be initialized only if the following conditions
* hold:
* <ul>
*   <li> The FinalView has not already been initialized to a
*   non-NULL value (either during construction, or via
*   <tt>initialize()</tt>)
*   <li> The FinalView has not escaped
* </ul>
*
* @param h     the FinalView to initialize
* @param that  the value to initialize this FinalView to
*/
template<class T, class V>
void initialize(FinalView<T>& h, V that)
    {
    h.initialize(that);
    }


COH_CLOSE_NAMESPACE2

#endif // COH_FINAL_VIEW_HPP

Copyright © 2000, 2011, Oracle and/or its affiliates. All rights reserved.