/ - Diff - CSE2410 Fall 2014 Bounce - CS Projects

Revision 822d7fa2

       pthread_attr_init (&attr);
       pthread_attr_setdetachstate (&attr, PTHREAD_CREATE_DETACHED);
       /*
       pthread_attr_setstacksize (&attr, PTHREAD_STACK_MIN < sizeof (long) * 4096
                                         ? sizeof (long) * 4096 : PTHREAD_STACK_MIN);
       */
       pthread_attr_setstacksize (&attr, PTHREAD_STACK_MIN < sizeof (long) * 4096 * 4
                                         ? sizeof (long) * 4096 * 4 : PTHREAD_STACK_MIN);
     #ifdef PTHREAD_SCOPE_PROCESS
       pthread_attr_setscope (&attr, PTHREAD_SCOPE_PROCESS);
     #endif

     #define INVALID_STATE_ERR 1
     class Server {
     class HttpServer {
     public:
       Server (Handle<Object> _js_server);
       ~Server ();
       HttpServer (Handle<Object> _js_server);
       ~HttpServer ();
       int Start(struct addrinfo *servinfo);
       void Stop();
-...
       ebb_request_parser parser;
       list<HttpRequest*> requests;
       list<HttpRequest*> finished_requests;
       friend class Server;
       friend class HttpServer;
     };
     class HttpRequest {
-...
+    {
       HandleScope scope;
       Server *server = static_cast<Server*> (_server->data);
       HttpServer *server = static_cast<HttpServer*> (_server->data);
       Handle<Value> callback_v = server->Callback();
-...
     static void
     server_destroy (Persistent<Value> _, void *data)
+    {
       Server *server = static_cast<Server *> (data);
       HttpServer *server = static_cast<HttpServer *> (data);
       delete server;
+    }
     Server::Server (Handle<Object> _js_server)
     HttpServer::HttpServer (Handle<Object> _js_server)
+    {
       oi_server_init(&server, 1024);
       server.on_connection = on_connection;
-...
       js_server.MakeWeak (this, server_destroy);
+    }
     Server::~Server ()
     HttpServer::~HttpServer ()
+    {
       Stop();
       js_server.Dispose();
-...
+    }
     int
     Server::Start(struct addrinfo *servinfo)
     HttpServer::Start(struct addrinfo *servinfo)
+    {
       int r = oi_server_listen(&server, servinfo);
       if(r == 0)
-...
+    }
     void
     Server::Stop()
     HttpServer::Stop()
+    {
       oi_server_close (&server);
       oi_server_detach (&server);
-...
     /* This constructor takes 2 arguments: host, port. */
     static Handle<Value>
     newHTTPServer (const Arguments& args)
     newHTTPHttpServer (const Arguments& args)
+    {
       if (args.Length() < 3)
         return Undefined();
-...
       //
       //
       Server *server = new Server(args.This());
       HttpServer *server = new HttpServer(args.This());
       if(server == NULL)
         return Undefined(); // XXX raise error?
-...
+    {
       HandleScope scope;
       Local<FunctionTemplate> server_t = FunctionTemplate::New(newHTTPServer);
       Local<FunctionTemplate> server_t = FunctionTemplate::New(newHTTPHttpServer);
       server_t->InstanceTemplate()->SetInternalFieldCount(1);
       server_t->Set("INVALID_STATE_ERR", Integer::New(INVALID_STATE_ERR));

     /* ai_next       */ , NULL
                         };
     class Server {
     public:
       Server (Handle<Object> handle, int backlog);
       ~Server ();
       static Handle<Value> New (const Arguments& args);
       static Handle<Value> ListenTCP (const Arguments& args);
       static Handle<Value> Close (const Arguments& args);
     private:
       static oi_socket* OnConnection (oi_server *, struct sockaddr *, socklen_t);
       static Server* Unwrap (Handle<Object> handle);
       static void MakeWeak (Persistent<Value> _, void *data);
       oi_server server_;
       Persistent<Object> handle_;
     };
     class Socket {
     public:
       Socket (Handle<Object> obj, double timeout);
       Socket (Handle<Object> handle, double timeout);
       ~Socket ();
       void SetEncoding (enum encoding);
       void SetEncoding (Handle<Value>);
       void SetTimeout (double);
       static Handle<Value> New (const Arguments& args);
       static Handle<Value> Write (const Arguments& args);
       static Handle<Value> Close (const Arguments& args);
       static Handle<Value> ConnectTCP (const Arguments& args);
       static Handle<Value> SetEncoding (const Arguments& args);
     private:
       static void OnConnect (oi_socket *socket);
       static void OnRead (oi_socket *s, const void *buf, size_t count);
       static void OnDrain (oi_socket *s);
-...
       static void OnClose (oi_socket *s);
       static void OnTimeout (oi_socket *s);
       char *host_;
       char *port_;
     private:
       static int Resolve (eio_req *req);
       static int AfterResolve (eio_req *req);
-...
       enum {UTF8, RAW} encoding_;
       oi_socket socket_;
       Persistent<Object> handle_;
       char *host_;
       char *port_;
     };
     Server::Server (Handle<Object> handle, int backlog)
+    {
       oi_server_init(&server_, backlog);
       server_.on_connection = Server::OnConnection;
     //  server_.on_error      = Server::OnError;
       server_.data = this;
       HandleScope scope;
       handle_ = Persistent<Object>::New(handle);
       handle_->SetInternalField(0, External::New(this));
       handle_.MakeWeak(this, Server::MakeWeak);
+    }
     Server::~Server ()
+    {
       oi_server_close(&server_);
       oi_server_detach(&server_);
       handle_.Dispose();
       handle_.Clear(); // necessary?
+    }
     Handle<Value>
     Server::New (const Arguments& args)
+    {
+      ;
+    }
     Handle<Value>
     Server::ListenTCP (const Arguments& args)
+    {
+      ;
+    }
     Handle<Value>
     Server::Close (const Arguments& args)
+    {
+      ;
+    }
     oi_socket*
     Server::OnConnection (oi_server *, struct sockaddr *remote_addr, socklen_t remote_addr_len)
+    {
+      ;
+    }
     Server*
     Server::Unwrap (Handle<Object> handle)
+    {
       HandleScope scope;
       Handle<External> field = Handle<External>::Cast(handle->GetInternalField(0));
       Server* server = static_cast<Server*>(field->Value());
       return server;
+    }
     void
     Server::MakeWeak (Persistent<Value> _, void *data)
+    {
       Server *s = static_cast<Server*> (data);
       delete s;
+    }
     Handle<Value>
     Socket::New(const Arguments& args)
+    {
-...
       return args.This();
+    }
     void
     Socket::SetEncoding (Handle<Value> encoding_value)
+    {
       if (encoding_value->IsString()) {
         HandleScope scope;
         Local<String> encoding_string = encoding_value->ToString();
         char buf[5]; // need enough room for "utf8" or "raw"
         encoding_string->WriteAscii(buf, 0, 4);
         buf[4] = '\0';
         if(strcasecmp(buf, "utf8") == 0)
           encoding_ = UTF8;
         else
           encoding_ = RAW;
+      }
+    }
     Socket*
     Socket::Unwrap (Handle<Object> handle)
+    {
-...
       HandleScope scope;
       handle_ = Persistent<Object>::New(handle);
       handle_->SetInternalField (0, External::New(this));
       handle_.MakeWeak (this, Socket::MakeWeak);
       handle_->SetInternalField(0, External::New(this));
       handle_.MakeWeak(this, Socket::MakeWeak);
       encoding_ = UTF8;
       encoding_ = UTF8; // default encoding.
       host_ = NULL;
       port_ = NULL;
+    }
-...
+    }
     Handle<Value>
     Socket::SetEncoding (const Arguments& args)
+    {
       Socket *socket = Socket::Unwrap(args.Holder());
       socket->SetEncoding(args[0]);
       return Undefined();
+    }
     Handle<Value>
     Socket::Write (const Arguments& args)
+    {
       HandleScope scope;
-...
       Socket *socket = static_cast<Socket*> (s->data);
       HandleScope scope;
       printf("timeout\n");
       Handle<Value> ontimeout_value = socket->handle_->Get( String::NewSymbol("onTimeout") );
       if (!ontimeout_value->IsFunction()) return;
       Handle<Function> ontimeout = Handle<Function>::Cast(ontimeout_value);
-...
       //NODE_SET_METHOD(socket_template->InstanceTemplate(), "connectUNIX", Socket::ConnectUNIX);
       NODE_SET_METHOD(socket_template->InstanceTemplate(), "write", Socket::Write);
       NODE_SET_METHOD(socket_template->InstanceTemplate(), "close", Socket::Close);
       NODE_SET_METHOD(socket_template->InstanceTemplate(), "setEncoding", Socket::SetEncoding);
       Local<FunctionTemplate> server_template = FunctionTemplate::New(Server::New);
       server_template->InstanceTemplate()->SetInternalFieldCount(1);
       target->Set(String::NewSymbol("Server"), server_template->GetFunction());
       NODE_SET_METHOD(server_template->InstanceTemplate(), "listenTCP", Server::ListenTCP);
+    }

       # Configure default variant
       conf.setenv('default')
       conf.env.append_value('CCFLAGS', ['-DNDEBUG', '-O2', '-g'])
       conf.env.append_value('CXXFLAGS', ['-DNDEBUG', '-O2', '-g'])
       conf.env.append_value('CCFLAGS', ['-DNDEBUG', '-O0', '-g'])
       conf.env.append_value('CXXFLAGS', ['-DNDEBUG', '-O0', '-g'])
       conf.write_config_header("config.h")
     def build(bld):

Also available in: Unified diff