ASSA Namespace Reference


Classes

class  Acceptor
class  Address
class  AutoPtrRef
 A wrapper class to provide AutoPtr with reference semantics. More...
class  AutoPtr
 AutoPtr is based on SGI implementation of a auto_ptr template that makes memory handling a little bit easier. More...
class  AutoPtrArrayRef
 A wrapper class to provide AutoPtr with reference semantics. More...
class  AutoPtrArray
 AutoPtrArray handles memory management of an array of objects. More...
class  CharInBuffer
 CharInBuffer is a bucket for the character-based streams/messages. More...
class  Option
 Option class. More...
class  CmdLineOpts
 Class CmdLineOpts. More...
class  Connector
 Connector is a template class for initialization of communication services. More...
class  ConUDPSocket
class  Destroyer
class  EventHandler
 EventHandler class. More...
class  FdSet
 Class FdSet. More...
class  FileLogger
class  ChildStatusHandler
 A helper class of Fork. More...
class  Fork
 Fork class is a simple wrapper around C library function fork(). More...
class  fnode_t
 forknode_t class. More...
class  ForkList
 ForkList is a singleton class that keeps a list of all forked children. More...
class  GenServer
class  SIGINTHandler
 SIGINTHandler handles SIGINT signal. More...
class  SIGUSR1Handler
 Class SIGUSR1Handler. More...
class  SIGUSR2Handler
 Class SIGUSR2Handler handles SIGUSR2 signal. More...
class  SIGCHLDHandler
 Class SIGCHLDHandler handles SIGCHLD signal. More...
class  SIGALRMHandler
 Class SIGALRMHandler handles SIGALRM signal. More...
class  SIGPOLLHandler
 Class SIGPOLLHandler handles SIGPOLL signal. More...
class  IdSet
class  INETAddress
class  IniFile
class  IPv4Socket
class  Logger
class  DiagnosticContext
 Class DiagnosticContext tracks who deep a function is in the calling stack. More...
class  Logger_Impl
class  MaskSet
class  MemDump
class  PidFileLock
class  Pipe
class  PriorityQueue
class  PriorityQueue_Heap
struct  Bfunc
 Bfunc is used by PriorityQueue_impl. More...
struct  Less
 Less is borrowed from STL implementation. More...
class  PriorityQueue_Impl
 Class PriorityQueue_Impl. More...
class  PriorityQueue_STLPQ
class  Reactor
class  Regexp
 Regexp class. More...
class  RemoteLogger
class  Repository
class  Semaphore
class  ServiceHandler
class  SigAction
class  SigHandler
class  SigHandlers
class  CFUNC_Handler
 CFUNC_Handler class. More...
class  SigHandlersList
 SigHandlersList class. More...
class  SigSet
class  Singleton
class  Socket
class  Socketbuf
class  StdOutLogger
class  io_ptrs
 io_ptrs structure. More...
class  Streambuf
 Streambuf class. More...
class  Timer
struct  TimerCompare
 TimerCompare class compares two Timers base on their expiration timestamp. More...
class  TimerCountdown
class  TimerQueue
class  TimeVal
class  UDPSocket
class  UnConUDPSocket
class  UNIXAddress
class  xdrIOBuffer

Namespaces

namespace  Log
namespace  Utils

Typedefs

typedef sockaddr SA
typedef sockaddr_in SA_IN
typedef sockaddr_un SA_UN
typedef unsigned long TimerId
 Timer Id is used in handle_timeout() calls.
typedef int(EventHandler::* EH_IO_Callback )(int)
 A type for the pointer to I/O-related callback member function of class EventHandler.
typedef unsigned long TimerId

Enumerations

enum  ConnectMode { sync, async }
enum  EventType {
  READ_EVENT = 0x01, WRITE_EVENT = 0x02, EXCEPT_EVENT = 0x04, TIMEOUT_EVENT = 0x10,
  SIGNAL_EVENT = 0x20, RWE_EVENTS = 0x07, ALL_EVENTS = 0x37
}
 EventType defines events types that Reactor understands. More...
