Lots of cool new stuff, the Server class actually works for everything except

actually interacting with clients, and the Client class is almost there, except
that it doesn't really do anything yet.

15 files changed, 279 insertions, 61 deletions

diff --git a/src/client.cpp b/src/client.cpp
new file mode 100644
index 0000000..a048ca3
--- /dev/null
+++ b/src/client.cpp
@@ -0,0 +1,9 @@
+#include "client.h"
+
+Bu::Client::Client()
+{
+}
+
+Bu::Client::~Client()
+{
+}
diff --git a/src/client.h b/src/client.h
new file mode 100644
index 0000000..27fbad4
--- /dev/null
+++ b/src/client.h
@@ -0,0 +1,23 @@
+#ifndef CLIENT_H
+#define CLIENT_H
+
+#include <stdint.h>
+#include "bu/socket.h"
+
+namespace Bu
+{
+        /**
+         *
+         */
+        class Client
+        {
+        public:
+                Client();
+                virtual ~Client();
+
+        private:
+
+        };
+}
+
+#endif
diff --git a/src/file.cpp b/src/file.cpp
index 5de5f6c..26986a5 100644
--- a/src/file.cpp
+++ b/src/file.cpp
@@ -98,3 +98,13 @@ bool Bu::File::canSeek()
         return true;
 }
 
+bool Bu::File::isBlocking()
+{
+        return true;
+}
+
+void Bu::File::setBlocking( bool bBlocking )
+{
+        return;
+}
+
diff --git a/src/file.h b/src/file.h
index bbc620c..ee3fdb3 100644
--- a/src/file.h
+++ b/src/file.h
@@ -27,6 +27,9 @@ namespace Bu
                 virtual bool canWrite();
                 virtual bool canSeek();
 
+                virtual bool isBlocking();
+                virtual void setBlocking( bool bBlocking=true );
+
         private:
                 FILE *fh;
 
diff --git a/src/list.h b/src/list.h
index 4d16872..6081ea5 100644
--- a/src/list.h
+++ b/src/list.h
@@ -217,6 +217,11 @@ namespace Bu
                         {
                         }
 
