/home/fb/sf/compp/trunk/ComPP/ComPlusPlus/Poll.cpp

Go to the documentation of this file.

// **************************************************************
// Com ++ Framework by the C++ World
// Please report defects: mailto:compp@cplusplusworld.com
// Please visit: http://www.cplusplusworld.com/socketlibrary.html
// **************************************************************

#include <iostream>

#include "SysPlusPlus/syscall.h"
#include <string.h>


#include "ComPlusPlus/Poll.h"
#include "ComPlusPlus/Comm.h"

#include "ComPlusPlus/SocketTcp.h"
#include <unistd.h>
#include "SysPlusPlus/ComException.h"

// Destructor
compp::Poll::~Poll () {

}
  

compp::Poll::Poll ( ) {

  NumConn = 0;
  Timeout = StdPollTimeout;
  FD_ZERO( & rdset );
  FD_ZERO( & wrset );
  FD_ZERO( & errset );
  ErrorContainer.clear();
  ReadContainer.clear();
  WriteContainer.clear();
} 
 
void compp::Poll::AddWriteQueue( compp::Comm * Channel ) {

  if ( Channel == NULL ) {
            throw syspp::ComException("CommunicationChannel is NULL.");
  }
  int FD;

  if ( ( FD = Channel->GetFd ()) == -1 ) {
    throw syspp::ComException("CommunicationChannel not initialised.");
  } 
  WriteContainer[FD] = Channel;
}

void compp::Poll::AddReadQueue( Comm * Channel ){

  if ( Channel == NULL ) {
            throw syspp::ComException("CommunicationChannel is NULL.");
  }

  int FD;

  if ( (FD = Channel->GetFd ()) == -1 ) {
        throw syspp::ComException("CommunicationChannel not initialised.");
  }
 
  ReadContainer[FD] = Channel;
 

}

void compp::Poll::AddErrorQueue( Comm * Channel ){

  if ( Channel == NULL ) {
            throw syspp::ComException("CommunicationChannel is NULL.");
  }

  int FD;

  if ( (FD = Channel->GetFd ()) == -1 ) {
    throw syspp::ComException("CommunicationChannel not initialised.");
  }
  ErrorContainer[FD] = Channel;
}

void compp::Poll::SetTimeout ( int usecs ) {
        this->Timeout = usecs;
}

int compp::Poll::Multiplexer ( ) {
        return Multiplexer ( this->Timeout ) ;
}

int compp::Poll::Multiplexer ( int usecs ) {

  struct timeval tv, *tvp;

      if ( usecs >= 0 ) {
    memset   (&tv, 0, sizeof(tv));
    tv.tv_sec  = usecs / 1000000;
    tv.tv_usec = usecs % 1000000;
    tvp = &tv;
  } else {
    tvp = NULL;
  }
      
   int maxfd=0;
   std::map<int, Comm*>::iterator iter;
   // *********** WRITECONTAINER ******************
   for ( iter=WriteContainer.begin(); iter != WriteContainer.end(); ++iter ) {
          
          int i;
          i = iter->second->GetFd();
          FD_SET( i, &wrset);
          maxfd = maxfd < i ? i : maxfd;
   }

   // *********** READCONTAINER ******************
   for ( iter=ReadContainer.begin(); iter != ReadContainer.end(); ++iter ) {
          int i;
          i = iter->second->GetFd();
          FD_SET( i, &rdset);
          maxfd = maxfd < i ? i : maxfd;
   }

   // *********** READCONTAINER ******************
   for ( iter=ErrorContainer.begin(); iter != ErrorContainer.end(); ++iter ) {
          int i;
          i = iter->second->GetFd();
          FD_SET( i, &errset);
          maxfd = maxfd < i ? i : maxfd;
   }
   

    int retv;
    if (-1 == (retv = syspp::Call::Select (maxfd + 1, &rdset, &wrset, &errset, tvp))) {
      throw  syspp::ComException (  "compp::Comm::PollRcv. Select failed" );
    }
    
    return retv;
}

bool compp::Poll::CheckAll( Comm * Channel ) {
  
if ( FD_ISSET ( Channel->GetFd(), &rdset ) ) {
        return true;    
}

if ( FD_ISSET ( Channel->GetFd(), &wrset ) ) {
        return true;    
}

if ( FD_ISSET ( Channel->GetFd(), &errset ) ) {
        return true;    
}

return false;

}

bool compp::Poll::CheckReadQueue( Comm * Channel ) {
  
        if ( FD_ISSET ( Channel->GetFd(), &rdset ) ) {
         return true;   
        }

        return false;
}

bool compp::Poll::CheckWriteQueue( Comm * Channel ) {
if ( FD_ISSET ( Channel->GetFd(), &wrset ) ) {
        return true;    
}
return false;
}

bool compp::Poll::CheckErrorQueue( Comm * Channel ) {
  

if ( FD_ISSET ( Channel->GetFd(), &errset ) ) {
        return true;    
}

return false;

}

void compp::Poll::EmptyWriteQueue( ) {
          FD_ZERO( & wrset );
          WriteContainer.clear();
}

void compp::Poll::EmptyReadQueue ( ){
          FD_ZERO( & rdset );
          ReadContainer.clear();
}

void compp::Poll::EmptyErrorQueue( ) {
          FD_ZERO( & errset );
          ErrorContainer.clear();         
} 

void compp::Poll::EmptyAllQueues( ) {
          FD_ZERO( & wrset );
          FD_ZERO( & rdset );
          FD_ZERO( & errset );
          ErrorContainer.clear();
          ReadContainer.clear();
          WriteContainer.clear();
}

---