AbstractField.h

Go to the documentation of this file.

// Copyright CERN 2012 - Developed in collaboration with GSI

#ifndef ABSTRACT_FIELD_H_
#define ABSTRACT_FIELD_H_

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

#include <string>

namespace fesa
{

class AbstractMultiplexingManager;
class MultiplexingContext;
class FieldElement;
class DataStore;
class FieldValueBase;

class AbstractField
{

    template<typename GlobalDeviceType, typename DomainStoreType,
             typename DevInstType> friend class DeviceFactoryImp;
    friend class StoreManager;
    friend class InitializeDataStoreManager;

  public:

    virtual ~AbstractField();

    AbstractMultiplexingManager* getMultiplexingManager();

    uint32_t getMuxDepth();

    bool isMultiplexed();

    const std::string& getName();

    FieldCategory getType();

    bool isMultiMux();

    bool isPersistent();

    //  /*!
    //   * \brief Changes the pendingChanged flag in the field value class at a given slot
    //   * \param changed (true or false)
    //   * \param slot
    //   */
    //  void setPendingChanged(bool changed, int slot);

    std::string getAsString(MultiplexingContext* context=NULL);

  protected:

    virtual void initialize(FieldElement& fieldElement);

    void setMultiplexingManager(AbstractMultiplexingManager* muxManager);

    void setDataIntegrity(DataIntegrity dataIntegrity);

    void restore(FieldElement& fieldElement);

    void store(FieldElement& fieldElement);

    AbstractField(const std::string& fieldName,
                  const FieldCategory fieldCategory, bool multiplexed,
                  bool multiMultipexed, bool persistent, DataIntegrity buffer,
                  DataStore* pDataStore);

    void commit(uint32_t slot);

    void resetToBeSync(uint32_t slot);

    void registerModifiedField(FieldValueBase* pFV, MultiplexingContext* context);

    uint32_t getSlot(MultiplexingContext* context);

    uint32_t requireSlot(MultiplexingContext* context);
    virtual FieldValueBase* getFieldValue(int32_t slot) = 0;

    /*
     * \return the value of the pending buffer as a string
     */
    virtual void getValueToStore(int32_t slot, std::string& str) = 0;

    virtual void setFieldValueAddress(char* pFV, bool initFieldsFlag) = 0;

    virtual void copyValue(uint32_t slot, std::string& val) = 0;

    virtual uint32_t getFieldValueSize() = 0;

    std::string name_;

    FieldCategory fieldCategory_;

    bool multiplexed_;

    AbstractMultiplexingManager* multiplexingManager_;

    DataStore* pDataStore_;

    bool isMultiMux_;

    bool isPersistent_;

    bool isShared_;

    void setMultiMuxFlag(bool flag);

    void setMultiplexed(bool multiplexed);

    uint32_t valueSize_;

    DataIntegrity buffer_;

    friend class DataStore;
};

} // fesa

#endif // ABSTRACT_FIELD_H_