+                        const_iterator( const iterator &i ) :
+                                pLink( i.pLink )
+                        {
+                        }
+
                 public:
                         bool operator==( const const_iterator &oth ) const
                         {
diff --git a/src/old/singleton.h b/src/old/singleton.h
deleted file mode 100644
index 47adbd5..0000000
--- a/src/old/singleton.h
+++ /dev/null
@@ -1,59 +0,0 @@
-#ifndef SINGLETON_H
-#define SINGLETON_H
-
-#include <stdio.h>
-
-/**
- * Provides singleton functionality in a modular sort of way.  Make this the
- * base class of any other class and you immediately gain singleton
- * functionality.  Be sure to make your constructor and various functions use
- * intellegent scoping.  Cleanup and instantiation are performed automatically
- * for you at first use and program exit.  There are two things that you must
- * do when using this template, first is to inherit from it with the name of
- * your class filling in for T and then make this class a friend of your class.
- *@code
- * // Making the Single Singleton:
- * class Single : public Singleton<Single>
- * {
- *              friend class Singleton<Single>;
- *      protected:
- *              Single();
- *              ...
- * };
- @endcode
- * You can still add public functions and variables to your new Singleton child
- * class, but your constructor should be protected (hence the need for the
- * friend decleration).
- *@author Mike Buland
- */
-template <class T>
-class Singleton
-{
-protected:
-        /**
-         * Private constructor.  This constructor is empty but has a body so that
-         * you can make your own override of it.  Be sure that you're override is
-         * also protected.
-         */
-        Singleton() {};
-
-private:
-        /**
-         * Copy constructor, defined so that you could write your own as well.
-         */
-        Singleton( const Singleton& );
-
-public:
-        /**
-         * Get a handle to the contained instance of the contained class.  It is
-         * a reference.
-         *@returns A reference to the contained object.
-         */
-        static T &getInstance()
-        {
-                static T i;
-                return i;
-        }
-};
-
-#endif
diff --git a/src/server.cpp b/src/server.cpp
new file mode 100644
index 0000000..f93238c
--- /dev/null
+++ b/src/server.cpp
@@ -0,0 +1,73 @@
+#include "server.h"
+#include <errno.h>
+
+Bu::Server::Server() :
+        nTimeoutSec( 0 ),
+        nTimeoutUSec( 0 )
+{
+        FD_ZERO( &fdActive );
+}
+
+Bu::Server::~Server()
+{
+}
+
+void Bu::Server::addPort( int nPort, int nPoolSize )
+{
+        ServerSocket *s = new ServerSocket( nPort, nPoolSize );
+        int nSocket = s->getSocket();
+        FD_SET( nSocket, &fdActive );
+        hServers.insert( nSocket, s );
+}
+
+void Bu::Server::addPort( const FString &sAddr, int nPort, int nPoolSize )
+{
+        ServerSocket *s = new ServerSocket( sAddr, nPort, nPoolSize );
+        int nSocket = s->getSocket();
+        FD_SET( nSocket, &fdActive );
+        hServers.insert( nSocket, s );
+}
+
+void Bu::Server::setTimeout( int nTimeoutSec, int nTimeoutUSec )
+{
+        this->nTimeoutSec = nTimeoutSec;
+        this->nTimeoutUSec = nTimeoutUSec;
+}
+
+void Bu::Server::scan()
+{
+        struct timeval xTimeout = { nTimeoutSec, nTimeoutUSec };
+        
+        fd_set fdRead = fdActive;
+        fd_set fdWrite = fdActive;
+        fd_set fdException = fdActive;
+
+        if( TEMP_FAILURE_RETRY( select( FD_SETSIZE, &fdRead, NULL, &fdException, &xTimeout ) ) < 0 )
+        {
+                throw ExceptionBase("Error attempting to scan open connections.");
+        }
+
+        for( int j = 0; j < FD_SETSIZE; j++ )
+        {
+                if( FD_ISSET( j, &fdRead ) )
+                {
+                        if( hServers.has( j ) )
+                        {
+                                addClient( hServers.get( j )->accept() );
+                        }
+                        else
+                        {
+                                
+                        }
+                }
+        }
+}
+
+void Bu::Server::addClient( int nSocket )
+{
+        FD_SET( nSocket, &fdActive );
+
+        Client *c = new Client();
+        hClients.insert( nSocket, c );
+}
+
diff --git a/src/server.h b/src/server.h
new file mode 100644
index 0000000..9f4f459
--- /dev/null
+++ b/src/server.h
@@ -0,0 +1,49 @@
+#ifndef SERVER_H
+#define SERVER_H
+
+#include <stdint.h>
+#include "bu/serversocket.h"
+#include "bu/list.h"
+#include "bu/client.h"
+
+namespace Bu
+{
+        /**
+         * Core of a network server.  This class is distinct from a ServerSocket in
+         * that a ServerSocket is one listening socket, nothing more.  Socket will
+         * manage a pool of both ServerSockets and connected Sockets along with
+         * their protocols and buffers.
+         *
+         * To start serving on a new port, use the addPort functions.  Each call to
+         * addPort creates a new ServerSocket, starts it listening, and adds it to
+         * the server pool.
+         *
+         * All of the real work is done by scan, which will wait for up
+         * to the timeout set by setTimeout before returning if there is no data
+         * pending.  scan should probably be called in some sort of tight
+         * loop, possibly in it's own thread, or in the main control loop.
+         */
+        class Server
+        {
+        public:
+                Server();
+                virtual ~Server();
+
+                void addPort( int nPort, int nPoolSize=40 );
+                void addPort( const FString &sAddr, int nPort, int nPoolSize=40 );
+
+                void scan();
+                void setTimeout( int nTimeoutSec, int nTimeoutUSec=0 );
+
+                void addClient( int nSocket );
+
+        private:
+                int nTimeoutSec;
+                int nTimeoutUSec;
+                fd_set fdActive;
+                Hash<int,ServerSocket *> hServers;
+                Hash<int,Client *> hClients;
+        };
+}
+
+#endif
diff --git a/src/serversocket.cpp b/src/serversocket.cpp
index c53c80d..9c8f743 100644
--- a/src/serversocket.cpp
+++ b/src/serversocket.cpp
@@ -85,6 +85,11 @@ void Bu::ServerSocket::startServer( struct sockaddr_in &name, int nPoolSize )
         FD_SET( nServer, &fdActive );
 }
 
