FieldValue.h

Go to the documentation of this file.

// Copyright CERN 2012 - Developed in collaboration with GSI

#ifndef FIELD_VALUE_H_
#define FIELD_VALUE_H_

#include <fesa-core/Core/FesaDefs.h>

namespace fesa
{

class FieldValueBase
{
  public:
    void commit(bool force);

    bool isToBeSync();

    void setToBeSync(bool flag);

    void setPendingChanged(bool flag);

    bool hasPendingChanged();

  protected:
    enum Phase
    {
        P1 = 0, P2 = 1
    } phase_;

    bool pendingChanged_;

    bool toBeSync_;

    FieldValueBase()
    {
    }

};

inline void FieldValueBase::commit(bool force = false)
{
    if (toBeSync_ || force)
    {
        phase_ = (phase_ == P1) ? P2 : P1;
        toBeSync_ = false;
        pendingChanged_ = false;
    }
}

inline bool FieldValueBase::isToBeSync()
{
    return toBeSync_;
}

inline void FieldValueBase::setToBeSync(bool flag)
{
    toBeSync_ = flag;
    pendingChanged_ = false;
}

inline void FieldValueBase::setPendingChanged(bool flag)
{

    pendingChanged_ = flag;

}

inline bool FieldValueBase::hasPendingChanged()
{
    return pendingChanged_;
}

template<typename T>
class FieldValue : public FieldValueBase
{
  public:

    FieldValue(DataIntegrity dataIntegrity);

    T & pendingBuffer(char* pFV);

    T & activeBuffer(char *FV);

  private:
    uint32_t offset_[2];

};

template<typename T>
FieldValue<T>::FieldValue(DataIntegrity dataIntegrity)
{

    phase_ = P1;
    toBeSync_ = false;
    pendingChanged_ = false;
    offset_[0] = sizeof(FieldValue<T> );
    if (dataIntegrity == DoubleBuffered)
    {
        offset_[1] = sizeof(FieldValue<T> ) + sizeof(T);
    }
    else
    {
        offset_[1] = offset_[0];
    }

}

template<typename T>
inline T & FieldValue<T>::pendingBuffer(char* pFV)
{
    return (this->phase_ == this->P1) ? (T&) (*(pFV + offset_[0])) : (T&) (*(pFV + offset_[1]));
}

template<typename T>
inline T & FieldValue<T>::activeBuffer(char* pFV)
{
    return (this->phase_ == this->P1) ? (T&) (*(pFV + offset_[1])) : (T&) (*(pFV + offset_[0]));
}

/************************ END SPECIALIZATION FOR SCALAR FIELDS *****************/

template<typename T>
class FieldValue<T[]> : public FieldValueBase
{
  public:
    FieldValue(DataIntegrity dataIntegrity, uint32_t size);

    T* pendingBuffer(char* pFV);

    T* activeBuffer(char* pFV);

    void setPendingCurrentSize(uint32_t currentSize);

    void setActiveCurrentSize(uint32_t currentSize);

    uint32_t getPendingCurrentSize();

    uint32_t getActiveCurrentSize();

  private:

    uint32_t offset_[2];

    uint32_t currentSize_[2];

    bool isSingleBuffer_;
};

template<typename T>
FieldValue<T[]>::FieldValue(DataIntegrity dataIntegrity, uint32_t size)
{

    phase_ = P1;
    toBeSync_ = false;
    pendingChanged_ = false;
    currentSize_[0] = size;
    currentSize_[1] = size;

    offset_[0] = sizeof(FieldValue<T[]> );

    if (dataIntegrity == DoubleBuffered)
    {
        offset_[1] = sizeof(FieldValue<T[]> ) + sizeof(T) * size;
        isSingleBuffer_ = false;
    }
    else
    {
        offset_[1] = offset_[0];
        isSingleBuffer_ = true;
    }
}

template<typename T>
inline T* FieldValue<T[]>::pendingBuffer(char* pFV)
{
    return (this->phase_ == this->P1) ? (T*) (pFV + offset_[0]) : (T*) (pFV + offset_[1]);
}

template<typename T>
inline T* FieldValue<T[]>::activeBuffer(char* pFV)
{
    return (this->phase_ == this->P1) ? (T*) (pFV + offset_[1]) : (T*) (pFV + offset_[0]);
}

template<typename T>
inline uint32_t FieldValue<T[]>::getPendingCurrentSize()
{
    // In case of single buffer dimension is get from position 0 else it's driven by the phase
    if (isSingleBuffer_)
        return currentSize_[0];
    else
        return (this->phase_ == this->P1) ? currentSize_[0] : currentSize_[1];
}

template<typename T>
inline uint32_t FieldValue<T[]>::getActiveCurrentSize()
{
    // In case of single buffer dimension is get from position 0 else it's driven by the phase
    if (isSingleBuffer_)
        return currentSize_[0];
    else
        return (this->phase_ == this->P1) ? currentSize_[1] : currentSize_[0];
}

template<typename T>
inline void FieldValue<T[]>::setPendingCurrentSize(uint32_t currentSize)
{
    // In case of single buffer dimension is written in position 0 else it's driven by the phase
    if (isSingleBuffer_ || this->phase_ == this->P1)
    {
        currentSize_[0] = currentSize;
    }
    else
    {
        currentSize_[1] = currentSize;
    }
}

template<typename T>
inline void FieldValue<T[]>::setActiveCurrentSize(uint32_t currentSize)
{
    // In case of single buffer dimension is written in position 0 else it's driven by the phase
    if (isSingleBuffer_ || this->phase_ == this->P2)
    {
        currentSize_[0] = currentSize;
    }
    else
    {
        currentSize_[1] = currentSize;
    }
}

/**************** END SPECIALIZATION FOR ARRAY ****************************/

template<typename T>
class FieldValue<T[][1]> : public FieldValueBase
{
  public:

