#ifndef CONNECTIONREADER_H

#define CONNECTIONREADER_H

#include "pandabase.h"

#include "connection.h"

#include "pointerTo.h"

#include "pmutex.h"

#include "lightMutex.h"

#include "pvector.h"

#include "pset.h"

#include "socket_fdset.h"

#include "atomicAdjust.h"

class NetDatagram;

class ConnectionManager;

class Socket_Address;

class Socket_IP;

class EXPCL_PANDA_NET ConnectionReader {

PUBLISHED:

// The implementation here used to involve NSPR's multi-wait interface, but

// that got too complicated to manage. It turns out to be difficult to

// protect against memory leaks caused by race conditions in that interface,

// as designed.

// Instead, we do our own multi-wait type stuff. Only one thread at a time

// can extract the next-available socket with activity on it. That thread

// will either (a) simply extract the next socket from the arrays returned

// by a previous call to PR_Poll(), or (b) execute (and possibly block on) a

// new call to PR_Poll().

explicit ConnectionReader(ConnectionManager *manager, int num_threads,

const std::string &thread_name = std::string());

virtual ~ConnectionReader();

bool add_connection(Connection *connection);

bool remove_connection(Connection *connection);

bool is_connection_ok(Connection *connection);

void poll();

ConnectionManager *get_manager() const;

INLINE bool is_polling() const;

int get_num_threads() const;

void set_raw_mode(bool mode);

bool get_raw_mode() const;

void set_tcp_header_size(int tcp_header_size);

int get_tcp_header_size() const;

void shutdown();

virtual void flush_read_connection(Connection *connection);

virtual void receive_datagram(const NetDatagram &datagram)=0;

class SocketInfo {

};

typedef pvector<SocketInfo *> Sockets;

void clear_manager();

void finish_socket(SocketInfo *sinfo);

virtual bool process_incoming_data(SocketInfo *sinfo);

virtual bool process_incoming_udp_data(SocketInfo *sinfo);

virtual bool process_incoming_tcp_data(SocketInfo *sinfo);

virtual bool process_raw_incoming_udp_data(SocketInfo *sinfo);

virtual bool process_raw_incoming_tcp_data(SocketInfo *sinfo);

ConnectionManager *_manager;

// These structures track the total set of sockets (connections) we know

// about.

Sockets _sockets;

// This is the list of recently-removed sockets. We can't actually delete

// them until they're no longer _busy.

Sockets _removed_sockets;

// Any operations on _sockets are protected by this mutex.

LightMutex _sockets_mutex;

void thread_run(int thread_index);

SocketInfo *get_next_available_socket(bool allow_block,

int current_thread_index);

void rebuild_select_list();

void accumulate_fdset(Socket_fdset &fdset);

bool _raw_mode;

int _tcp_header_size;

bool _shutdown;

class ReaderThread : public Thread {

};

typedef pvector< PT(ReaderThread) > Threads;

Threads _threads;

bool _polling;

// These structures are used to manage selecting for noise on available

// sockets.

Socket_fdset _fdset;

Sockets _selecting_sockets;

int _next_index;

int _num_results;

// Threads go to sleep on this mutex waiting for their chance to read a

// socket.

Mutex _select_mutex;

// This is atomically updated with the index (in _threads) of the thread

// that is currently waiting on the PR_Poll() call. It contains -1 if no

// thread is so waiting.

AtomicAdjust::Integer _currently_polling_thread;

friend class ConnectionManager;

friend class ReaderThread;

};

#include "connectionReader.I"

#endif