enum  Group {
  TRACE = 0x00000001, APP = 0x00000002, USR1 = 0x00000004, USR2 = 0x00000008,
  USR3 = 0x00000010, ALL_APPS = 0x0000001F, ASSAERR = 0x00000020, PIDFLOCK = 0x00000040,
  CMDLINEOPTS = 0x00000080, SEM = 0x00000100, SIGHAND = 0x00000200, REACT = 0x00000400,
  REACTTRACE = 0x00000800, SOCK = 0x00001000, SOCKTRACE = 0x00002000, XDRBUF = 0x00004000,
  XDRBUFTRACE = 0x00008000, STRMBUF = 0x00010000, STRMBUFTRACE = 0x00020000, FORK = 0x00040000,
  SIGACT = 0x00080000, PIPE = 0x00100000, CHARINBUF = 0x00200000, ADDRESS = 0x00400000,
  INIFILE = 0x00800000, REGEXP = 0x01000000, RES5 = 0x02000000, RES6 = 0x04000000,
  RES7 = 0x08000000, RES8 = 0x10000000, RES9 = 0x20000000, RES10 = 0x40000000,
  ALL_LIB = 0x7FFFFFE0, ALL = 0x7FFFFFFF, NONE = 0x00000000
}
 Bit mask used to mask out log messages. More...
enum  marker_t { FUNC_MSG, FUNC_ENTRY, FUNC_EXIT }

Functions

Socket & operator>> (Socket &s_, CharInBuffer &b_)
 Read bytes from Socket stream until either record delimiter is detected, or EOF occured, or Socket stream is exhausted.
bool isReadEvent (EventType e_)
bool isWriteEvent (EventType e_)
bool isExceptEvent (EventType e_)
bool isTimeoutEvent (EventType e_)
bool isSignalEvent (EventType e_)
bool isRWEEvents (EventType e_)
bool isAllEvents (EventType e_)
bool is_valid_handler (handler_t socket_)
 Detect socket() error in a portable way.
void disable_handler (handler_t &socket_)
 Set socket descriptor to invalid value in a portable way.
int get_errno ()
 Fetch error number in a portable way.
void set_errno (int new_errno_)
 Set error number in a portable way.
Socket & flush (Socket &os_)
 flush manipulator.
Socket & endl (Socket &os_)
 endl manipulator.
Socket & ends (Socket &os_)
 ends manipulator.
TimeVal operator+ (const TimeVal &lhs_, const TimeVal &rhs_)
TimeVal operator- (const TimeVal &lhs_, const TimeVal &rhs_)
bool operator> (const TimeVal &lhs_, const TimeVal &rhs_)
bool operator!= (const TimeVal &lhs_, const TimeVal &rhs_)
bool operator<= (const TimeVal &lhs_, const TimeVal &rhs_)
bool operator>= (const TimeVal &lhs_, const TimeVal &rhs_)
Socket & operator>> (Socket &s_, xdrIOBuffer &b_)

Typedef Documentation

int(EventHandler::* ASSA::EH_IO_Callback)(int)
 

A type for the pointer to I/O-related callback member function of class EventHandler.

These are:

  • handle_read ()
  • handle_write ()
  • handle_except ()

See also:
EventHandler

Definition at line 236 of file EventHandler.h.

typedef struct sockaddr ASSA::SA
 

Definition at line 33 of file Address.h.

typedef struct sockaddr_in ASSA::SA_IN
 

Definition at line 34 of file Address.h.

typedef struct sockaddr_un ASSA::SA_UN
 

Definition at line 44 of file Address.h.

typedef unsigned long ASSA::TimerId
 

Definition at line 28 of file TimerQueue.h.

unsigned long ASSA::TimerId
 

Timer Id is used in handle_timeout() calls.

Definition at line 27 of file EventHandler.h.

Enumeration Type Documentation

enum ASSA::ConnectMode
 

Enumerator:
sync  Synchronous connection mode.
async  Asynchronous connection mode.

Definition at line 43 of file Connector.h.

00043                  { 
00044     sync,                   
00045     async                   
00046 };

enum ASSA::EventType
 

EventType defines events types that Reactor understands.

Enumerator:
READ_EVENT  Notify when there will be at least 1 byte available for reading from IO channel without blocking .
WRITE_EVENT  Notify when there will be room for at least 1 byte to be written to IO channel without blocking.
EXCEPT_EVENT  Notify when there is an exception condition detected in TCP layer.
TIMEOUT_EVENT  Notify about expired timer.
SIGNAL_EVENT  Notify when UNIX signal is delivered by OS.
RWE_EVENTS  READ_EVENT | WRITE_EVENT | EXCEPT_EVENT.
ALL_EVENTS  Mask that includes all events.

Definition at line 34 of file EventHandler.h.

