Example 2.19. sc_port<CASITransactionIF, 1> class

class sc_port<eslapi::CASITransactionIF, 1> : public eslapi::CASITransactionMasterIF
{
public:
    sc_port<eslapi::CASITransactionIF,1> (eslapi::CASIModuleIF * _owner, const std::string& name,
         eslapi::CASITransactionProperties *prop=NULL)
         : slave(NULL), portName(name), casiPortInstanceName(""),casiOwner(_owner), casiIsEnabled(true)
         { memset(&casiProperties,0,sizeof(casiProperties)); if(prop!=NULL) casiProperties = *prop; }

    sc_port<eslapi::CASITransactionIF,1>(const std::string& name, 
           eslapi::CASITransactionProperties *prop=NULL)
          : slave(NULL), portName(name), casiPortInstanceName(""), casiOwner(NULL), casiIsEnabled(true)
          { memset(&casiProperties,0,sizeof(casiProperties)); if(prop!=NULL) casiProperties = *prop; }

   sc_port<eslapi::CASITransactionIF,1>() : slave(NULL), portName("default name 0"),
        casiPortInstanceName(""), casiOwner(NULL), casiIsEnabled(true)
      {memset(&casiProperties,0,sizeof(casiProperties));}

  explicit sc_port<eslapi::CASITransactionIF,1>(const char *name)
     : slave(NULL), portName(name), casiPortInstanceName(""), casiOwner(NULL), casiIsEnabled(true) 
     { memset(&casiProperties,0,sizeof(casiProperties)); }

  explicit sc_port<eslapi::CASITransactionIF,1>( eslapi::CASITransactionIF& interface_ )
     : slave(NULL), portName("default name 0"), casiPortInstanceName(""), 
     casiOwner(NULL),  casiIsEnabled(true)
     { memset(&casiProperties,0,sizeof(casiProperties));}

  sc_port<eslapi::CASITransactionIF,1>( const char* name_, eslapi::CASITransactionIF& interface_ )
        : slave(NULL), portName(name_), casiPortInstanceName(""), casiOwner(NULL), casiIsEnabled(true)
        { memset(&casiProperties,0,sizeof(casiProperties));}

  sc_port<eslapi::CASITransactionIF,1>( sc_port<eslapi::CASITransactionIF,1>& parent_ ) 
        : CASITransactionMasterIF(), slave(NULL), portName("default name 0"), casiPortInstanceName(""), 
        casiOwner(NULL), casiIsEnabled(true)
        { memset(&casiProperties,0,sizeof(casiProperties));}
  sc_port<eslapi::CASITransactionIF,1>( const char* name_, 
        sc_port<eslapi::CASITransactionIF,1>& parent_ )
        : slave(NULL), portName(name_), casiPortInstanceName(""), casiOwner(NULL), casiIsEnabled(true)
        { memset(&casiProperties,0,sizeof(casiProperties));}

  virtual ~sc_port<CASIGenericTransactionIFCASITransactionIF,1>() {}

    // Configuration functions
  std::string getName() { return portName; }
  eslapi::CASIInterfaceType getType() { return eslapi::CASI_TRANSACTION_MASTER; }
  virtual const eslapi::CASITransactionProperties * getProperties() 
          { return &eslapi::casiProperties; }
  virtual void setProperties(const eslapi::CASITransactionProperties * prop)
          { eslapi::casiProperties = *prop; }
  bool supportsAddressRegions()     {return eslapi::casiProperties.supportsAddressRegions; }
  virtual void setPortInstanceName(const std::string& name) { casiPortInstanceName = name; }
  virtual std::string getPortInstanceName() { return casiPortInstanceName; }
  virtual void setCASIOwner(eslapi::CASIModuleIF* owner) { casiOwner = owner; }
  virtual eslapi::CASIModuleIF* getCASIOwner() { return casiOwner; }
  virtual void enablePort(bool enable) { casiIsEnabled = enable; }
  virtual const bool isPortEnabled() { return casiIsEnabled; }
  virtual void setNotifyHandler(CASINotifyHandlerIF *handler) { notifyHandler=handler; }
  virtual eslapi::CASINotifyHandlerIF * getNotifyHandler(void) { return notifyHandler; }
    // Prints a message
  virtual void pmessage( const std::string& msg, 
       eslapi::CASIMessageType type = eslapi::CASI_MSG_INFO );
  virtual void pmessage( eslapi::CASIMessageType type, const char *fmt, ... );

