Oracle Fusion Middleware C++ API Reference for Oracle Coherence
12c (12.1.2)
E26041-01

coherence/lang/Volatile.hpp

/*
* Volatile.hpp
*
* Copyright (c) 2000, 2013, 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_VOLATILE_HPP
#define COH_VOLATILE_HPP

#include "coherence/lang/compatibility.hpp"

#include "coherence/lang/Object.hpp"
#include "coherence/native/NativeAtomic64.hpp"

#include <ostream>

COH_OPEN_NAMESPACE2(coherence,lang)


/**
* Template class wraps primitive data types with memory barriers, providing
* JSR-133 style volatiles.
*
* Note: In the rare case that a Volatile is declared via the mutable
*       keyword, the Volatile must be informed of this fact by setting
*       fMutable to true during construction.
*
* @author mf  2008.02.07
*/
template<class T>
class COH_EXPORT Volatile
    {
    // ----- typedefs -------------------------------------------------------

    public:
        /**
        * A primitive data type that is wrapped by this Volatile<T>
        */
        typedef T Type;


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

    public:
        /**
        * Construct a new Volatile<T> with the default wrapped T value.
        *
        * @param oGuardian  the object which this data member is part of
        */
        Volatile(Object& oGuardian);

        /**
        * Copy-construct a Volatile<T>.
        *
        * @param oGuardian  the object which this data member is part of
        */
        Volatile(Object& oGuardian, const Volatile& o);

        /**
        * Copy-construct a Volatile<T>.
        *
        * @param oGuardian  the object which this data member is part of
        * @param fMutable   true if the member is declared as mutable, false
        *                   if declared as const
        */
        Volatile(Object& oGuardian, const Volatile& o, bool fMutable);

        /**
        * Construct a new Volatile<T> with the specified wrapped T value.
        *
        * @param oGuardian  the object which this data member is part of
        */
        Volatile(Object& oGuardian, const T& value);

        /**
        * Construct a new Volatile<T> with the specified wrapped T value.
        *
        * @param oGuardian  the object which this data member is part of
        * @param fMutable   true if the member is declared as mutable, false
        *                   if declared as const
        */
        Volatile(Object& oGuardian, const T& value, bool fMutable);

        /**
        * Destruct this Volatile<T> object.
        */
        ~Volatile();


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

    public:
        /**
        * Assign this Volatile the value from another Volatile
        */
        Volatile& operator=(const Volatile& value);

        /**
        * Assign this Volatile a new value.
        */
        Volatile& operator=(const T& value);


    // ----- Volatile interface --------------------------------------------

    public:
        /**
        * Return the Volatile value
        *
        * @return The Volatile value
        */
        operator const T() const;


    // ----- data members ---------------------------------------------------

    private:
        /**
        * The object which this data member is part of.
        */
        const Object& m_oGuardian;

        /**
        * The volatile value wrapped in a NativeAtomic64.
        */
        coherence::native::NativeAtomic64 m_atomic;
    };

COH_CLOSE_NAMESPACE2


// ----- global operators and functions -------------------------------------

/**
* Output a human-readable description of the given Volatile<T> to the
* specified stream.
*
* @param out  the stream used to output the description
* @param o    the Volatile<T> value to describe
*
* @return the supplied stream
*/
template<class T> std::ostream& operator<<(std::ostream& out,
            const coherence::lang::Volatile<T>& o);

#endif // COH_Volatile_HPP

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