src/systemc/ext/channel/sc_signal.hh - public/gem5 - Git at Google

 /*
  * Copyright 2018 Google, Inc.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are
  * met: redistributions of source code must retain the above copyright
  * notice, this list of conditions and the following disclaimer;
  * redistributions in binary form must reproduce the above copyright
  * notice, this list of conditions and the following disclaimer in the
  * documentation and/or other materials provided with the distribution;
  * neither the name of the copyright holders nor the names of its
  * contributors may be used to endorse or promote products derived from
  * this software without specific prior written permission.
  *
  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
  * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
  * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
  * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
  * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  *
  * Authors: Gabe Black
  */

 #ifndef __SYSTEMC_EXT_CHANNEL_SC_SIGNAL_HH__
 #define __SYSTEMC_EXT_CHANNEL_SC_SIGNAL_HH__

 #include <iostream>
 #include <string>
 #include <vector>

 #include "../core/sc_event.hh"
 #include "../core/sc_module.hh" // for sc_gen_unique_name
 #include "../core/sc_prim.hh"
 #include "../dt/bit/sc_logic.hh"
 #include "sc_signal_inout_if.hh"
 #include "warn_unimpl.hh" // for warn_unimpl

 namespace sc_core
 {

 class sc_port_base;
 class sc_trace_file;

 // Nonstandard
 // Despite having a warning "FOR INTERNAL USE ONLY!" in all caps above this
 // class definition in the Accellera implementation, it appears in their
 // examples and test programs, and so we need to have it here as well.
 struct sc_trace_params
 {
     sc_trace_file *tf;
     std::string name;

     sc_trace_params(sc_trace_file *tf, const std::string &name) :
         tf(tf), name(name)
     {}
 };
 typedef std::vector<sc_trace_params *> sc_trace_params_vec;

 template <class T, sc_writer_policy WRITER_POLICY=SC_ONE_WRITER>
 class sc_signal : public sc_signal_inout_if<T>,
                   public sc_prim_channel
 {
   public:
     sc_signal() : sc_signal_inout_if<T>(),
                   sc_prim_channel(sc_gen_unique_name("signal")),
                   m_cur_val(T()), m_new_val(T())
     {}
     explicit sc_signal(const char *name) :
         sc_signal_inout_if<T>(), sc_prim_channel(name),
         m_cur_val(T()), m_new_val(T())
     {}
     explicit sc_signal(const char *name, const T &initial_value) :
         sc_signal_inout_if<T>(), sc_prim_channel(name),
         m_cur_val(initial_value), m_new_val(initial_value)
     {}
     virtual ~sc_signal() {}

     virtual void
     register_port(sc_port_base &, const char *)
     {
         sc_channel_warn_unimpl(__PRETTY_FUNCTION__);
     }

     virtual const T &read() const { return m_cur_val; }
     operator const T&() const { return read(); }

     virtual sc_writer_policy
     get_writer_policy() const
     {
         return WRITER_POLICY;
     }
     virtual void
     write(const T &t)
     {
         m_new_val = t;
         bool changed = !(m_cur_val == m_new_val);
         //TODO check whether this write follows the write policy.
         if (changed)
             request_update();
     }
     sc_signal<T, WRITER_POLICY> &
     operator = (const T &t)
     {
         write(t);
         return *this;
     }
     sc_signal<T, WRITER_POLICY> &
     operator = (const sc_signal<T, WRITER_POLICY> &s)
     {
         write(s.read());
         return *this;
     }

     virtual const sc_event &
     default_event() const
     {
         return value_changed_event();
     }
     virtual const sc_event &
     value_changed_event() const
     {
         return _valueChangedEvent;
     }
     virtual bool
     event() const
     {
         sc_channel_warn_unimpl(__PRETTY_FUNCTION__);
         return false;
     }

     virtual void print(std::ostream &os=std::cout) const { os << m_cur_val; }
     virtual void
     dump(std::ostream &os=std::cout) const
     {
         os << "     name = " << name() << ::std::endl;
         os << "    value = " << m_cur_val << ::std::endl;
         os << "new value = " << m_new_val << ::std::endl;
     }
     virtual const char *kind() const { return "sc_signal"; }

   protected:
     virtual void
     update()
     {
         if (m_new_val == m_cur_val)
             return;

         m_cur_val = m_new_val;
         _valueChangedEvent.notify(SC_ZERO_TIME);
     }

     // These members which store the current and future value of the signal
     // are not specified in the standard but are referred to directly by one
     // of the tests.
     T m_cur_val;
     T m_new_val;

   private:
     sc_event _valueChangedEvent;

     // Disabled
     sc_signal(const sc_signal<T, WRITER_POLICY> &) :
             sc_signal_inout_if<T>(), sc_prim_channel("")
     {}
 };

 template <class T, sc_writer_policy WRITER_POLICY>
 inline std::ostream &
 operator << (std::ostream &os, const sc_signal<T, WRITER_POLICY> &)
 {
     sc_channel_warn_unimpl(__PRETTY_FUNCTION__);
     return os;
 }

 template <sc_writer_policy WRITER_POLICY>
 class sc_signal<bool, WRITER_POLICY> :
     public sc_signal_inout_if<bool>, public sc_prim_channel
 {
   public:
     sc_signal() : sc_signal_inout_if<bool>(),
                   sc_prim_channel(sc_gen_unique_name("signal")),
                   m_cur_val(bool()), m_new_val(bool())
     {}
     explicit sc_signal(const char *name) :
         sc_signal_inout_if<bool>(), sc_prim_channel(name),
         m_cur_val(bool()), m_new_val(bool())
     {}
     explicit sc_signal(const char *name, const bool &initial_value) :
         sc_signal_inout_if<bool>(), sc_prim_channel(name),
         m_cur_val(initial_value), m_new_val(initial_value)
     {}
     virtual ~sc_signal() {}

     virtual void
     register_port(sc_port_base &, const char *)
     {
         sc_channel_warn_unimpl(__PRETTY_FUNCTION__);
     }

     virtual const bool &read() const { return m_cur_val; }
     operator const bool &() const { return read(); }

     virtual sc_writer_policy
     get_writer_policy() const
     {
         return WRITER_POLICY;
     }
     virtual void
     write(const bool &b)
     {
         m_new_val = b;
         bool changed = !(m_cur_val == m_new_val);
         //TODO check whether this write follows the write policy.
         if (changed)
             request_update();
     }
     sc_signal<bool, WRITER_POLICY> &
     operator = (const bool &b)
     {
         write(b);
         return *this;
     }
     sc_signal<bool, WRITER_POLICY> &
     operator = (const sc_signal<bool, WRITER_POLICY> &s)
     {
         write(s.read());
         return *this;
     }

     virtual const sc_event &
     default_event() const
     {
         return value_changed_event();
     }

     virtual const sc_event &
     value_changed_event() const
     {
         return _valueChangedEvent;
     }
     virtual const sc_event &
     posedge_event() const
     {
         return _posedgeEvent;
     }
     virtual const sc_event &
     negedge_event() const
     {
         return _negedgeEvent;
     }

     virtual bool
     event() const
     {
         sc_channel_warn_unimpl(__PRETTY_FUNCTION__);
         return false;
     }
     virtual bool
     posedge() const
     {
         sc_channel_warn_unimpl(__PRETTY_FUNCTION__);
         return false;
     }
     virtual bool
     negedge() const
     {
         sc_channel_warn_unimpl(__PRETTY_FUNCTION__);
         return false;
     }

     virtual void print(std::ostream &os=std::cout) const { os << m_cur_val; }
     virtual void
     dump(std::ostream &os=std::cout) const
     {
         os << "     name = " << name() << ::std::endl;
         os << "    value = " << m_cur_val << ::std::endl;
         os << "new value = " << m_new_val << ::std::endl;
     }
     virtual const char *kind() const { return "sc_signal"; }

   protected:
     virtual void
     update()
     {
         if (m_new_val == m_cur_val)
             return;

         m_cur_val = m_new_val;
         _valueChangedEvent.notify(SC_ZERO_TIME);
         if (m_cur_val)
             _posedgeEvent.notify(SC_ZERO_TIME);
         else
             _negedgeEvent.notify(SC_ZERO_TIME);
     }

     bool m_cur_val;
     bool m_new_val;

   private:
     sc_event _valueChangedEvent;
     sc_event _posedgeEvent;
     sc_event _negedgeEvent;

     // Disabled
     sc_signal(const sc_signal<bool, WRITER_POLICY> &) :
             sc_signal_inout_if<bool>(), sc_prim_channel("")
     {}
 };

 template <sc_writer_policy WRITER_POLICY>
 class sc_signal<sc_dt::sc_logic, WRITER_POLICY> :
     public sc_signal_inout_if<sc_dt::sc_logic>, public sc_prim_channel
 {
   public:
     sc_signal() : sc_signal_inout_if<sc_dt::sc_logic>(),
                   sc_prim_channel(sc_gen_unique_name("signal")),
                   m_cur_val(sc_dt::sc_logic()), m_new_val(sc_dt::sc_logic())
     {}
     explicit sc_signal(const char *name) :
         sc_signal_inout_if<sc_dt::sc_logic>(), sc_prim_channel(name),
         m_cur_val(sc_dt::sc_logic()), m_new_val(sc_dt::sc_logic())
     {}
     explicit sc_signal(const char *name,
             const sc_dt::sc_logic &initial_value) :
         sc_signal_inout_if<sc_dt::sc_logic>(), sc_prim_channel(name),
         m_cur_val(initial_value), m_new_val(initial_value)
     {}
     virtual ~sc_signal() {}

     virtual void
     register_port(sc_port_base &, const char *)
     {
         sc_channel_warn_unimpl(__PRETTY_FUNCTION__);
     }

     virtual const sc_dt::sc_logic &read() const { return m_cur_val; }
     operator const sc_dt::sc_logic &() const { return read(); }

     virtual sc_writer_policy
     get_writer_policy() const
     {
         return WRITER_POLICY;
     }
     virtual void
     write(const sc_dt::sc_logic &l)
     {
         m_new_val = l;
         bool changed = !(m_cur_val == m_new_val);
         //TODO check whether this write follows the write policy.
         if (changed)
             request_update();
     }
     sc_signal<sc_dt::sc_logic, WRITER_POLICY> &
     operator = (const sc_dt::sc_logic &l)
     {
         write(l);
         return *this;
     }
     sc_signal<sc_dt::sc_logic, WRITER_POLICY> &
     operator = (const sc_signal<sc_dt::sc_logic, WRITER_POLICY> &s)
     {
         write(s.read());
         return *this;
     }

     virtual const sc_event &
     default_event() const
     {
         return value_changed_event();
     }

     virtual const sc_event &
     value_changed_event() const
     {
         return _valueChangedEvent;
     }
     virtual const sc_event &
     posedge_event() const
     {
         return _posedgeEvent;
     }
     virtual const sc_event &
     negedge_event() const
     {
         return _negedgeEvent;
     }

     virtual bool
     event() const
     {
         sc_channel_warn_unimpl(__PRETTY_FUNCTION__);
         return false;
     }
     virtual bool
     posedge() const
     {
         sc_channel_warn_unimpl(__PRETTY_FUNCTION__);
         return false;
     }
     virtual bool
     negedge() const
     {
         sc_channel_warn_unimpl(__PRETTY_FUNCTION__);
         return false;
     }

     virtual void print(std::ostream &os=std::cout) const { os << m_cur_val; }
     virtual void
     dump(std::ostream &os=std::cout) const
     {
         os << "     name = " << name() << ::std::endl;
         os << "    value = " << m_cur_val << ::std::endl;
         os << "new value = " << m_new_val << ::std::endl;
     }
     virtual const char *kind() const { return "sc_signal"; }

   protected:
     virtual void
     update()
     {
         if (m_new_val == m_cur_val)
             return;

         m_cur_val = m_new_val;
         _valueChangedEvent.notify(SC_ZERO_TIME);
         if (m_cur_val == sc_dt::SC_LOGIC_1)
             _posedgeEvent.notify(SC_ZERO_TIME);
         else if (m_cur_val == sc_dt::SC_LOGIC_0)
             _negedgeEvent.notify(SC_ZERO_TIME);
     }

     sc_dt::sc_logic m_cur_val;
     sc_dt::sc_logic m_new_val;

   private:
     sc_event _valueChangedEvent;
     sc_event _posedgeEvent;
     sc_event _negedgeEvent;

     // Disabled
     sc_signal(const sc_signal<sc_dt::sc_logic, WRITER_POLICY> &) :
             sc_signal_inout_if<sc_dt::sc_logic>(), sc_prim_channel("")
     {}
 };

 } // namespace sc_core

 #endif  //__SYSTEMC_EXT_CHANNEL_SC_SIGNAL_HH__
	/*
	* Copyright 2018 Google, Inc.
	*
	* Redistribution and use in source and binary forms, with or without
	* modification, are permitted provided that the following conditions are
	* met: redistributions of source code must retain the above copyright
	* notice, this list of conditions and the following disclaimer;
	* redistributions in binary form must reproduce the above copyright
	* notice, this list of conditions and the following disclaimer in the
	* documentation and/or other materials provided with the distribution;
	* neither the name of the copyright holders nor the names of its
	* contributors may be used to endorse or promote products derived from
	* this software without specific prior written permission.
	*
	* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
	* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
	* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
	* A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
	* OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
	* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
	* LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
	* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
	* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
	* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
	* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
	*
	* Authors: Gabe Black
	*/

	#ifndef __SYSTEMC_EXT_CHANNEL_SC_SIGNAL_HH__
	#define __SYSTEMC_EXT_CHANNEL_SC_SIGNAL_HH__

	#include <iostream>
	#include <string>
	#include <vector>

	#include "../core/sc_event.hh"
	#include "../core/sc_module.hh" // for sc_gen_unique_name
	#include "../core/sc_prim.hh"
	#include "../dt/bit/sc_logic.hh"
	#include "sc_signal_inout_if.hh"
	#include "warn_unimpl.hh" // for warn_unimpl

	namespace sc_core
	{

	class sc_port_base;
	class sc_trace_file;

	// Nonstandard
	// Despite having a warning "FOR INTERNAL USE ONLY!" in all caps above this
	// class definition in the Accellera implementation, it appears in their
	// examples and test programs, and so we need to have it here as well.
	struct sc_trace_params
	{
	sc_trace_file *tf;
	std::string name;

	sc_trace_params(sc_trace_file *tf, const std::string &name) :
	tf(tf), name(name)
	{}
	};
	typedef std::vector<sc_trace_params *> sc_trace_params_vec;

	template <class T, sc_writer_policy WRITER_POLICY=SC_ONE_WRITER>
	class sc_signal : public sc_signal_inout_if<T>,
	public sc_prim_channel
	{
	public:
	sc_signal() : sc_signal_inout_if<T>(),
	sc_prim_channel(sc_gen_unique_name("signal")),
	m_cur_val(T()), m_new_val(T())
	{}
	explicit sc_signal(const char *name) :
	sc_signal_inout_if<T>(), sc_prim_channel(name),
	m_cur_val(T()), m_new_val(T())
	{}
	explicit sc_signal(const char *name, const T &initial_value) :
	sc_signal_inout_if<T>(), sc_prim_channel(name),
	m_cur_val(initial_value), m_new_val(initial_value)
	{}
	virtual ~sc_signal() {}

	virtual void
	register_port(sc_port_base &, const char *)
	{
	sc_channel_warn_unimpl(__PRETTY_FUNCTION__);
	}

	virtual const T &read() const { return m_cur_val; }
	operator const T&() const { return read(); }

	virtual sc_writer_policy
	get_writer_policy() const
	{
	return WRITER_POLICY;
	}
	virtual void
	write(const T &t)
	{
	m_new_val = t;
	bool changed = !(m_cur_val == m_new_val);
	//TODO check whether this write follows the write policy.
	if (changed)
	request_update();
	}
	sc_signal<T, WRITER_POLICY> &
	operator = (const T &t)
	{
	write(t);
	return *this;
	}
	sc_signal<T, WRITER_POLICY> &
	operator = (const sc_signal<T, WRITER_POLICY> &s)
	{
	write(s.read());
	return *this;
	}

	virtual const sc_event &
	default_event() const
	{
	return value_changed_event();
	}
	virtual const sc_event &
	value_changed_event() const
	{
	return _valueChangedEvent;
	}
	virtual bool
	event() const
	{
	sc_channel_warn_unimpl(__PRETTY_FUNCTION__);
	return false;
	}

	virtual void print(std::ostream &os=std::cout) const { os << m_cur_val; }
	virtual void
	dump(std::ostream &os=std::cout) const
	{
	os << " name = " << name() << ::std::endl;
	os << " value = " << m_cur_val << ::std::endl;
	os << "new value = " << m_new_val << ::std::endl;
	}
	virtual const char *kind() const { return "sc_signal"; }

	protected:
	virtual void
	update()
	{
	if (m_new_val == m_cur_val)
	return;

	m_cur_val = m_new_val;
	_valueChangedEvent.notify(SC_ZERO_TIME);
	}

	// These members which store the current and future value of the signal
	// are not specified in the standard but are referred to directly by one
	// of the tests.
	T m_cur_val;
	T m_new_val;

	private:
	sc_event _valueChangedEvent;

	// Disabled
	sc_signal(const sc_signal<T, WRITER_POLICY> &) :
	sc_signal_inout_if<T>(), sc_prim_channel("")
	{}
	};

	template <class T, sc_writer_policy WRITER_POLICY>
	inline std::ostream &
	operator << (std::ostream &os, const sc_signal<T, WRITER_POLICY> &)
	{
	sc_channel_warn_unimpl(__PRETTY_FUNCTION__);
	return os;
	}

	template <sc_writer_policy WRITER_POLICY>
	class sc_signal<bool, WRITER_POLICY> :
	public sc_signal_inout_if<bool>, public sc_prim_channel
	{
	public:
	sc_signal() : sc_signal_inout_if<bool>(),
	sc_prim_channel(sc_gen_unique_name("signal")),
	m_cur_val(bool()), m_new_val(bool())
	{}
	explicit sc_signal(const char *name) :
	sc_signal_inout_if<bool>(), sc_prim_channel(name),
	m_cur_val(bool()), m_new_val(bool())
	{}
	explicit sc_signal(const char *name, const bool &initial_value) :
	sc_signal_inout_if<bool>(), sc_prim_channel(name),
	m_cur_val(initial_value), m_new_val(initial_value)
	{}
	virtual ~sc_signal() {}

	virtual void
	register_port(sc_port_base &, const char *)
	{
	sc_channel_warn_unimpl(__PRETTY_FUNCTION__);
	}

	virtual const bool &read() const { return m_cur_val; }
	operator const bool &() const { return read(); }

	virtual sc_writer_policy
	get_writer_policy() const
	{
	return WRITER_POLICY;
	}
	virtual void
	write(const bool &b)
	{
	m_new_val = b;
	bool changed = !(m_cur_val == m_new_val);
	//TODO check whether this write follows the write policy.
	if (changed)
	request_update();
	}
	sc_signal<bool, WRITER_POLICY> &
	operator = (const bool &b)
	{
	write(b);
	return *this;
	}
	sc_signal<bool, WRITER_POLICY> &
	operator = (const sc_signal<bool, WRITER_POLICY> &s)
	{
	write(s.read());
	return *this;
	}

	virtual const sc_event &
	default_event() const
	{
	return value_changed_event();
	}

	virtual const sc_event &
	value_changed_event() const
	{
	return _valueChangedEvent;
	}
	virtual const sc_event &
	posedge_event() const
	{
	return _posedgeEvent;
	}
	virtual const sc_event &
	negedge_event() const
	{
	return _negedgeEvent;
	}

	virtual bool
	event() const
	{
	sc_channel_warn_unimpl(__PRETTY_FUNCTION__);
	return false;
	}
	virtual bool
	posedge() const
	{
	sc_channel_warn_unimpl(__PRETTY_FUNCTION__);
	return false;
	}
	virtual bool
	negedge() const
	{
	sc_channel_warn_unimpl(__PRETTY_FUNCTION__);
	return false;
	}

	virtual void print(std::ostream &os=std::cout) const { os << m_cur_val; }
	virtual void
	dump(std::ostream &os=std::cout) const
	{
	os << " name = " << name() << ::std::endl;
	os << " value = " << m_cur_val << ::std::endl;
	os << "new value = " << m_new_val << ::std::endl;
	}
	virtual const char *kind() const { return "sc_signal"; }

	protected:
	virtual void
	update()
	{
	if (m_new_val == m_cur_val)
	return;

	m_cur_val = m_new_val;
	_valueChangedEvent.notify(SC_ZERO_TIME);
	if (m_cur_val)
	_posedgeEvent.notify(SC_ZERO_TIME);
	else
	_negedgeEvent.notify(SC_ZERO_TIME);
	}

	bool m_cur_val;
	bool m_new_val;

	private:
	sc_event _valueChangedEvent;
	sc_event _posedgeEvent;
	sc_event _negedgeEvent;

	// Disabled
	sc_signal(const sc_signal<bool, WRITER_POLICY> &) :
	sc_signal_inout_if<bool>(), sc_prim_channel("")
	{}
	};

	template <sc_writer_policy WRITER_POLICY>
	class sc_signal<sc_dt::sc_logic, WRITER_POLICY> :
	public sc_signal_inout_if<sc_dt::sc_logic>, public sc_prim_channel
	{
	public:
	sc_signal() : sc_signal_inout_if<sc_dt::sc_logic>(),
	sc_prim_channel(sc_gen_unique_name("signal")),
	m_cur_val(sc_dt::sc_logic()), m_new_val(sc_dt::sc_logic())
	{}
	explicit sc_signal(const char *name) :
	sc_signal_inout_if<sc_dt::sc_logic>(), sc_prim_channel(name),
	m_cur_val(sc_dt::sc_logic()), m_new_val(sc_dt::sc_logic())
	{}
	explicit sc_signal(const char *name,
	const sc_dt::sc_logic &initial_value) :
	sc_signal_inout_if<sc_dt::sc_logic>(), sc_prim_channel(name),
	m_cur_val(initial_value), m_new_val(initial_value)
	{}
	virtual ~sc_signal() {}

	virtual void
	register_port(sc_port_base &, const char *)
	{
	sc_channel_warn_unimpl(__PRETTY_FUNCTION__);
	}

	virtual const sc_dt::sc_logic &read() const { return m_cur_val; }
	operator const sc_dt::sc_logic &() const { return read(); }

	virtual sc_writer_policy
	get_writer_policy() const
	{
	return WRITER_POLICY;
	}
	virtual void
	write(const sc_dt::sc_logic &l)
	{
	m_new_val = l;
	bool changed = !(m_cur_val == m_new_val);
	//TODO check whether this write follows the write policy.
	if (changed)
	request_update();
	}
	sc_signal<sc_dt::sc_logic, WRITER_POLICY> &
	operator = (const sc_dt::sc_logic &l)
	{
	write(l);
	return *this;
	}
	sc_signal<sc_dt::sc_logic, WRITER_POLICY> &
	operator = (const sc_signal<sc_dt::sc_logic, WRITER_POLICY> &s)
	{
	write(s.read());
	return *this;
	}

	virtual const sc_event &
	default_event() const
	{
	return value_changed_event();
	}

	virtual const sc_event &
	value_changed_event() const
	{
	return _valueChangedEvent;
	}
	virtual const sc_event &
	posedge_event() const
	{
	return _posedgeEvent;
	}
	virtual const sc_event &
	negedge_event() const
	{
	return _negedgeEvent;
	}

	virtual bool
	event() const
	{
	sc_channel_warn_unimpl(__PRETTY_FUNCTION__);
	return false;
	}
	virtual bool
	posedge() const
	{
	sc_channel_warn_unimpl(__PRETTY_FUNCTION__);
	return false;
	}
	virtual bool
	negedge() const
	{
	sc_channel_warn_unimpl(__PRETTY_FUNCTION__);
	return false;
	}

	virtual void print(std::ostream &os=std::cout) const { os << m_cur_val; }
	virtual void
	dump(std::ostream &os=std::cout) const
	{
	os << " name = " << name() << ::std::endl;
	os << " value = " << m_cur_val << ::std::endl;
	os << "new value = " << m_new_val << ::std::endl;
	}
	virtual const char *kind() const { return "sc_signal"; }

	protected:
	virtual void
	update()
	{
	if (m_new_val == m_cur_val)
	return;

	m_cur_val = m_new_val;
	_valueChangedEvent.notify(SC_ZERO_TIME);
	if (m_cur_val == sc_dt::SC_LOGIC_1)
	_posedgeEvent.notify(SC_ZERO_TIME);
	else if (m_cur_val == sc_dt::SC_LOGIC_0)
	_negedgeEvent.notify(SC_ZERO_TIME);
	}

	sc_dt::sc_logic m_cur_val;
	sc_dt::sc_logic m_new_val;

	private:
	sc_event _valueChangedEvent;
	sc_event _posedgeEvent;
	sc_event _negedgeEvent;

	// Disabled
	sc_signal(const sc_signal<sc_dt::sc_logic, WRITER_POLICY> &) :
	sc_signal_inout_if<sc_dt::sc_logic>(), sc_prim_channel("")
	{}
	};

	} // namespace sc_core

	#endif //__SYSTEMC_EXT_CHANNEL_SC_SIGNAL_HH__