void MockPhysicalLayerAsync::TriggerRead(const std::string& arData)
{
HexSequence hs(arData);
assert(hs.Size() <= this->mNumToRead);
memcpy(mpWriteBuff, hs.Buffer(), hs.Size());
mNumToRead = 0;
error_code ec(errc::success, get_generic_category());
this->OnReadCallback(ec, mpWriteBuff, hs.Size());
}
MockPhysicalLayerAsyncTS::MockPhysicalLayerAsyncTS(Logger* apLogger, MockTimerSource* apTimerSrc) :
PhysicalLayerAsyncBase(apLogger),
mpTimerSrc(apTimerSrc),
mpOpenTimer(NULL),
mErrorCode(errc::permission_denied, get_generic_category()),
mWriteBuffer(1024)
{
this->Reset();
}
BOOST_SYSTEM_DECL error_category const & error_category::find_category(char const * name)
{
std::vector<error_category const *>::const_iterator iter = get_categories().begin();
std::vector<error_category const *>::const_iterator end = get_categories().end();
for (; iter != end; ++iter)
if (strcmp((*iter)->name(), name) == 0)
return **iter;
assert(false);
return get_generic_category();
}
void LoopbackPhysicalLayerAsync::DoAsyncWrite(const byte_t* apData, size_t aNumBytes)
{
for(size_t i=0; i<aNumBytes; ++i) mWritten.push_back(apData[i]);
//always write successfully
error_code ec(errc::success, get_generic_category());
mpService->post(bind(&LoopbackPhysicalLayerAsync::OnWriteCallback, this, ec, aNumBytes));
//now check to see if this write will dispatch a read
this->CheckForReadDispatch();
}
void LoopbackPhysicalLayerAsync::DoClose()
{
//empty any remaining written data
mWritten.erase(mWritten.begin(), mWritten.end());
//dispatch any pending reads with failures
if(mReadSize > 0) {
mReadSize = 0;
error_code ec(errc::permission_denied, get_generic_category());
mpService->post(bind(&LoopbackPhysicalLayerAsync::OnReadCallback, this, ec, mpReadBuff, 0));
}
}
void LoopbackPhysicalLayerAsync::CheckForReadDispatch()
{
if(mReadSize > 0 && mWritten.size() > 0) {
size_t num = (mReadSize < mWritten.size()) ? mReadSize : mWritten.size();
for(size_t i=0; i<num; ++i) {
mpReadBuff[i] = mWritten.front();
mWritten.pop_front();
}
mReadSize = 0;
error_code ec(errc::success, get_generic_category());
mpService->post(bind(&LoopbackPhysicalLayerAsync::OnReadCallback, this, ec, mpReadBuff, num));
}
}
void LoopbackPhysicalLayerAsync::DoOpen()
{
//always open successfully
error_code ec(errc::success, get_generic_category());
mpService->post(bind(&LoopbackPhysicalLayerAsync::OnOpenCallback, this, ec));
}
void MockPhysicalLayerAsync::SignalSendFailure()
{
mNumToWrite = 0;
error_code ec(errc::permission_denied, get_generic_category());
this->OnWriteCallback(ec, 0);
}
// explicit conversion:
inline error_code make_error_code( errc_t e )
{ return error_code( e, get_generic_category() ); }
// implicit conversion:
inline error_condition make_error_condition( errc_t e )
{ return error_condition( e, get_generic_category() ); }
void clear()
{
m_val = 0;
m_cat = &get_generic_category();
}
namespace system
{
class error_code;
class error_condition;
// "Concept" helpers ---------------------------------------------------//
template< class T >
struct is_error_code_enum { static const bool value = false; };
template< class T >
struct is_error_condition_enum { static const bool value = false; };
// generic error_conditions --------------------------------------------//
namespace errc
{
enum errc_t
{
success = 0,
address_family_not_supported = EAFNOSUPPORT,
address_in_use = EADDRINUSE,
address_not_available = EADDRNOTAVAIL,
already_connected = EISCONN,
argument_list_too_long = E2BIG,
argument_out_of_domain = EDOM,
bad_address = EFAULT,
bad_file_descriptor = EBADF,
bad_message = EBADMSG,
broken_pipe = EPIPE,
connection_aborted = ECONNABORTED,
connection_already_in_progress = EALREADY,
connection_refused = ECONNREFUSED,
connection_reset = ECONNRESET,
cross_device_link = EXDEV,
destination_address_required = EDESTADDRREQ,
device_or_resource_busy = EBUSY,
directory_not_empty = ENOTEMPTY,
executable_format_error = ENOEXEC,
file_exists = EEXIST,
file_too_large = EFBIG,
filename_too_long = ENAMETOOLONG,
function_not_supported = ENOSYS,
host_unreachable = EHOSTUNREACH,
identifier_removed = EIDRM,
illegal_byte_sequence = EILSEQ,
inappropriate_io_control_operation = ENOTTY,
interrupted = EINTR,
invalid_argument = EINVAL,
invalid_seek = ESPIPE,
io_error = EIO,
is_a_directory = EISDIR,
message_size = EMSGSIZE,
network_down = ENETDOWN,
network_reset = ENETRESET,
network_unreachable = ENETUNREACH,
no_buffer_space = ENOBUFS,
no_child_process = ECHILD,
no_link = ENOLINK,
no_lock_available = ENOLCK,
no_message_available = ENODATA,
no_message = ENOMSG,
no_protocol_option = ENOPROTOOPT,
no_space_on_device = ENOSPC,
no_stream_resources = ENOSR,
no_such_device_or_address = ENXIO,
no_such_device = ENODEV,
no_such_file_or_directory = ENOENT,
no_such_process = ESRCH,
not_a_directory = ENOTDIR,
not_a_socket = ENOTSOCK,
not_a_stream = ENOSTR,
not_connected = ENOTCONN,
not_enough_memory = ENOMEM,
not_supported = ENOTSUP,
operation_canceled = ECANCELED,
operation_in_progress = EINPROGRESS,
operation_not_permitted = EPERM,
operation_not_supported = EOPNOTSUPP,
operation_would_block = EWOULDBLOCK,
owner_dead = EOWNERDEAD,
permission_denied = EACCES,
protocol_error = EPROTO,
protocol_not_supported = EPROTONOSUPPORT,
read_only_file_system = EROFS,
resource_deadlock_would_occur = EDEADLK,
resource_unavailable_try_again = EAGAIN,
result_out_of_range = ERANGE,
state_not_recoverable = ENOTRECOVERABLE,
stream_timeout = ETIME,
text_file_busy = ETXTBSY,
timed_out = ETIMEDOUT,
too_many_files_open_in_system = ENFILE,
too_many_files_open = EMFILE,
too_many_links = EMLINK,
too_many_synbolic_link_levels = ELOOP,
value_too_large = EOVERFLOW,
wrong_protocol_type = EPROTOTYPE
};
} // namespace errc
# ifndef BOOST_SYSTEM_NO_DEPRECATED
namespace posix = errc;
namespace posix_error = errc;
# endif
template<> struct is_error_condition_enum<errc::errc_t>
{ static const bool value = true; };
// ----------------------------------------------------------------------//
// Operating system specific interfaces --------------------------------//
// The interface is divided into general and system-specific portions to
// meet these requirements:
//
// * Code calling an operating system API can create an error_code with
// a single category (system_category), even for POSIX-like operating
// systems that return some POSIX errno values and some native errno
// values. This code should not have to pay the cost of distinguishing
// between categories, since it is not yet known if that is needed.
//
// * Users wishing to write system-specific code should be given enums for
// at least the common error cases.
//
// * System specific code should fail at compile time if moved to another
// operating system.
// The system specific portions of the interface are located in headers
// with names reflecting the operating system. For example,
//
// <boost/system/cygwin_error.hpp>
// <boost/system/linux_error.hpp>
// <boost/system/windows_error.hpp>
//
// These headers are effectively empty for compiles on operating systems
// where they are not applicable.
// ----------------------------------------------------------------------//
// class error_category ------------------------------------------------//
class error_category : public noncopyable
{
public:
virtual ~error_category(){}
virtual inline const char * name() const; // see implementation note below
virtual inline std::string message( int ev ) const; // see implementation note below
virtual inline error_condition default_error_condition( int ev ) const;
virtual inline bool equivalent( int code, const error_condition & condition ) const;
virtual inline bool equivalent( const error_code & code, int condition ) const;
bool operator==(const error_category & rhs) const { return this == &rhs; }
bool operator!=(const error_category & rhs) const { return this != &rhs; }
bool operator<( const error_category & rhs ) const
{
return std::less<const error_category*>()( this, &rhs );
}
};
// predefined error categories -----------------------------------------//
BOOST_SYSTEM_DECL const error_category & get_system_category();
BOOST_SYSTEM_DECL const error_category & get_generic_category();
static const error_category & system_category = get_system_category();
static const error_category & generic_category = get_generic_category();
# ifndef BOOST_SYSTEM_NO_DEPRECATED
// deprecated synonyms
static const error_category & posix_category = get_generic_category();
static const error_category & errno_ecat = get_generic_category();
static const error_category & native_ecat = get_system_category();
# endif
// class error_condition -----------------------------------------------//
// error_conditions are portable, error_codes are system or lib specific
class error_condition
{
public:
// constructors:
error_condition() : m_val(0), m_cat(&get_generic_category()) {}
error_condition( int val, const error_category & cat ) : m_val(val), m_cat(&cat) {}
template <class ConditionEnum>
error_condition(ConditionEnum e,
typename boost::enable_if<is_error_condition_enum<ConditionEnum> >::type* = 0)
{
*this = make_error_condition(e);
}
// modifiers:
void assign( int val, const error_category & cat )
{
m_val = val;
m_cat = &cat;
}
template<typename ConditionEnum>
typename boost::enable_if<is_error_condition_enum<ConditionEnum>, error_condition>::type &
operator=( ConditionEnum val )
{
*this = make_error_condition(val);
return *this;
}
void clear()
{
m_val = 0;
m_cat = &get_generic_category();
}
// observers:
int value() const { return m_val; }
const error_category & category() const { return *m_cat; }
std::string message() const { return m_cat->message(value()); }
typedef void (*unspecified_bool_type)();
static void unspecified_bool_true() {}
operator unspecified_bool_type() const // true if error
{
return m_val == 0 ? 0 : unspecified_bool_true;
}
bool operator!() const // true if no error
{
return m_val == 0;
}
// relationals:
// the more symmetrical non-member syntax allows enum
// conversions work for both rhs and lhs.
inline friend bool operator==( const error_condition & lhs,
const error_condition & rhs )
{
return lhs.m_cat == rhs.m_cat && lhs.m_val == rhs.m_val;
}
inline friend bool operator<( const error_condition & lhs,
const error_condition & rhs )
// the more symmetrical non-member syntax allows enum
// conversions work for both rhs and lhs.
{
return lhs.m_cat < rhs.m_cat
|| (lhs.m_cat == rhs.m_cat && lhs.m_val < rhs.m_val);
}
private:
int m_val;
const error_category * m_cat;
};
// class error_code ----------------------------------------------------//
// We want error_code to be a value type that can be copied without slicing
// and without requiring heap allocation, but we also want it to have
// polymorphic behavior based on the error category. This is achieved by
// abstract base class error_category supplying the polymorphic behavior,
// and error_code containing a pointer to an object of a type derived
// from error_category.
class error_code
{
public:
// constructors:
error_code() : m_val(0), m_cat(&get_system_category()) {}
error_code( int val, const error_category & cat ) : m_val(val), m_cat(&cat) {}
template <class CodeEnum>
error_code(CodeEnum e,
typename boost::enable_if<is_error_code_enum<CodeEnum> >::type* = 0)
{
*this = make_error_code(e);
}
// modifiers:
void assign( int val, const error_category & cat )
{
m_val = val;
m_cat = &cat;
}
template<typename CodeEnum>
typename boost::enable_if<is_error_code_enum<CodeEnum>, error_code>::type &
operator=( CodeEnum val )
{
*this = make_error_code(val);
return *this;
}
void clear()
{
m_val = 0;
m_cat = &get_system_category();
}
// observers:
int value() const { return m_val; }
const error_category & category() const { return *m_cat; }
error_condition default_error_condition() const { return m_cat->default_error_condition(value()); }
std::string message() const { return m_cat->message(value()); }
typedef void (*unspecified_bool_type)();
static void unspecified_bool_true() {}
operator unspecified_bool_type() const // true if error
{
return m_val == 0 ? 0 : unspecified_bool_true;
}
bool operator!() const // true if no error
{
return m_val == 0;
}
// relationals:
inline friend bool operator==( const error_code & lhs,
const error_code & rhs )
// the more symmetrical non-member syntax allows enum
// conversions work for both rhs and lhs.
{
return lhs.m_cat == rhs.m_cat && lhs.m_val == rhs.m_val;
}
inline friend bool operator<( const error_code & lhs,
const error_code & rhs )
// the more symmetrical non-member syntax allows enum
// conversions work for both rhs and lhs.
{
return lhs.m_cat < rhs.m_cat
|| (lhs.m_cat == rhs.m_cat && lhs.m_val < rhs.m_val);
}
private:
int m_val;
const error_category * m_cat;
};
// non-member functions ------------------------------------------------//
inline bool operator!=( const error_code & lhs,
const error_code & rhs )
{
return !(lhs == rhs);
}
inline bool operator!=( const error_condition & lhs,
const error_condition & rhs )
{
return !(lhs == rhs);
}
inline bool operator==( const error_code & code,
const error_condition & condition )
{
return code.category().equivalent( code.value(), condition )
|| condition.category().equivalent( code, condition.value() );
}
inline bool operator!=( const error_code & lhs,
const error_condition & rhs )
{
return !(lhs == rhs);
}
inline bool operator==( const error_condition & condition,
const error_code & code )
{
return condition.category().equivalent( code, condition.value() )
|| code.category().equivalent( code.value(), condition );
}
inline bool operator!=( const error_condition & lhs,
const error_code & rhs )
{
return !(lhs == rhs);
}
// TODO: both of these may move elsewhere, but the LWG hasn't spoken yet.
template <class charT, class traits>
inline std::basic_ostream<charT,traits>&
operator<< (std::basic_ostream<charT,traits>& os, error_code ec)
{
os << ec.category().name() << ':' << ec.value();
return os;
}
inline std::size_t hash_value( const error_code & ec )
{
return static_cast<std::size_t>(ec.value())
+ reinterpret_cast<std::size_t>(&ec.category());
}
// make_* functions for errc::errc_t -----------------------------//
namespace errc
{
// explicit conversion:
inline error_code make_error_code( errc_t e )
{ return error_code( e, get_generic_category() ); }
// implicit conversion:
inline error_condition make_error_condition( errc_t e )
{ return error_condition( e, get_generic_category() ); }
}
// error_category default implementation -------------------------------//
inline error_condition error_category::default_error_condition( int ev ) const
{
return error_condition( ev, *this );
}
inline bool error_category::equivalent( int code,
const error_condition & condition ) const
{
return default_error_condition( code ) == condition;
}
inline bool error_category::equivalent( const error_code & code,
int condition ) const
{
return *this == code.category() && code.value() == condition;
}
// error_category implementation note: VC++ 8.0 objects to name() and
// message() being pure virtual functions. Thus these implementations.
inline const char * error_category::name() const
{
return "error: should never be called";
}
inline std::string error_category::message( int ) const
{
static std::string s("error: should never be called");
return s;
}
} // namespace system
// deprecated synonyms
inline const error_category & get_posix_category() { return get_generic_category(); }
// constructors:
error_condition() : m_val(0), m_cat(&get_generic_category()) {}
error_code()
: val_(success)
, cat_(&get_generic_category())
{
}
void MockPhysicalLayerAsync::TriggerClose()
{
error_code ec(errc::connection_aborted, get_generic_category());
this->OnReadCallback(ec, mpWriteBuff, 0);
}
void MockPhysicalLayerAsync::SignalSendSuccess()
{
size_t num = mNumToWrite; mNumToWrite = 0;
error_code ec(errc::success, get_generic_category());
this->OnWriteCallback(ec, num);
}
void MockPhysicalLayerAsync::SignalOpenFailure()
{
error_code ec(errc::permission_denied, get_generic_category());
this->OnOpenCallback(ec);
}
void MockPhysicalLayerAsync::SignalOpenSuccess()
{
error_code ec(errc::success, get_generic_category());
this->OnOpenCallback(ec);
}
void MockPhysicalLayerAsync::SignalReadFailure()
{
mNumToRead = 0;
error_code ec(errc::permission_denied, get_generic_category());
this->OnReadCallback(ec, mpWriteBuff, 0);
}
inline error_code make_error_code(generic_errors e)
{
return error_code(static_cast<int>(e), get_generic_category());
}
