Variable.h

Go to the documentation of this file.

 
#ifndef __ROGUE_INTERFACES_MEMORY_VARIABLE_H__
#define __ROGUE_INTERFACES_MEMORY_VARIABLE_H__
#include "rogue/Directives.h"
 
#include <inttypes.h>
#include <stdint.h>
 
#include <memory>
#include <string>
#include <thread>
#include <vector>
 
#include "rogue/EnableSharedFromThis.h"
 
#ifndef NO_PYTHON
    #include <boost/python.hpp>
#endif
 
namespace rogue {
namespace interfaces {
namespace memory {
 
class Block;
class Variable;
 
typedef std::shared_ptr<rogue::interfaces::memory::Variable> VariablePtr;
 
class Variable {
    friend class Block;
 
  protected:
    // Associated block
    rogue::interfaces::memory::Block* block_;
 
    // Name
    std::string name_;
 
    // Path
    std::string path_;
 
    // Model
    uint32_t modelId_;
 
    // Byte reverse flag
    bool byteReverse_;
 
    // Bit reverse flag
    bool bitReverse_;
 
    // Total number of used bits for this value, used for standard non list variables
    uint32_t bitTotal_;
 
    // Fast copy base array
    uint32_t* fastByte_;
 
    // Total bytes (rounded up) for this value, based upon bitTotal_
    uint32_t byteSize_;
 
    // Variable coverage bytes, regardless of if bits are used
    uint32_t varBytes_;
 
    // Variable offset, in bytes
    uint64_t offset_;
 
    // Array of bit offsets
    std::vector<uint32_t> bitOffset_;
 
    // Array of bit sizes
    std::vector<uint32_t> bitSize_;
 
    // Min value for range checking
    double minValue_;
 
    // Max value for range checking
    double maxValue_;
 
    // Bulk Enable Flag
    bool bulkOpEn_;
 
    // Enable update calls
    bool updateNotify_;
 
    // Variable mode
    std::string mode_;
 
    // Overlap Enable Flag
    bool overlapEn_;
 
    // Verify flag
    bool verifyEn_;
 
    // Low byte value
    uint32_t* lowTranByte_;
 
    // High byte value
    uint32_t* highTranByte_;
 
    // Poiner to custom data
    void* customData_;
 
    // Bin Point
    uint32_t binPoint_;
 
    // Stale flag
    bool stale_;
 
    // Stale start address
    uint32_t staleLowByte_;
 
    // Stale stop address
    uint32_t staleHighByte_;
 
    // Number of values
    uint32_t numValues_;
 
    // Bits per value
    uint32_t valueBits_;
 
    // Bytes per value
    uint32_t valueBytes_;
 
    // Stride per value
    uint32_t valueStride_;
 
    // Retry count
    uint32_t retryCount_;
 
#ifndef NO_PYTHON
    // Python
 
    // Set pointer function
    void (rogue::interfaces::memory::Block::*setFuncPy_)(boost::python::object&,
                                                         rogue::interfaces::memory::Variable*,
                                                         int32_t index);
 
    // Get pointer function
    boost::python::object (rogue::interfaces::memory::Block::*getFuncPy_)(rogue::interfaces::memory::Variable*,
                                                                          int32_t index);
#endif
 
    // C++ Byte Array
 
    void (rogue::interfaces::memory::Block::*setByteArray_)(const uint8_t*,
                                                            rogue::interfaces::memory::Variable*,
                                                            int32_t index);
 
    void (rogue::interfaces::memory::Block::*getByteArray_)(uint8_t*,
                                                            rogue::interfaces::memory::Variable*,
                                                            int32_t index);
 
    // C++ Uint
 
    void (rogue::interfaces::memory::Block::*setUInt_)(const uint64_t&,
                                                       rogue::interfaces::memory::Variable*,
                                                       int32_t index);
 
    uint64_t (rogue::interfaces::memory::Block::*getUInt_)(rogue::interfaces::memory::Variable*, int32_t index);
 
    // C++ int
 
