sc_signal_rv_ports.h

Go to the documentation of this file.

/*****************************************************************************
 
  Licensed to Accellera Systems Initiative Inc. (Accellera) under one or
  more contributor license agreements.  See the NOTICE file distributed
  with this work for additional information regarding copyright ownership.
  Accellera licenses this file to you under the Apache License, Version 2.0
  (the "License"); you may not use this file except in compliance with the
  License.  You may obtain a copy of the License at
 
    http://www.apache.org/licenses/LICENSE-2.0
 
  Unless required by applicable law or agreed to in writing, software
  distributed under the License is distributed on an "AS IS" BASIS,
  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
  implied.  See the License for the specific language governing
  permissions and limitations under the License.
 
 *****************************************************************************/
 
/*****************************************************************************
 
  sc_signal_rv_ports.h -- The resolved vector signal ports.
 
  Original Author: Martin Janssen, Synopsys, Inc., 2001-05-21
 
  CHANGE LOG IS AT THE END OF THE FILE
 *****************************************************************************/
 
#ifndef SC_SIGNAL_RV_PORTS_H
#define SC_SIGNAL_RV_PORTS_H
 
 
#include <cstdio>
 
#include "sysc/communication/sc_communication_ids.h"
#include "sysc/communication/sc_signal_ports.h"
#include "sysc/communication/sc_signal_rv.h"
#include "sysc/datatypes/bit/sc_lv.h"
 
