//
// ********************************************************************
// * License and Disclaimer                                           *
// *                                                                  *
// * The  Geant4 software  is  copyright of the Copyright Holders  of *
// * the Geant4 Collaboration.  It is provided  under  the terms  and *
// * conditions of the Geant4 Software License,  included in the file *
// * LICENSE and available at  http://cern.ch/geant4/license .  These *
// * include a list of copyright holders.                             *
// *                                                                  *
// * Neither the authors of this software system, nor their employing *
// * institutes,nor the agencies providing financial support for this *
// * work  make  any representation or  warranty, express or implied, *
// * regarding  this  software system or assume any liability for its *
// * use.  Please see the license in the file  LICENSE  and URL above *
// * for the full disclaimer and the limitation of liability.         *
// *                                                                  *
// * This  code  implementation is the result of  the  scientific and *
// * technical work of the GEANT4 collaboration.                      *
// * By using,  copying,  modifying or  distributing the software (or *
// * any work based  on the software)  you  agree  to acknowledge its *
// * use  in  resulting  scientific  publications,  and indicate your *
// * acceptance of all terms of the Geant4 Software license.          *
// ********************************************************************
//
/// \file parallel/ThreadsafeScorers/include/G4atomic.hh
/// \brief Definition of the G4atomic class
//
//
// $Id: G4atomic.hh 93110 2015-11-05 08:37:42Z jmadsen $
//
//
/// This is an friendly implementation of the STL atomic class.
///     This class has the same interface as the STL atomic but can be used
///     in an extremely similar fashion to plain old data (POD) types.
///     In other words, the copy constructor and assignment operators are
///     defined, and a load() does not need to be called to get the POD
///     value.
///
/// IMPORTANT: Care must be taken when using this class as a RHS term.
///     The best use case scenario for this class is as a LHS term that is
///     only used as a RHS term outside of the multithreaded operations on it.
///
/// FOR EXAMPLE:
///     Proper use:
///         Goal: sum energy deposited in run
///         Impl: Is a member variable of derived
///                   G4VUserActionInitialization (of which there will
///                   always be just one instance). Accumulate
///                   thread-local energy deposit into EventAction,
///                   add to ActionInit at end of event, print sum
///                   on master EndOfRunAction
///         Why: the sum is only a LHS term
///     Improper use:
///         Goal: compute error during event processing
///         Impl: sum += x; sum_sq += x*x; counts++;
///               error = sqrt(sum_sq/(sum*sum) - 1/counts;
///               (where sum, sum_sq, counts are G4atomics)
///         Why: This will work but error can/will be wrong when
///              sum, sum_sq, and counts are updated by another thread
///              while error is being calculated, i.e. they are used as
///              RHS terms
//
//
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......


#ifndef G4atomic_hh_
#define G4atomic_hh_

//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......

#ifdef G4MULTITHREADED

#include "G4atomic_defines.hh"

//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......

template<typename _Tp>
class G4atomic
{
public:
    typedef typename std::atomic<_Tp>   base_type;
    typedef _Tp                         value_type;

private:
    using mem_odr = std::memory_order;

public:
    // constructors
    explicit
    G4atomic(mem_odr odr = std::memory_order_acq_rel) : fMemOrder(odr)
    { atomics::set(&fvalue, value_type()); }

    explicit
    G4atomic(const value_type& _init,
             mem_odr odr = std::memory_order_acq_rel) : fMemOrder(odr)
    { atomics::set(&fvalue, _init); }

    // copy-constructor from pure C++11 atomic
    explicit
    G4atomic(const base_type& rhs,
             mem_odr odr = std::memory_order_acq_rel) : fMemOrder(odr)
    { atomics::set(&fvalue, rhs); }

    // copy-constructor
    explicit
    G4atomic(const G4atomic& rhs) : fMemOrder(rhs.fMemOrder)
    { atomics::set(&fvalue, rhs.base()); }

    // assignment operators
    G4atomic& operator=(const G4atomic& rhs)
    {
        if(this != &rhs)
            atomics::set(&fvalue, rhs.fvalue);
        return *this;
    }

    G4atomic& operator=(const value_type& rhs)
    {
        atomics::set(&fvalue, rhs);
        return *this;
    }

    G4atomic& operator=(const base_type& rhs)
    {
        atomics::set(&fvalue, rhs);
        return *this;
    }

    // destructor
    ~G4atomic() { fvalue.~base_type(); }

    // base version
    base_type& base() { return fvalue; }
    const base_type& base() const { return fvalue; }
    base_type& base() volatile { return fvalue; }
    const base_type& base() const volatile { return fvalue; }

    // check if atomic is lock-free
    bool is_lock_free() const { return fvalue.is_lock_free(); }
    bool is_lock_free() const volatile { return fvalue.is_lock_free(); }

    // store functions
    void store(_Tp _desired, std::memory_order mem_odr
               = std::memory_order_seq_cst)
    { atomics::set(fvalue, _desired, mem_odr); }
    void store(_Tp _desired, std::memory_order mem_odr
               = std::memory_order_seq_cst) volatile
    { atomics::set(fvalue, _desired, mem_odr); }

    // load functions
    _Tp load(std::memory_order mem_odr
             = std::memory_order_seq_cst) const
    { return atomics::get(fvalue, mem_odr); }
    _Tp load(std::memory_order mem_odr
             = std::memory_order_seq_cst) const volatile
    { return atomics::get(fvalue, mem_odr); }

    // implicit conversion functions
    operator _Tp() const { return this->load(); }
    operator _Tp() const volatile { return this->load(); }