    void (rogue::interfaces::memory::Block::*setInt_)(const int64_t&,
                                                      rogue::interfaces::memory::Variable*,
                                                      int32_t index);
 
    int64_t (rogue::interfaces::memory::Block::*getInt_)(rogue::interfaces::memory::Variable*, int32_t index);
 
    // C++ bool
 
    void (rogue::interfaces::memory::Block::*setBool_)(const bool&,
                                                       rogue::interfaces::memory::Variable*,
                                                       int32_t index);
 
    bool (rogue::interfaces::memory::Block::*getBool_)(rogue::interfaces::memory::Variable*, int32_t index);
 
    // C++ String
 
    void (rogue::interfaces::memory::Block::*setString_)(const std::string&,
                                                         rogue::interfaces::memory::Variable*,
                                                         int32_t index);
 
    std::string (rogue::interfaces::memory::Block::*getString_)(rogue::interfaces::memory::Variable*, int32_t index);
 
    // C++ Float
 
    void (rogue::interfaces::memory::Block::*setFloat_)(const float&,
                                                        rogue::interfaces::memory::Variable*,
                                                        int32_t index);
 
    float (rogue::interfaces::memory::Block::*getFloat_)(rogue::interfaces::memory::Variable*, int32_t index);
 
    // C++ double
 
    void (rogue::interfaces::memory::Block::*setDouble_)(const double&,
                                                         rogue::interfaces::memory::Variable*,
                                                         int32_t index);
 
    double (rogue::interfaces::memory::Block::*getDouble_)(rogue::interfaces::memory::Variable*, int32_t index);
 
    // C++ filed point
 
    void (rogue::interfaces::memory::Block::*setFixed_)(const double&,
                                                        rogue::interfaces::memory::Variable*,
                                                        int32_t index);
 
    double (rogue::interfaces::memory::Block::*getFixed_)(rogue::interfaces::memory::Variable*, int32_t index);
 
  public:
    static rogue::interfaces::memory::VariablePtr create(std::string name,
                                                         std::string mode,
                                                         double minimum,
                                                         double maximum,
                                                         uint64_t offset,
                                                         std::vector<uint32_t> bitOffset,
                                                         std::vector<uint32_t> bitSize,
                                                         bool overlapEn,
                                                         bool verify,
                                                         bool bulkOpEn,
                                                         bool updateNotify,
                                                         uint32_t modelId,
                                                         bool byteReverse,
                                                         bool bitReverse,
                                                         uint32_t binPoint,
                                                         uint32_t numValues,
                                                         uint32_t valueBits,
                                                         uint32_t valueStride,
                                                         uint32_t retryCount);
 
    static void setup_python();
 
    Variable(std::string name,
             std::string mode,
             double minimum,
             double maximum,
             uint64_t offset,
             std::vector<uint32_t> bitOffset,
             std::vector<uint32_t> bitSize,
             bool overlapEn,
             bool verify,
             bool bulkOpEn,
             bool updateNotify,
             uint32_t modelId,
             bool byteReverse,
             bool bitReverse,
             uint32_t binPoint,
             uint32_t numValues,
             uint32_t valueBits,
             uint32_t valueStride,
             uint32_t retryCount);
 
    virtual ~Variable();
 
    void shiftOffsetDown(uint32_t shift, uint32_t minSize);
 
    void updatePath(std::string path);
 
    uint32_t modelId() const {
        return modelId_;
    }
 
    uint32_t bitTotal() const {
        return bitTotal_;
    }
 
    uint32_t byteSize() const {
        return byteSize_;
    }
 
    const std::string& name() const {
        return name_;
    }
 
    const std::string& mode() const {
        return mode_;
    }
 
    const std::string& path() const {
        return path_;
    }
 
    double minimum();
 
    double maximum();
 
    uint32_t varBytes();
 
    uint64_t offset();
 
    bool verifyEn();
 
    bool overlapEn();
 
    bool bulkOpEn();
 
    uint32_t numValues() {
        return numValues_;
    }
 
    uint32_t valueBits() {
        return valueBits_;
    }
 
    uint32_t valueBytes() {
        return valueBytes_;
    }
 