00035 {   
00036     READ_EVENT    = 0x01,   
00039     WRITE_EVENT   = 0x02,   
00042     EXCEPT_EVENT  = 0x04,   
00044     TIMEOUT_EVENT = 0x10,   
00045     SIGNAL_EVENT  = 0x20,   
00046     RWE_EVENTS    = 0x07,   
00047     ALL_EVENTS    = 0x37    
00048 };

enum ASSA::Group
 

Bit mask used to mask out log messages.

Enumerator:
TRACE  Function call trace.
APP  Application-level messages.
USR1  Additional application-level messages.
USR2  Additional application-level messages.
USR3  Additional application-level messages.
ALL_APPS  All application-level messages.
ASSAERR  ASSA and system errors.
PIDFLOCK  Class PidFileLock messages.
CMDLINEOPTS  Class CmdLineOpts messages.
SEM  Class Semaphore messages.
SIGHAND  Class SigHandler(s) messages.
REACT  Class Reactor/PrioriyQueue messages.
REACTTRACE  Extended Reactor/PrioriyQueue messages.
SOCK  Class Socket & friends messages.
SOCKTRACE  Extended Socket & friends messages.
XDRBUF  Class xdrIOBuffer messages.
XDRBUFTRACE  Extended xdrIOBuffer messages.
STRMBUF  Class Streambuf & friends messages.
STRMBUFTRACE  Extended Streambuf & friends messages.
FORK  Class Fork messages.
SIGACT  Class SigACtion messages.
PIPE  Class Pipe messages.
CHARINBUF  Class CharInBuffer messages.
ADDRESS  Class Address & friends messages.
INIFILE  Class IniFile messages.
REGEXP  Class RegExp messages.
RES5  Reserved for future use.
RES6  Reserved for future use.
RES7  Reserved for future use.
RES8  Reserved for future use.
RES9  Reserved for future use.
RES10  Reserved for future use.
ALL_LIB  All library messages.
ALL  All messages: library + application.
NONE  Total silence.

Definition at line 25 of file LogMask.h.

00025            {
00026     TRACE        = 0x00000001, 
00027     APP          = 0x00000002, 
00028     USR1         = 0x00000004, 
00029     USR2         = 0x00000008, 
00030     USR3         = 0x00000010, 
00031     /*-----------------------------------------------------------------------*/
00032     ALL_APPS     = 0x0000001F, 
00033     /*-----------------------------------------------------------------------*/
00034     ASSAERR      = 0x00000020, 
00035     PIDFLOCK     = 0x00000040, 
00036     CMDLINEOPTS  = 0x00000080, 
00037     SEM          = 0x00000100, 
00038     SIGHAND      = 0x00000200, 
00039     REACT        = 0x00000400, 
00040     REACTTRACE   = 0x00000800, 
00041     SOCK         = 0x00001000, 
00042     SOCKTRACE    = 0x00002000, 
00043     XDRBUF       = 0x00004000, 
00044     XDRBUFTRACE  = 0x00008000, 
00045     STRMBUF      = 0x00010000, 
00046     STRMBUFTRACE = 0x00020000, 
00047     FORK         = 0x00040000, 
00048     SIGACT       = 0x00080000, 
00049     PIPE         = 0x00100000, 
00050     CHARINBUF    = 0x00200000, 
00051     ADDRESS      = 0x00400000, 
00052     INIFILE      = 0x00800000, 
00053     REGEXP       = 0x01000000, 
00054     RES5         = 0x02000000, 
00055     RES6         = 0x04000000, 
00056     RES7         = 0x08000000, 
00057     RES8         = 0x10000000, 
00058     RES9         = 0x20000000, 
00059     RES10        = 0x40000000, 
00060     /*-----------------------------------------------------------------------*/
00061     ALL_LIB      = 0x7FFFFFE0, 
00062     ALL          = 0x7FFFFFFF, 
00063     NONE         = 0x00000000  
00064 };

enum ASSA::marker_t
 

Enumerator:
FUNC_MSG 
FUNC_ENTRY 
FUNC_EXIT 

Definition at line 67 of file LogMask.h.

00067               { 
00068     FUNC_MSG,
00069     FUNC_ENTRY, 
00070     FUNC_EXIT 
00071 };

Function Documentation

void ASSA::disable_handler (  handler_t &  socket_  )  [inline]
 

Set socket descriptor to invalid value in a portable way.

socket_ is set to the value out of valid range.

Definition at line 106 of file Logger_Impl.h.

References BAD_HANDLER.

Referenced by ASSA::IPv4Socket::accept(), ASSA::Socket::close_handler(), and ASSA::IPv4Socket::open().

00107     {
00108         socket_ = BAD_HANDLER;
00109     }