    // Connectivity functions
  virtual void connect(eslapi::CASITransactionIF* iface);
  virtual void disconnect(eslapi::CASITransactionIF* iface);
  virtual void replace(eslapi::CASITransactionIF* old_iface, eslapi::CASITransactionIF* new_iface);
  virtual const std::vector<eslapi::CASITransactionIF*>& getSlaves();

    // Behavioral functions
    // These are convenience functions which will operate on the unique slave.
    // Synchronous read transaction operation.
  eslapi::CASIStatus read(uint64_t addr, uint32_t* value, uint32_t* ctrl)
     { return slave->read(addr, value, ctrl); }
    // Synchronous write transaction operation.
  eslapi::CASIStatus write(uint64_t addr, uint32_t* value, uint32_t* ctrl)
     { return slave->write(addr, value, ctrl); }
    // Synchronous debug read transaction operation.
  eslapi::CASIStatus readDbg(uint64_t addr, uint32_t* value, uint32_t* ctrl)
     { return slave->readDbg(addr, value, ctrl); }
    // Synchronous debug write transaction operation.
  eslapi::CASIStatus writeDbg(uint64_t addr, uint32_t* value, uint32_t* ctrl)
     { return slave->writeDbg(addr, value, ctrl); }
    // Aynchronous read transaction operation.
  eslapi::CASIStatus readReq( uint64_t addr, uint32_t* value, uint32_t* ctrl,
     eslapi::CASITransactionCallbackIF* callback )
    { return slave->readReq( addr, value, ctrl, callback ); }
    // Asynchronous write transaction operation.
  eslapi::CASIStatus writeReq( uint64_t addr, uint32_t* value, uint32_t* ctrl,
     eslapi::CASITransactionCallbackIF* callback )
     { return slave->writeReq( addr, value, ctrl, callback ); }

    // Requests bus access
  eslapi::CASIGrant requestAccess(uint64_t addr) 			{ return slave->requestAccess( addr ); }
    // Checks whether access is still granted.
  eslapi::CASIGrant checkForGrant(uint64_t addr) {return slave->checkForGrant( addr ); }

    // Returns the number of memory address regions supported.
  int getNumRegions()
        { 
            if(slave != NULL) return slave->getNumRegions(); 
            return 0; 
        }
    // Returns the structure of the memory address regions supported.
  void getAddressRegions(uint64_t* start, uint64_t* size, std::string* name)
     { slave->getAddressRegions(start, size, name); }
  void setAddressRegions(uint64_t* start, uint64_t* size, std::string* name)
     { slave->setAddressRegions(start, size, name); }
	// Initiate a shared memory transaction

  virtual eslapi::CASIMemoryMapConstraints* getMappingConstraints()
     { return slave->getMappingConstraints(); }

  virtual void driveTransaction(eslapi::CASITransactionInfo* info)
     { slave->driveTransaction(info); }
    // Cancels a shared memory transaction
  virtual void cancelTransaction(eslapi::CASITransactionInfo* info)
     { slave->cancelTransaction(info); }
    // Initiate a shared memory transaction
  virtual eslapi::CASIStatus debugTransaction(eslapi::CASITransactionInfo* info)
            { return slave->debugTransaction(info); }
    // convenience connection operator
  void operator () ( eslapi::CASITransactionIF& interface_ );
  virtual const char* kind() const { return kind_string; }

    // Return interface if requested 
  virtual eslapi::CAInterface * ObtainInterface(if_name_t ifName, if_rev_t minRev,
         if_rev_t *   actualRev)
         {
             if((strcmp(ifName,"eslapi.sc_port<CASITransactionIF,1>2") == 0) && (minRev <= 0))
             {
                  *actualRev = 0; 
                   return this; 
             }
             return NULL; 
         }


  typedef sc_port_base  base_type;
  typedef sc_port_b<eslapi::CASITransactionIF> this_type;

private:
  void bind( eslapi::CASITransactionIF& interface_ );
  //void operator() ( eslapi::CASITransactionIF& interface_ );
  void bind( this_type& parent_ );
  void operator() ( this_type& parent_ );
    virtual sc_interface* get_interface() {return NULL;};
    virtual const sc_interface* get_interface() const {return NULL;};
    static const char* const kind_string;

protected:
    eslapi::CASITransactionIF *slave;
    std::string portName;
    std::string casiPortInstanceName;    // every port knows its instance name
    eslapi::CASIModuleIF * casiOwner;    // every port knows its owner
    bool casiIsEnabled;                  // ports can be disabled
    eslapi::CASINotifyHandlerIF *notifyHandler; // the notify handler of this master transaction port
    std::vector<eslapi::CASITransactionIF*> slaves;
    eslapi::CASITransactionProperties casiProperties;
};