namespace sc_core {
 
// ----------------------------------------------------------------------------
//  CLASS : sc_in_rv<W>
//
//  The sc_signal_rv<W> input port class.
// ----------------------------------------------------------------------------
 
template <int W>
class sc_in_rv
    : public sc_in<sc_dt::sc_lv<W> >
{
public:
 
    // typedefs
 
    typedef sc_dt::sc_lv<W>                     data_type;
 
    typedef sc_in_rv<W>                         this_type;
    typedef sc_in<data_type>                    base_type;
 
    typedef typename base_type::in_if_type      in_if_type;
    typedef typename base_type::in_port_type    in_port_type;
    typedef typename base_type::inout_port_type inout_port_type;
 
public:
 
    // constructors
 
    sc_in_rv()
        : base_type()
        {}
 
    explicit sc_in_rv( const char* name_ )
        : base_type( name_ )
        {}
 
    explicit sc_in_rv( const in_if_type& interface_ )
        : base_type( interface_ )
        {}
 
    sc_in_rv( const char* name_, const in_if_type& interface_ )
        : base_type( name_, interface_ )
        {}
 
    explicit sc_in_rv( in_port_type& parent_ )
        : base_type( parent_ )
        {}
 
    sc_in_rv( const char* name_, in_port_type& parent_ )
        : base_type( name_, parent_ )
        {}
 
    explicit sc_in_rv( inout_port_type& parent_ )
        : base_type( parent_ )
        {}
 
    sc_in_rv( const char* name_, inout_port_type& parent_ )
        : base_type( name_, parent_ )
        {}
 
    sc_in_rv( this_type& parent_ )
        : base_type( parent_ )
        {}
 
    sc_in_rv( const char* name_, this_type& parent_ )
        : base_type( name_, parent_ )
        {}
 
 
    // destructor (does nothing)
 
    virtual ~sc_in_rv()
        {}
 
 
    // called when elaboration is done
    /*  WHEN DEFINING THIS METHOD IN A DERIVED CLASS, */
    /*  MAKE SURE THAT THIS METHOD IS CALLED AS WELL. */
 
    virtual void end_of_elaboration();
 
    virtual const char* kind() const
        { return "sc_in_rv"; }
 
private:
 
    // disabled
    sc_in_rv( const this_type& );
    this_type& operator = ( const this_type& );
};
 
 
// IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII
 
 
// called when elaboration is done
 
template <int W>
void
sc_in_rv<W>::end_of_elaboration()
{
    base_type::end_of_elaboration();
    // check if bound channel is a resolved signal
    if( dynamic_cast<sc_signal_rv<W>*>( this->get_interface() ) == 0 ) {
        this->report_error( SC_ID_RESOLVED_PORT_NOT_BOUND_, 0 );
    }
}
 
 
// ----------------------------------------------------------------------------
//  CLASS : sc_inout_rv<W>
//
//  The sc_signal_rv<W> input/output port class.
// ----------------------------------------------------------------------------
 
template <int W>
class sc_inout_rv
    : public sc_inout<sc_dt::sc_lv<W> >
{
public:
 
    // typedefs
 
    typedef sc_dt::sc_lv<W>                     data_type;
 
    typedef sc_inout_rv<W>                      this_type;
    typedef sc_inout<data_type>                 base_type;
 
    typedef typename base_type::in_if_type      in_if_type;
    typedef typename base_type::in_port_type    in_port_type;
    typedef typename base_type::inout_if_type   inout_if_type;
    typedef typename base_type::inout_port_type inout_port_type;
 
public:
 
    // constructors
 
    sc_inout_rv()
        : base_type()
        {}
 
    explicit sc_inout_rv( const char* name_ )
        : base_type( name_ )
        {}
 
    explicit sc_inout_rv( inout_if_type& interface_ )
        : base_type( interface_ )
        {}
 
    sc_inout_rv( const char* name_, inout_if_type& interface_ )
        : base_type( name_, interface_ )
        {}
 
    explicit sc_inout_rv( inout_port_type& parent_ )
        : base_type( parent_ )
        {}
 
    sc_inout_rv( const char* name_, inout_port_type& parent_ )
        : base_type( name_, parent_ )
        {}
 
    sc_inout_rv( this_type& parent_ )
        : base_type( parent_ )
        {}
 
    sc_inout_rv( const char* name_, this_type& parent_ )
        : base_type( name_, parent_ )
        {}
 
 
    // destructor (does nothing)
 
    virtual ~sc_inout_rv()
        {}
 
 
    // write the new value
 
    using base_type::operator=;
    this_type& operator = ( const this_type& port_ )
      { base_type::operator=(port_); return *this; }
 
 
    // called when elaboration is done
    /*  WHEN DEFINING THIS METHOD IN A DERIVED CLASS, */
    /*  MAKE SURE THAT THIS METHOD IS CALLED AS WELL. */
 
    virtual void end_of_elaboration();
 
    virtual const char* kind() const
        { return "sc_inout_rv"; }
 
private:
 
    // disabled
    sc_inout_rv( const this_type& );
};
 
 
// IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII
 
 
// called when elaboration is done
 
template <int W>
void
sc_inout_rv<W>::end_of_elaboration()
{
    base_type::end_of_elaboration();
    // check if bound channel is a resolved signal
    if( dynamic_cast<sc_signal_rv<W>*>( this->get_interface() ) == 0 ) {
        this->report_error( SC_ID_RESOLVED_PORT_NOT_BOUND_, 0 );
    }
}
 
 
// ----------------------------------------------------------------------------
//  CLASS : sc_out_rv<W>
//
//  The sc_signal_rv<W> output port class.
// ----------------------------------------------------------------------------
 
// sc_out_rv can also read from its port, hence no difference with
// sc_inout_rv. For debugging reasons, a class is provided instead
// of a define.
 
template <int W>
class sc_out_rv
    : public sc_inout_rv<W>
{
public:
 
    // typedefs
 
    typedef sc_out_rv<W>                        this_type;
    typedef sc_inout_rv<W>                      base_type;
 
    typedef typename base_type::data_type       data_type;
 
    typedef typename base_type::in_if_type      in_if_type;
    typedef typename base_type::in_port_type    in_port_type;
    typedef typename base_type::inout_if_type   inout_if_type;
    typedef typename base_type::inout_port_type inout_port_type;
 
public:
 
    // constructors
 
    sc_out_rv()
        : base_type()
        {}
 
    explicit sc_out_rv( const char* name_ )
        : base_type( name_ )
        {}
 
    explicit sc_out_rv( inout_if_type& interface_ )
        : base_type( interface_ )
        {}
 
    sc_out_rv( const char* name_, inout_if_type& interface_ )
        : base_type( name_, interface_ )
        {}
 
    explicit sc_out_rv( inout_port_type& parent_ )
        : base_type( parent_ )
        {}
 
    sc_out_rv( const char* name_, inout_port_type& parent_ )
        : base_type( name_, parent_ )
        {}
 
    sc_out_rv( this_type& parent_ )
        : base_type( parent_ )
        {}
 
    sc_out_rv( const char* name_, this_type& parent_ )
        : base_type( name_, parent_ )
        {}
 
 
    // destructor (does nothing)
 
    virtual ~sc_out_rv()
        {}
 
 
    // write the new value
 
    using base_type::operator=;
    this_type& operator = ( const this_type& port_ )
      { base_type::operator=(port_); return *this; }
 
    virtual const char* kind() const
        { return "sc_out_rv"; }
 
private:
 
    // disabled
    sc_out_rv( const this_type& );
};
 
 
// IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII
 
} // namespace sc_core
 
//$Log: sc_signal_rv_ports.h,v $
//Revision 1.3  2011/08/26 20:45:44  acg
// Andy Goodrich: moved the modification log to the end of the file to
// eliminate source line number skew when check-ins are done.
//
//Revision 1.2  2011/02/18 20:23:45  acg
// Andy Goodrich: Copyright update.
//
//Revision 1.1.1.1  2006/12/15 20:20:04  acg
//SystemC 2.3
//
//Revision 1.2  2006/01/03 23:18:27  acg
//Changed copyright to include 2006.
//
//Revision 1.1.1.1  2005/12/19 23:16:43  acg
//First check in of SystemC 2.1 into its own archive.
//
//Revision 1.11  2005/09/15 23:01:52  acg
//Added std:: prefix to appropriate methods and types to get around
//issues with the Edison Front End.
//
//Revision 1.10  2005/06/10 22:43:56  acg
//Added CVS change log annotation.
//
 
#endif
 
// Taf!