Socket& ASSA::endl (  Socket &  os_  )  [inline]
 

endl manipulator.

If you want to insert a newline character ('
') to terminate a text line, you should favor the manipulator endl. This manipulator inserts a newline character and also flushes the stream buffer.

Author:
Vladislav Grinchenko

Definition at line 602 of file Socket.h.

References ASSA::Socket::flush(), and ASSA::Socket::write().

Referenced by ASSA::GenServer::display_help(), ASSA::FileLogger::dump(), ASSA::FileLogger::handle_rollover(), ASSA::GenServer::init(), and ASSA::Logger::log_open().

00603 {
00604     char c = '\n';
00605     os_.write (&c, 1);
00606     os_.flush ();
00607     return (os_);
00608 }

Socket& ASSA::ends (  Socket &  os_  )  [inline]
 

ends manipulator.

You can insert a null character (without flushing the output stream) with the manipulator ends. A common use for a Socket object is to mediate output to a stream buffer that constructs an in-memory character sequence. Such a sequence wants a terminating null character. The manipulator ends provides highly visible evidence that the null character is indeed being supplied.

Author:
Vladislav Grinchenko

Definition at line 622 of file Socket.h.

References ASSA::Socket::write().

Referenced by ASSA::Semaphore::dump(), ASSA::Socket::dumpState(), ASSA::GenServer::get_version(), ASSA::GenServer::handle_signal(), and ASSA::PidFileLock::write_pid().

00623 {
00624     char c = '\0';
00625     os_.write (&c, 1);
00626     return (os_);
00627 }

Socket& ASSA::flush (  Socket &  os_  )  [inline]
 

flush manipulator.

Flush a stream buffer.

Definition at line 587 of file Socket.h.

References ASSA::Socket::flush().

Referenced by ASSA::Logger_Impl::format_msg(), ASSA::RemoteLogger::log_close(), ASSA::FileLogger::log_close(), ASSA::RemoteLogger::log_func(), ASSA::FileLogger::log_func(), ASSA::RemoteLogger::log_msg(), ASSA::FileLogger::log_msg(), ASSA::RemoteLogger::log_open(), ASSA::FileLogger::log_raw_msg(), ASSA::StdOutLogger::log_resync(), ASSA::RemoteLogger::log_resync(), and ASSA::FileLogger::log_resync().

00588 {
00589     os_.flush ();
00590     return (os_);
00591 }

int ASSA::get_errno (   )  [inline]
 

Fetch error number in a portable way.

Definition at line 113 of file Logger_Impl.h.

Referenced by ASSA::IPv4Socket::connect(), ASSA::Connector< SERVICE_HANDLER, PEER_CONNECTOR >::handle_write(), ASSA::Socketbuf::sys_read(), and ASSA::Socketbuf::underflow().

00114     {
00115         int myerrno;
00116 #if defined (WIN32)
00117         myerrno = WSAGetLastError ();
00118 #else
00119         myerrno = errno;
00120 #endif
00121         return myerrno;
00122     }

bool ASSA::is_valid_handler (  handler_t  socket_  )  [inline]
 

Detect socket() error in a portable way.

Returns:
true if socket is in valid range; false otherwise.

Definition at line 98 of file Logger_Impl.h.

References BAD_HANDLER.

Referenced by ASSA::IPv4Socket::accept(), ASSA::Socket::clear(), ASSA::IPv4Socket::clone(), ASSA::IPv4Socket::close(), ASSA::IPv4Socket::connect(), ASSA::IPv4Socket::open(), ASSA::IPv4Socket::read(), ASSA::Reactor::removeIOHandler(), and ASSA::IPv4Socket::write().

00099     {
00100         return (socket_ != BAD_HANDLER);
00101     }

bool ASSA::isAllEvents (  EventType  e_  )  [inline]
 

Definition at line 87 of file EventHandler.h.

References isExceptEvent(), isReadEvent(), isSignalEvent(), isTimeoutEvent(), and isWriteEvent().

00088 {
00089     return isReadEvent (e_) && isWriteEvent (e_) && isExceptEvent (e_) &&
00090         isSignalEvent (e_) && isTimeoutEvent (e_) ;
00091 }

bool ASSA::isExceptEvent (  EventType  e_  )  [inline]
 

Definition at line 63 of file EventHandler.h.

References EXCEPT_EVENT.

Referenced by isAllEvents(), and isRWEEvents().

00064 {
00065     return (e_ & EXCEPT_EVENT) == EXCEPT_EVENT;
00066 }

bool ASSA::isReadEvent (  EventType  e_  )  [inline]
 

Definition at line 51 of file EventHandler.h.

References READ_EVENT.

Referenced by isAllEvents(), isRWEEvents(), ASSA::Reactor::registerIOHandler(), and ASSA::Reactor::removeHandler().

00052 {     
00053     return (e_ & READ_EVENT) == READ_EVENT;
00054 }

bool ASSA::isRWEEvents (  EventType  e_  )  [inline]
 

Definition at line 81 of file EventHandler.h.

References isExceptEvent(), isReadEvent(), and isWriteEvent().

00082 {
00083     return isReadEvent (e_) && isWriteEvent (e_) && isExceptEvent (e_);
00084 }

bool ASSA::isSignalEvent (  EventType  e_  )  [inline]
 

Definition at line 75 of file EventHandler.h.

References SIGNAL_EVENT.

Referenced by isAllEvents(), and ASSA::Reactor::registerIOHandler().

00076 {
00077     return (e_ & SIGNAL_EVENT) == SIGNAL_EVENT;
00078 }

bool ASSA::isTimeoutEvent (  EventType  e_  )  [inline]
 

Definition at line 69 of file EventHandler.h.

References TIMEOUT_EVENT.

Referenced by isAllEvents(), ASSA::Reactor::registerIOHandler(), and ASSA::Reactor::removeHandler().

00070 {
00071     return (e_ & TIMEOUT_EVENT) == TIMEOUT_EVENT;
00072 }

bool ASSA::isWriteEvent (  EventType  e_  )  [inline]
 

Definition at line 57 of file EventHandler.h.

References WRITE_EVENT.

Referenced by isAllEvents(), and isRWEEvents().

00058 {
00059     return (e_ & WRITE_EVENT) == WRITE_EVENT;
00060 }

bool ASSA::operator!= (  const TimeVal &  lhs_,
const TimeVal &  rhs_
)  [inline]
 

Definition at line 312 of file TimeVal.h.

00313 {
00314     return !( lhs_ == rhs_ );
00315 }

TimeVal ASSA::operator+ (  const TimeVal &  lhs_,
const TimeVal &  rhs_
)  [inline]
 

Definition at line 273 of file TimeVal.h.

References ASSA::TimeVal::normalize().

00274 {
00275     TimeVal temp(lhs_);
00276     temp += rhs_;
00277     temp.normalize ();
00278     return temp;
00279 }

TimeVal ASSA::operator- (  const TimeVal &  lhs_,
const TimeVal &  rhs_
)  [inline]
 

Definition at line 282 of file TimeVal.h.

References ASSA::TimeVal::normalize().

00283 {
00284     TimeVal temp(lhs_);
00285     temp -= rhs_;
00286     temp.normalize ();
00287     return temp;
00288 }

bool ASSA::operator<= (  const TimeVal &  lhs_,
const TimeVal &  rhs_
)  [inline]
 

Definition at line 318 of file TimeVal.h.

00319 {
00320     return !(rhs_ < lhs_);
00321 }

bool ASSA::operator> (  const TimeVal &  lhs_,
const TimeVal &  rhs_
)  [inline]
 

Definition at line 306 of file TimeVal.h.

00307 {
00308     return rhs_ < lhs_;
00309 }

bool ASSA::operator>= (  const TimeVal &  lhs_,
const TimeVal &  rhs_
)  [inline]
 

Definition at line 324 of file TimeVal.h.

00325 {
00326     return !(lhs_ < rhs_);
00327 }

Socket& ASSA::operator>> (  Socket &  s_,
xdrIOBuffer &  b_
) 
 

Definition at line 25 of file xdrIOBuffer.cpp.

References ASSAERR, DL, ASSA::xdrIOBuffer::dump(), EL, ASSA::xdrIOBuffer::error, ASSA::xdrIOBuffer::get_state(), ASSA::Socket::getBytesAvail(), ASSA::xdrIOBuffer::m_ptr, ASSA::xdrIOBuffer::m_state, ASSA::xdrIOBuffer::m_sz, ASSA::Socket::read(), ASSA::xdrIOBuffer::size(), trace_with_mask, ASSA::xdrIOBuffer::waiting, and XDRBUFTRACE.

00026 {
00027     trace_with_mask("Socket >> xdrIOBuffer", XDRBUFTRACE);
00028 
00029     DL((XDRBUFTRACE,"Buffer Initially:\n"));
00030     b_.dump ();
00031 
00032     if (b_.m_state != xdrIOBuffer::waiting) {
00033         EL((ASSAERR,"Wrong state: %s\n", b_.get_state ().c_str ()));
00034         return s_;
00035     }
00036     int expected = b_.m_sz - b_.size ();
00037 
00038     DL((XDRBUFTRACE,"Bytes expected: %d\n",expected));
00039     DL((XDRBUFTRACE,"Bytes in Socket buffer(s): %d\n", s_.getBytesAvail ()));
00040     int ret;
00041 
00042     if ((ret = s_.read (b_.m_ptr, expected)) <= 0) 
00043     {
00044 #if defined(WIN32)
00045         if (WSAGetLastError () != WSAEWOULDBLOCK) {
00046             WSASetLastError (0);
00047             EL((ASSAERR,"Socket::read() error!\n"));
00048             b_.m_state = xdrIOBuffer::error;
00049         }
00050 #else
00051         if (errno != EWOULDBLOCK) { 
00052             EL((ASSAERR,"Socket::read() error!\n"));
00053             b_.m_state = xdrIOBuffer::error;
00054         }
00055 #endif
00056         else {
00057             EL((ASSAERR,"Socket::read() error! \n"));
00058         }
00059         return s_;
00060     }
00061     b_.m_ptr += ret;
00062 
00063     DL((XDRBUFTRACE,"Received %d bytes\n", ret));
00064     b_.dump ();
00065 
00066     if (b_.m_sz == b_.size ()) { // at the end
00067         DL((XDRBUFTRACE,"Complete message is in the buffer!\n"));
00068         b_.m_state = xdrIOBuffer::xmitted;
00069         b_.m_ptr = b_.m_buf;    // rewind m_ptr for parsing stage
00070         b_.dump ();
00071     }
00072     return s_;
00073 }

Socket& ASSA::operator>> (  ASSA::Socket &  s_,
ASSA::CharInBuffer &  b_
) 
 

Read bytes from Socket stream until either record delimiter is detected, or EOF occured, or Socket stream is exhausted.

If match, bite off delimiter and set the state to complete. If not, continue reading till either there is no more characters to read, or Socket error (Fail or EOF), or buffer overflow. If overflow occurs, set the state to 'error' and terminate.

Definition at line 80 of file CharInBuffer.cpp.

References CHARINBUF, DL, ASSA::CharInBuffer::state(), ASSA::CharInBuffer::state_name(), trace_with_mask, and ASSA::CharInBuffer::waiting.

00081 {
00082     trace_with_mask ("Socket >> CharInBuffer", CHARINBUF);
00083     register char c;
00084 
00085     if (b_.state () != CharInBuffer::waiting) {
00086         DL((CHARINBUF,"Wrong state %s\n", b_.state_name (b_.state ())));
00087         return s_;
00088     }
00089 
00090     while (s_.read (&c, 1) == 1) 
00091     {
00092         b_.m_buffer += c;
00093 
00094         if (b_.m_buffer.size() < b_.m_delimiter.size()) { // Bug # 1252926
00095             continue;
00096         }
00097 
00098         if (b_.m_buffer.substr (
00099                 b_.m_buffer.size ()-b_.m_delimiter.size ()) == b_.m_delimiter) 
00100         {
00101             b_.chop ();
00102             b_.m_state = CharInBuffer::complete;
00103             return s_;
00104         }
00105 
00106         if (b_.m_buffer.length () >= b_.m_max_size) {
00107             b_.m_state = CharInBuffer::error;
00108             break;
00109         }
00110     }
00111 
00112     if (!s_) {                  // EOF or error
00113         b_.state (CharInBuffer::error);
00114     }
00115     
00116     return s_;
00117 }

void ASSA::set_errno (  int  new_errno_  )  [inline]
 

Set error number in a portable way.

Definition at line 126 of file Logger_Impl.h.

Referenced by ASSA::Connector< SERVICE_HANDLER, PEER_CONNECTOR >::connect(), ASSA::Connector< SERVICE_HANDLER, PEER_CONNECTOR >::doSync(), ASSA::Connector< SERVICE_HANDLER, PEER_CONNECTOR >::handle_timeout(), and ASSA::Connector< SERVICE_HANDLER, PEER_CONNECTOR >::handle_write().

00127     {
00128 #if defined (WIN32)
00129         WSASetLastError (new_errno_); 
00130 #else
00131         errno = new_errno_;
00132 #endif
00133     }

Generated on Sun Aug 13 15:08:18 2006 for libassa by  doxygen 1.4.6