    uint32_t valueStride() {
        return valueStride_;
    }
 
    uint32_t retryCount() {
        return retryCount_;
    }
 
    virtual void queueUpdate();
 
    void rateTest();
 
    void setLogLevel(uint32_t level);
 
    std::string getDumpValue(bool read);
 
    void read();
 
    // C++ Byte Array
 
    void setByteArray(uint8_t* value, int32_t index = -1);
 
    void getByteArray(uint8_t* value, int32_t index = -1);
 
    // C++ Uint
 
    void setUInt(uint64_t& value, int32_t index = -1);
 
    void setValue(uint64_t value, int32_t index = -1) {
        setUInt(value, index);
    }
 
    uint64_t getUInt(int32_t index = -1);
 
    void getValue(uint64_t& valueRet, int32_t index = -1) {
        valueRet = getUInt(index);
    }
 
    // C++ int
 
    void setInt(int64_t& value, int32_t index = -1);
 
    void setValue(int64_t value, int32_t index = -1) {
        setInt(value, index);
    }
 
    int64_t getInt(int32_t index = -1);
 
    void getValue(int64_t& valueRet, int32_t index = -1) {
        valueRet = getInt(index);
    }
 
    // C++ bool
 
    void setBool(bool& value, int32_t index = -1);
 
    void setValue(bool value, int32_t index = -1) {
        setBool(value, index);
    }
 
    bool getBool(int32_t index = -1);
 
    void getValue(bool& valueRet, int32_t index = -1) {
        valueRet = getBool(index);
    }
 
    // C++ String
 
    void setString(const std::string& value, int32_t index = -1);
 
    void setValue(const std::string& value, int32_t index = -1) {
        setString(value, index);
    }
 
    std::string getString(int32_t index = -1);
 
    void getString(std::string& retString, int32_t index = -1) {
        getValue(retString, index);
    }
 
    void getValue(std::string& valueRet, int32_t index = -1);
 
    // C++ Float
 
    void setFloat(float& value, int32_t index = -1);
 
    void setValue(float value, int32_t index = -1) {
        setFloat(value, index);
    }
 
    float getFloat(int32_t index = -1);
 
    void getValue(float& valueRet, int32_t index = -1) {
        valueRet = getFloat(index);
    }
 
    // C++ double
 
    void setDouble(double& value, int32_t index = -1);
 
    void setValue(double value, int32_t index = -1) {
        setDouble(value, index);
    }
 
    double getDouble(int32_t index = -1);
 
    void getValue(double& valueRet, int32_t index = -1) {
        valueRet = getDouble(index);
    }
 
    // C++ fixed point
 
    void setFixed(double& value, int32_t index = -1);
 
    double getFixed(int32_t index = -1);
};
 
#ifndef NO_PYTHON
 
class VariableWrap : public rogue::interfaces::memory::Variable,
                     public boost::python::wrapper<rogue::interfaces::memory::Variable> {
    boost::python::object model_;
 
  public:
    VariableWrap(std::string name,
                 std::string mode,
                 boost::python::object minimum,
                 boost::python::object maximum,
                 uint64_t offset,
                 boost::python::object bitOffset,
                 boost::python::object bitSize,
                 bool overlapEn,
                 bool verify,
                 bool bulkOpEn,
                 bool updateNotify,
                 boost::python::object model,
                 boost::python::object listData,
                 uint32_t retryCount);
 
    void updateOffset(boost::python::object& bitOffset);
 
    void set(boost::python::object& value, int32_t index);
 
    boost::python::object get(int32_t index);
 
    boost::python::object toBytes(boost::python::object& value);
 
    boost::python::object fromBytes(boost::python::object& value);
 
    void defQueueUpdate();
 
    void queueUpdate();
 
    boost::python::object bitOffset();
 
    boost::python::object bitSize();
};
 
typedef std::shared_ptr<rogue::interfaces::memory::VariableWrap> VariableWrapPtr;
 
#endif
 
}  // namespace memory
}  // namespace interfaces
}  // namespace rogue
 
#endif