DualDomain.hxx

//
//  Copyright PHOENIX CONTACT Electronics GmbH
//
#pragma once
#include "Arp/System/Core/Arp.h"
#include <algorithm>

// TODO(OR): move this to Arp/Plc/Commons/Internal/Domain

namespace Arp { namespace Plc { namespace Commons { namespace Domain
{

template<class T>
class DualDomain
{
public: // typedefs

public: // construction/destruction
    template <class ...Args>
    DualDomain(Args& ... args);
    DualDomain(const DualDomain& arg) = default;
    DualDomain& operator=(const DualDomain& arg) = default;
    ~DualDomain(void) = default;

public: // setter/getter operations
    T&          Get(bool backgroundDomain = false);
    const T&    Get(bool backgroundDomain = false)const;

public: // operations
    void        SwapDomains(bool simulate = false);

private: // fields
    T   domain1;
    T   domain2;
    T*  pCurrentDomain = nullptr;
    T*  pBackgroundDomain = nullptr;
};

// inline methods of class DualDomain

template<class T>
template <class ...Args>
inline DualDomain<T>::DualDomain(Args& ... args)
    : domain1(*this, args...)
    , domain2(*this, args...)
{
    this->pCurrentDomain = &this->domain1;
    this->pBackgroundDomain = &this->domain2;
}

template<class T>
inline T& DualDomain<T>::Get(bool backgroundDomain)
{
    return backgroundDomain ? *this->pBackgroundDomain : *this->pCurrentDomain;
}

template<class T>
inline const T& DualDomain<T>::Get(bool backgroundDomain)const
{
    return backgroundDomain ? *this->pBackgroundDomain : *this->pCurrentDomain;
}

template<class T>
inline void DualDomain<T>::SwapDomains(bool simulate)
{
    if (simulate)
    {
        // we just swap the backgrounddomain by itself, which causes no changes but will measure the time correctly
        std::swap(this->pBackgroundDomain, this->pBackgroundDomain);
    }
    else
    {
        std::swap(this->pCurrentDomain, this->pBackgroundDomain);
    }
}

}}}} // end of namespace Arp::Plc::Commons::Domain