    operator base_type&() const { return fvalue; }

    // compare-and-swap functions
    bool compare_exchange_weak(_Tp& _expected, _Tp _desired,
                               std::memory_order _success,
                               std::memory_order _failure)
    { return fvalue.compare_exchange_weak(_expected, _desired,
                                          _success, _failure); }
    bool compare_exchange_weak(_Tp& _expected, _Tp _desired,
                               std::memory_order _success,
                               std::memory_order _failure) volatile
    { return fvalue.compare_exchange_weak(_expected, _desired,
                                          _success, _failure); }

    bool compare_exchange_weak(_Tp& _expected, _Tp _desired,
                               std::memory_order _order)
    { return fvalue.compare_exchange_weak(_expected, _desired, _order); }
    bool compare_exchange_weak(_Tp& _expected, _Tp _desired,
                               std::memory_order _order) volatile
    { return fvalue.compare_exchange_weak(_expected, _desired, _order); }

    bool compare_exchange_strong(_Tp& _expected, _Tp _desired,
                                 std::memory_order _success,
                                 std::memory_order _failure)
    { return fvalue.compare_exchange_weak(_expected, _desired,
                                          _success, _failure); }
    bool compare_exchange_strong(_Tp& _expected, _Tp _desired,
                                 std::memory_order _success,
                                 std::memory_order _failure) volatile
    { return fvalue.compare_exchange_weak(_expected, _desired,
                                          _success, _failure); }

    bool compare_exchange_strong(_Tp& _expected, _Tp _desired,
                                 std::memory_order _order)
    { return fvalue.compare_exchange_weak(_expected, _desired, _order); }
    bool compare_exchange_strong(_Tp& _expected, _Tp _desired,
                                 std::memory_order _order) volatile
    { return fvalue.compare_exchange_weak(_expected, _desired, _order); }

    // value_type operators
    G4atomic& operator+=(const value_type& rhs)
    { atomics::increment(&fvalue, rhs, fMemOrder); return *this; }
    G4atomic& operator-=(const value_type& rhs)
    { atomics::decrement(&fvalue, rhs, fMemOrder); return *this; }
    G4atomic& operator*=(const value_type& rhs)
    { atomics::multiply(&fvalue, rhs, fMemOrder); return *this; }
    G4atomic& operator/=(const value_type& rhs)
    { atomics::divide(&fvalue, rhs, fMemOrder); return *this; }

    // atomic operators
    G4atomic& operator+=(const G4atomic& rhs)
    { atomics::increment(&fvalue, rhs.fvalue); return *this; }
    G4atomic& operator-=(const G4atomic& rhs)
    { atomics::decrement(&fvalue, rhs.fvalue); return *this; }
    G4atomic& operator*=(const G4atomic& rhs)
    { atomics::multiply(&fvalue, rhs.fvalue); return *this; }
    G4atomic& operator/=(const G4atomic& rhs)
    { atomics::divide(&fvalue, rhs.fvalue); return *this; }

    G4atomic& operator+=(const G4atomic& rhs) volatile
    { atomics::increment(&fvalue, rhs.fvalue); return *this; }
    G4atomic& operator-=(const G4atomic& rhs) volatile
    { atomics::decrement(&fvalue, rhs.fvalue); return *this; }
    G4atomic& operator*=(const G4atomic& rhs) volatile
    { atomics::multiply(&fvalue, rhs.fvalue); return *this; }
    G4atomic& operator/=(const G4atomic& rhs) volatile
    { atomics::divide(&fvalue, rhs.fvalue); return *this; }

    // STL atomic operators
    G4atomic& operator+=(const std::atomic<_Tp>& rhs)
    { atomics::increment(&fvalue, rhs, fMemOrder); return *this; }
    G4atomic& operator-=(const std::atomic<_Tp>& rhs)
    { atomics::decrement(&fvalue, rhs, fMemOrder); return *this; }
    G4atomic& operator*=(const std::atomic<_Tp>& rhs)
    { atomics::multiply(&fvalue, rhs, fMemOrder); return *this; }
    G4atomic& operator/=(const std::atomic<_Tp>& rhs)
    { atomics::divide(&fvalue, rhs, fMemOrder); return *this; }

    G4atomic& operator+=(const std::atomic<_Tp>& rhs) volatile
    { atomics::increment(&fvalue, rhs, fMemOrder); return *this; }
    G4atomic& operator-=(const std::atomic<_Tp>& rhs) volatile
    { atomics::decrement(&fvalue, rhs, fMemOrder); return *this; }
    G4atomic& operator*=(const std::atomic<_Tp>& rhs) volatile
    { atomics::multiply(&fvalue, rhs, fMemOrder); return *this; }
    G4atomic& operator/=(const std::atomic<_Tp>& rhs) volatile
    { atomics::divide(&fvalue, rhs, fMemOrder); return *this; }

    // increment operators
    value_type operator++() { value_type _tmp = ++fvalue; return _tmp; }
    value_type operator++(int)
    { value_type _tmp = fvalue++; return _tmp; }

    value_type operator--() { value_type _tmp = --fvalue; return _tmp; }
    value_type operator--(int)
    { value_type _tmp = fvalue--; return _tmp; }

protected:
    base_type fvalue;
    mem_odr fMemOrder;

};

//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......

#else // ! G4MULTITHREADED

template <typename _Tp> using G4atomic = _Tp;

#endif // G4MULTITHREADED

//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......

#endif // G4atomic_hh_