    FieldValue(DataIntegrity dataIntegrity, uint32_t size1, uint32_t size2);

    T** pendingBuffer(char *pFV);

    T** activeBuffer(char *pFV);

    void getPendingCurrentSize(uint32_t& size1, uint32_t& size2);

    void getActiveCurrentSize(uint32_t& size1, uint32_t& size2);

    void setPendingCurrentSize(uint32_t size1, uint32_t size2);

    void setActiveCurrentSize(uint32_t size1, uint32_t size2);

  private:

    uint32_t offset_[2];

    uint32_t currentSize1_[2];

    uint32_t currentSize2_[2];

    bool isSingleBuffer_;
};

template<typename T>
FieldValue<T[][1]>::FieldValue(DataIntegrity dataIntegrity, uint32_t size1, uint32_t size2)
{

    phase_ = P1;
    toBeSync_ = false;
    pendingChanged_ = false;

    currentSize1_[0] = size1;
    currentSize1_[1] = size1;
    currentSize2_[0] = size2;
    currentSize2_[1] = size2;

    offset_[0] = sizeof(FieldValue<T[][1]> );

    if (dataIntegrity == DoubleBuffered)
    {
        offset_[1] = sizeof(FieldValue<T[][1]> ) + sizeof(T) * size1 * size2;
        isSingleBuffer_ = false;
    }
    else
    {
        offset_[1] = offset_[0];
        isSingleBuffer_ = true;
    }

}

template<typename T>
inline T** FieldValue<T[][1]>::pendingBuffer(char* pFV)
{
    return (this->phase_ == this->P1) ? (T**) (pFV + offset_[0]) : (T**) (pFV + offset_[1]);
}

template<typename T>
inline T** FieldValue<T[][1]>::activeBuffer(char* pFV)
{
    return (this->phase_ == this->P1) ? (T**) (pFV + offset_[1]) : (T**) (pFV + offset_[0]);
}

template<typename T>
inline void FieldValue<T[][1]>::getPendingCurrentSize(uint32_t& size1, uint32_t& size2)
{
    // In case of single buffer dimension is get from position 0 else it's driven by the phase
    if (isSingleBuffer_ || this->phase_ == this->P1)
    {
        size1 = currentSize1_[0];
        size2 = currentSize2_[0];
    }
    else
    {
        size1 = currentSize1_[1];
        size2 = currentSize2_[1];
    }
}

template<typename T>
inline void FieldValue<T[][1]>::getActiveCurrentSize(uint32_t& size1, uint32_t& size2)
{
    // In case of single buffer dimension is get from position 0 else it's driven by the phase
    if (isSingleBuffer_ || this->phase_ == this->P2)
    {
        size1 = currentSize1_[0];
        size2 = currentSize2_[0];
    }
    else
    {
        size1 = currentSize1_[1];
        size2 = currentSize2_[1];
    }
}

template<typename T>
void FieldValue<T[][1]>::setPendingCurrentSize(uint32_t size1, uint32_t size2)
{
    // In case of single buffer dimension is written in position 0 else it's driven by the phase
    if (isSingleBuffer_ || this->phase_ == this->P1)
    {
        currentSize1_[0] = size1;
        currentSize2_[0] = size2;
    }
    else
    {
        currentSize1_[1] = size1;
        currentSize2_[1] = size2;
    }
}

template<typename T>
void FieldValue<T[][1]>::setActiveCurrentSize(uint32_t size1, uint32_t size2)
{
    // In case of single buffer dimension is written in position 0 else it's driven by the phase
    if (isSingleBuffer_ || this->phase_ == this->P2)
    {
        currentSize1_[0] = size1;
        currentSize2_[0] = size2;
    }
    else
    {
        currentSize1_[1] = size1;
        currentSize2_[1] = size2;
    }
}

/************************** END SPECIALIZATION FOR ARRAY 2D ********************/

template<>
class FieldValue<char[]> : public FieldValueBase
{
  public:
    FieldValue(DataIntegrity dataIntegrity, uint32_t size);

    char* pendingBuffer(char* pFV);

    char* activeBuffer(char *pFV);

  private:

    uint32_t offset_[2];
};



/************************ END SPECIALIZATION FOR STRING ****************************/

template<>
class FieldValue<char *[]> : public FieldValueBase
{
  public:

    FieldValue(DataIntegrity dataIntegrity, uint32_t size1);

    uint32_t pendingBuffer();

    uint32_t activeBuffer();

    void setPendingCurrentSize(uint32_t size);

    void setActiveCurrentSize(uint32_t size);

    uint32_t getPendingCurrentSize();

    uint32_t getActiveCurrentSize();

  private:

    uint32_t offset_[2];

    uint32_t currentSize_[2];

    bool isSingleBuffer_;
};


} // fesa

#endif // FIELD_VALUE_H_