Slave.h

Go to the documentation of this file.

 
#ifndef __ROGUE_INTERFACES_MEMORY_SLAVE_H__
#define __ROGUE_INTERFACES_MEMORY_SLAVE_H__
#include "rogue/Directives.h"
 
#include <stdint.h>
 
#include <map>
#include <memory>
#include <string>
#include <vector>
 
#include "rogue/EnableSharedFromThis.h"
#include "rogue/interfaces/memory/Master.h"
#include "rogue/interfaces/memory/Transaction.h"
 
#ifndef NO_PYTHON
    #include <boost/python.hpp>
#endif
 
namespace rogue {
namespace interfaces {
namespace memory {
 
class Master;
class Transaction;
 
class Slave : public rogue::EnableSharedFromThis<rogue::interfaces::memory::Slave> {
    // Class instance counter
    static uint32_t classIdx_;
 
    // Class instance lock
    static std::mutex classMtx_;
 
    // Unique slave ID
    uint32_t id_;
 
    // Alias for map
    typedef std::map<uint32_t, std::shared_ptr<rogue::interfaces::memory::Transaction> > TransactionMap;
 
    // Transaction map
    TransactionMap tranMap_;
 
    // Slave lock
    std::mutex slaveMtx_;
 
    // Min access
    uint32_t min_;
 
    // Max access
    uint32_t max_;
 
    // Slave Name
    std::string name_;
 
  public:
    static std::shared_ptr<rogue::interfaces::memory::Slave> create(uint32_t min, uint32_t max);
 
    static void setup_python();
 
    Slave(uint32_t min, uint32_t max);
 
    virtual ~Slave();
 
    virtual void stop();
 
    void addTransaction(std::shared_ptr<rogue::interfaces::memory::Transaction> transaction);
 
    std::shared_ptr<rogue::interfaces::memory::Transaction> getTransaction(uint32_t index);
 
    uint32_t min();
 
    uint32_t max();
 
    uint32_t id();
 
    void setName(std::string name);
 
    std::string name();
 
    virtual uint32_t doSlaveId();
 
    virtual std::string doSlaveName();
 
    virtual uint32_t doMinAccess();
 
    virtual uint32_t doMaxAccess();
 
    virtual uint64_t doAddress();
 
    virtual void doTransaction(std::shared_ptr<rogue::interfaces::memory::Transaction> transaction);
 
#ifndef NO_PYTHON
 
    void lshiftPy(boost::python::object p);
 
#endif
 
    std::shared_ptr<rogue::interfaces::memory::Master>& operator<<(
        std::shared_ptr<rogue::interfaces::memory::Master>& other);
};
 
typedef std::shared_ptr<rogue::interfaces::memory::Slave> SlavePtr;
 
#ifndef NO_PYTHON
 
// Memory slave class, wrapper to enable python overload of virtual methods
class SlaveWrap : public rogue::interfaces::memory::Slave,
                  public boost::python::wrapper<rogue::interfaces::memory::Slave> {
  public:
    SlaveWrap(uint32_t min, uint32_t max);
 
    uint32_t doMinAccess();
 
    uint32_t defDoMinAccess();
 
    uint32_t doMaxAccess();
 
    uint32_t defDoMaxAccess();
 
    uint64_t doAddress();
 
    uint64_t defDoAddress();
 
    void doTransaction(std::shared_ptr<rogue::interfaces::memory::Transaction> transaction);
 
    void defDoTransaction(std::shared_ptr<rogue::interfaces::memory::Transaction> transaction);
};
 
typedef std::shared_ptr<rogue::interfaces::memory::SlaveWrap> SlaveWrapPtr;
#endif
 
}  // namespace memory
}  // namespace interfaces
}  // namespace rogue
 
#endif