+int Bu::ServerSocket::getSocket()
+{
+        return nServer;
+}
+
 int Bu::ServerSocket::accept( int nTimeoutSec, int nTimeoutUSec )
 {
         fd_set fdRead = fdActive;
diff --git a/src/serversocket.h b/src/serversocket.h
index f146d91..d2601e4 100644
--- a/src/serversocket.h
+++ b/src/serversocket.h
@@ -23,7 +23,8 @@ namespace Bu
                 ServerSocket( const FString &sAddr, int nPort, int nPoolSize=40 );
                 virtual ~ServerSocket();
 
-                int accept( int nTimeoutSec, int nTimeoutUSec );
+                int accept( int nTimeoutSec=0, int nTimeoutUSec=0 );
+                int getSocket();
 
         private:
                 void startServer( struct sockaddr_in &name, int nPoolSize );
diff --git a/src/singleton.h b/src/singleton.h
new file mode 100644
index 0000000..4976a61
--- /dev/null
+++ b/src/singleton.h
@@ -0,0 +1,62 @@
+#ifndef SINGLETON_H
+#define SINGLETON_H
+
+#include <stdio.h>
+
+namespace Bu
+{
+        /**
+         * Provides singleton functionality in a modular sort of way.  Make this the
+         * base class of any other class and you immediately gain singleton
+         * functionality.  Be sure to make your constructor and various functions use
+         * intellegent scoping.  Cleanup and instantiation are performed automatically
+         * for you at first use and program exit.  There are two things that you must
+         * do when using this template, first is to inherit from it with the name of
+         * your class filling in for T and then make this class a friend of your class.
+         *@code
+         * // Making the Single Singleton:
+         * class Single : public Singleton<Single>
+         * {
+         *              friend class Singleton<Single>;
+         *      protected:
+         *              Single();
+         *              ...
+         * };
+         @endcode
+         * You can still add public functions and variables to your new Singleton child
+         * class, but your constructor should be protected (hence the need for the
+         * friend decleration).
+         *@author Mike Buland
+         */
+        template <class T>
+        class Singleton
+        {
+        protected:
+                /**
+                 * Private constructor.  This constructor is empty but has a body so that
+                 * you can make your own override of it.  Be sure that you're override is
+                 * also protected.
+                 */
+                Singleton() {};
+
+        private:
+                /**
+                 * Copy constructor, defined so that you could write your own as well.
+                 */
+                Singleton( const Singleton& );
+
+        public:
+                /**
+                 * Get a handle to the contained instance of the contained class.  It is
+                 * a reference.
+                 *@returns A reference to the contained object.
+                 */
+                static T &getInstance()
+                {
+                        static T i;
+                        return i;
+                }
+        };
+}
+
+#endif
diff --git a/src/socket.cpp b/src/socket.cpp
index 455b5c8..441678a 100644
--- a/src/socket.cpp
+++ b/src/socket.cpp
@@ -231,3 +231,12 @@ bool Bu::Socket::canSeek()
         return false;
 }
 
+bool Bu::Socket::isBlocking()
+{
+        return false;
+}
+
+void Bu::Socket::setBlocking( bool bBlocking )
+{
+}
+
diff --git a/src/socket.h b/src/socket.h
index 568cad6..e65eb74 100644
--- a/src/socket.h
+++ b/src/socket.h
@@ -33,7 +33,8 @@ namespace Bu
                 virtual bool canWrite();
                 virtual bool canSeek();
 
-                
+                virtual bool isBlocking();
+                virtual void setBlocking( bool bBlocking=true );
 
         private:
                 int nSocket;
diff --git a/src/stream.h b/src/stream.h
index e640959..5f586e6 100644
--- a/src/stream.h
+++ b/src/stream.h
@@ -36,6 +36,9 @@ namespace Bu
                 virtual bool canWrite() = 0;
                 virtual bool canSeek() = 0;
 
+                virtual bool isBlocking() = 0;
+                virtual void setBlocking( bool bBlocking=true ) = 0;
+
         private:
 
         };
diff --git a/src/tests/hash.cpp b/src/tests/hash.cpp
new file mode 100644
index 0000000..73cfb27
--- /dev/null
+++ b/src/tests/hash.cpp
@@ -0,0 +1,24 @@
+#include "bu/hash.h"
+#include "bu/sptr.h"
+
+typedef struct Bob
+{
+        int nID;
+} Bob;
+
+int main()
+{
+        Bu::Hash<int, Bu::SPtr<const Bob> > lb;
+        for( int j = 0; j < 10; j++ )
+        {
+                Bob *b = new Bob;
+                b->nID = j;
+                lb.insert( j, b );
+        }
+
+        for( int j = 0; j < 10; j++ )
+        {
+                printf("%d\n", lb[j].value()->nID );
+        }
+}
+