pvBaseImpl.h

/*
 * Nominal Device Support v3 (NDS3)
 *
 * Copyright (c) 2015 Cosylab d.d.
 *
 * For more information about the license please refer to the license.txt
 * file included in the distribution.
 */

#ifndef NDSPVBASEIMPL_H
#define NDSPVBASEIMPL_H

#include <string>
#include "nds3/definitions.h"
#include "nds3/impl/baseImpl.h"

namespace nds
{

class PVBase;

class NDS3_API PVBaseImpl: public BaseImpl
{
public:
    PVBaseImpl(const std::string& name);

    virtual void initialize(FactoryBaseImpl& controlSystem);

    virtual void deinitialize();

    virtual void read(timespec* pTimestamp, std::int32_t* pValue) const;
    virtual void read(timespec* pTimestamp, double* pValue) const;
    virtual void read(timespec* pTimestamp, std::vector<std::int8_t>* pValue) const;
    virtual void read(timespec* pTimestamp, std::vector<std::uint8_t>* pValue) const;
    virtual void read(timespec* pTimestamp, std::vector<std::int32_t>* pValue) const;
    virtual void read(timespec* pTimestamp, std::vector<double>* pValue) const;
    virtual void read(timespec* pTimestamp, std::string* pValue) const;

    virtual void write(const timespec& timestamp, const std::int32_t& value);
    virtual void write(const timespec& timestamp, const double& value);
    virtual void write(const timespec& timestamp, const std::vector<std::int8_t>& value);
    virtual void write(const timespec& timestamp, const std::vector<std::uint8_t>& value);
    virtual void write(const timespec& timestamp, const std::vector<std::int32_t>& value);
    virtual void write(const timespec& timestamp, const std::vector<double>& value);
    virtual void write(const timespec& timestamp, const std::string& value);

    virtual dataDirection_t getDataDirection() const = 0;

    virtual dataType_t getDataType() const = 0;

    void setDescription(const std::string& description);

    void setUnits(const std::string& units);

    void setScanType(const scanType_t scanType, const double periodSeconds);

    void setMaxElements(const size_t maxElements);

    void setEnumeration(const enumerationStrings_t& enumerations);

    void processAtInit(const bool bProcessAtInit);

    const std::string& getDescription() const;

    const std::string& getUnits() const;

    scanType_t getScanType() const;

    double getScanPeriodSeconds() const;

    size_t getMaxElements() const;

    const enumerationStrings_t& getEnumerations() const;

    bool getProcessAtInit() const;

    template<typename T>
    static dataType_t getDataTypeForCPPType()
    {
        const int type =
                int(std::is_same<T, std::int32_t>::value) * (int)dataType_t::dataInt32 +
                int(std::is_same<T, double>::value) * (int)dataType_t::dataFloat64 +
                int(std::is_same<T, std::vector<std::int8_t> >::value) * (int)dataType_t::dataInt8Array +
                int(std::is_same<T, std::vector<std::uint8_t> >::value) * (int)dataType_t::dataUint8Array +
                int(std::is_same<T, std::vector<std::int32_t> >::value) * (int)dataType_t::dataInt32Array +
                int(std::is_same<T, std::vector<double> >::value) * (int)dataType_t::dataFloat64Array +
                int(std::is_same<T, std::string>::value) * (int)dataType_t::dataString;

        static_assert(type != 0, "Undefined data type");
        return(dataType_t)type;
    }

protected:
    std::string m_description;          
    std::string m_units;                
    scanType_t m_scanType;              
    double m_periodicScanSeconds;       
    size_t m_maxElements;               
    enumerationStrings_t m_enumeration; 
    bool m_bProcessAtInit;              
};

}
#endif // NDSPVBASEIMPL_H