Merge pull request #40 from jtomschroeder/add_inlines

dennycd · web-flow · commit d64e51042f49 · 2016-06-10T15:27:47.000-07:00
Made functions inline to avoid 'multiple definition' errors
diff --git a/native/error.h b/native/error.h
@@ -40,7 +40,7 @@ namespace native
         uv_err_t uv_err_;
     };
 
-    error get_last_error() { return uv_last_error(uv_default_loop()); }
+    inline error get_last_error() { return uv_last_error(uv_default_loop()); }
 }
 
 
diff --git a/native/fs.h b/native/fs.h
@@ -73,7 +73,7 @@ namespace native
                 delete req;
             }
 
-            void delete_req(uv_fs_t* req)
+            inline void delete_req(uv_fs_t* req)
             {
                 delete reinterpret_cast<callbacks*>(req->data);
                 uv_fs_req_cleanup(req);
@@ -122,7 +122,7 @@ namespace native
             }
         }
 
-        bool open(const std::string& path, int flags, int mode, std::function<void(native::fs::file_handle fd, error e)> callback)
+        inline bool open(const std::string& path, int flags, int mode, std::function<void(native::fs::file_handle fd, error e)> callback)
         {
             auto req = internal::create_req(callback);
             if(uv_fs_open(uv_default_loop(), req, path.c_str(), flags, mode, [](uv_fs_t* req) {
@@ -140,7 +140,7 @@ namespace native
             return true;
         }
 
-        bool read(file_handle fd, size_t len, off_t offset, std::function<void(const std::string& str, error e)> callback)
+        inline bool read(file_handle fd, size_t len, off_t offset, std::function<void(const std::string& str, error e)> callback)
         {
             auto buf = new char[len];
             auto req = internal::create_req(callback, buf);
@@ -172,7 +172,7 @@ namespace native
             return true;
         }
 
-        bool write(file_handle fd, const char* buf, size_t len, off_t offset, std::function<void(int nwritten, error e)> callback)
+        inline bool write(file_handle fd, const char* buf, size_t len, off_t offset, std::function<void(int nwritten, error e)> callback)
         {
             auto req = internal::create_req(callback);
 
@@ -198,7 +198,7 @@ namespace native
             return true;
         }
 
-        bool read_to_end(file_handle fd, std::function<void(const std::string& str, error e)> callback)
+        inline bool read_to_end(file_handle fd, std::function<void(const std::string& str, error e)> callback)
         {
             auto ctx = new internal::rte_context;
             ctx->file = fd;
@@ -212,7 +212,7 @@ namespace native
             return true;
         }
 
-        bool close(file_handle fd, std::function<void(error e)> callback)
+        inline bool close(file_handle fd, std::function<void(error e)> callback)
         {
             auto req = internal::create_req(callback);
             if(uv_fs_close(uv_default_loop(), req, fd, [](uv_fs_t* req){
@@ -226,7 +226,7 @@ namespace native
             return true;
         }
 
-        bool unlink(const std::string& path, std::function<void(error e)> callback)
+        inline bool unlink(const std::string& path, std::function<void(error e)> callback)
         {
             auto req = internal::create_req(callback);
             if(uv_fs_unlink(uv_default_loop(), req, path.c_str(), [](uv_fs_t* req){
@@ -240,7 +240,7 @@ namespace native
             return true;
         }
 
-        bool mkdir(const std::string& path, int mode, std::function<void(error e)> callback)
+        inline bool mkdir(const std::string& path, int mode, std::function<void(error e)> callback)
         {
             auto req = internal::create_req(callback);
             if(uv_fs_mkdir(uv_default_loop(), req, path.c_str(), mode, [](uv_fs_t* req){
@@ -254,7 +254,7 @@ namespace native
             return true;
         }
 
-        bool rmdir(const std::string& path, std::function<void(error e)> callback)
+        inline bool rmdir(const std::string& path, std::function<void(error e)> callback)
         {
             auto req = internal::create_req(callback);
             if(uv_fs_rmdir(uv_default_loop(), req, path.c_str(), [](uv_fs_t* req){
@@ -268,7 +268,7 @@ namespace native
             return true;
         }
 
-        bool rename(const std::string& path, const std::string& new_path, std::function<void(error e)> callback)
+        inline bool rename(const std::string& path, const std::string& new_path, std::function<void(error e)> callback)
         {
             auto req = internal::create_req(callback);
             if(uv_fs_rename(uv_default_loop(), req, path.c_str(), new_path.c_str(), [](uv_fs_t* req){
@@ -282,7 +282,7 @@ namespace native
             return true;
         }
 
-        bool chmod(const std::string& path, int mode, std::function<void(error e)> callback)
+        inline bool chmod(const std::string& path, int mode, std::function<void(error e)> callback)
         {
             auto req = internal::create_req(callback);
             if(uv_fs_chmod(uv_default_loop(), req, path.c_str(), mode, [](uv_fs_t* req){
@@ -296,7 +296,7 @@ namespace native
             return true;
         }
 
-        bool chown(const std::string& path, int uid, int gid, std::function<void(error e)> callback)
+        inline bool chown(const std::string& path, int uid, int gid, std::function<void(error e)> callback)
         {
             auto req = internal::create_req(callback);
             if(uv_fs_chown(uv_default_loop(), req, path.c_str(), uid, gid, [](uv_fs_t* req){
diff --git a/native/handle.h b/native/handle.h
@@ -10,7 +10,7 @@ namespace native
     {
         class handle;
 
-        void _delete_handle(uv_handle_t* h);
+        inline void _delete_handle(uv_handle_t* h);
 
         class handle
         {
@@ -67,7 +67,7 @@ namespace native
             uv_handle_t* uv_handle_;
         };
 
-        void _delete_handle(uv_handle_t* h)
+        inline void _delete_handle(uv_handle_t* h)
         {
             assert(h);
 
diff --git a/native/http.h b/native/http.h
@@ -501,17 +501,17 @@ namespace native
         typedef http_parser_url_fields url_fields;
         typedef http_errno error;
 
-        const char* get_error_name(error err)
+        inline const char* get_error_name(error err)
         {
             return http_errno_name(err);
         }
 
-        const char* get_error_description(error err)
+        inline const char* get_error_description(error err)
         {
             return http_errno_description(err);
         }
 
-        const char* get_method_name(method m)
+        inline const char* get_method_name(method m)
         {
             return http_method_str(m);
         }
diff --git a/native/loop.h b/native/loop.h
@@ -86,7 +86,7 @@ namespace native
     /*!
      *  Starts the default loop.
      */
-    int run()
+    inline int run()
     {
         /*New libuv requires a runmode enum argument*/
         return uv_run(uv_default_loop(),UV_RUN_DEFAULT);
@@ -95,7 +95,7 @@ namespace native
     /*!
      *  Polls for new events without blocking for the default loop.
      */
-    int run_once()
+    inline int run_once()
     {
         /*New libuv requires a runmode argument*/
         return uv_run(uv_default_loop(),UV_RUN_ONCE);
diff --git a/native/net.h b/native/net.h
@@ -11,10 +11,10 @@ namespace native
         typedef sockaddr_in ip4_addr;
         typedef sockaddr_in6 ip6_addr;
 
-        ip4_addr to_ip4_addr(const std::string& ip, int port) { return uv_ip4_addr(ip.c_str(), port); }
-        ip6_addr to_ip6_addr(const std::string& ip, int port) { return uv_ip6_addr(ip.c_str(), port); }
+        inline ip4_addr to_ip4_addr(const std::string& ip, int port) { return uv_ip4_addr(ip.c_str(), port); }
+        inline ip6_addr to_ip6_addr(const std::string& ip, int port) { return uv_ip6_addr(ip.c_str(), port); }
 
-        bool from_ip4_addr(ip4_addr* src, std::string& ip, int& port)
+        inline bool from_ip4_addr(ip4_addr* src, std::string& ip, int& port)
         {
             char dest[16];
             if(uv_ip4_name(src, dest, 16) == 0)
@@ -26,7 +26,7 @@ namespace native
             return false;
         }
 
-        bool from_ip6_addr(ip6_addr* src, std::string& ip, int& port)
+        inline bool from_ip6_addr(ip6_addr* src, std::string& ip, int& port)
         {
             char dest[46];
             if(uv_ip6_name(src, dest, 46) == 0)

Original file line number	Diff line number	Diff line change
`@@ -40,7 +40,7 @@ namespace native`
`40`	`40`	`uv_err_t uv_err_;`
`41`	`41`	`};`
`42`	`42`
`43`		`- error get_last_error() { return uv_last_error(uv_default_loop()); }`
	`43`	`+ inline error get_last_error() { return uv_last_error(uv_default_loop()); }`
`44`	`44`	`}`
`45`	`45`
`46`	`46`
Original file line number	Diff line number	Diff line change
`@@ -73,7 +73,7 @@ namespace native`
`73`	`73`	`delete req;`
`74`	`74`	`}`
`75`	`75`
`76`		`- void delete_req(uv_fs_t* req)`
	`76`	`+ inline void delete_req(uv_fs_t* req)`
`77`	`77`	`{`
`78`	`78`	`delete reinterpret_cast<callbacks*>(req->data);`
`79`	`79`	`uv_fs_req_cleanup(req);`
`@@ -122,7 +122,7 @@ namespace native`
`122`	`122`	`}`
`123`	`123`	`}`
`124`	`124`
`125`		`- bool open(const std::string& path, int flags, int mode, std::function<void(native::fs::file_handle fd, error e)> callback)`
	`125`	`+ inline bool open(const std::string& path, int flags, int mode, std::function<void(native::fs::file_handle fd, error e)> callback)`
`126`	`126`	`{`
`127`	`127`	`auto req = internal::create_req(callback);`
`128`	`128`	`if(uv_fs_open(uv_default_loop(), req, path.c_str(), flags, mode, [](uv_fs_t* req) {`
`@@ -140,7 +140,7 @@ namespace native`
`140`	`140`	`return true;`
`141`	`141`	`}`
`142`	`142`
`143`		`- bool read(file_handle fd, size_t len, off_t offset, std::function<void(const std::string& str, error e)> callback)`
	`143`	`+ inline bool read(file_handle fd, size_t len, off_t offset, std::function<void(const std::string& str, error e)> callback)`
`144`	`144`	`{`
`145`	`145`	`auto buf = new char[len];`
`146`	`146`	`auto req = internal::create_req(callback, buf);`
`@@ -172,7 +172,7 @@ namespace native`
`172`	`172`	`return true;`
`173`	`173`	`}`
`174`	`174`
`175`		`- bool write(file_handle fd, const char* buf, size_t len, off_t offset, std::function<void(int nwritten, error e)> callback)`
	`175`	`+ inline bool write(file_handle fd, const char* buf, size_t len, off_t offset, std::function<void(int nwritten, error e)> callback)`
`176`	`176`	`{`
`177`	`177`	`auto req = internal::create_req(callback);`
`178`	`178`
`@@ -198,7 +198,7 @@ namespace native`
`198`	`198`	`return true;`
`199`	`199`	`}`
`200`	`200`
`201`		`- bool read_to_end(file_handle fd, std::function<void(const std::string& str, error e)> callback)`
	`201`	`+ inline bool read_to_end(file_handle fd, std::function<void(const std::string& str, error e)> callback)`
`202`	`202`	`{`
`203`	`203`	`auto ctx = new internal::rte_context;`
`204`	`204`	`ctx->file = fd;`
`@@ -212,7 +212,7 @@ namespace native`
`212`	`212`	`return true;`
`213`	`213`	`}`
`214`	`214`
`215`		`- bool close(file_handle fd, std::function<void(error e)> callback)`
	`215`	`+ inline bool close(file_handle fd, std::function<void(error e)> callback)`
`216`	`216`	`{`
`217`	`217`	`auto req = internal::create_req(callback);`
`218`	`218`	`if(uv_fs_close(uv_default_loop(), req, fd, [](uv_fs_t* req){`
`@@ -226,7 +226,7 @@ namespace native`
`226`	`226`	`return true;`
`227`	`227`	`}`
`228`	`228`
`229`		`- bool unlink(const std::string& path, std::function<void(error e)> callback)`
	`229`	`+ inline bool unlink(const std::string& path, std::function<void(error e)> callback)`
`230`	`230`	`{`
`231`	`231`	`auto req = internal::create_req(callback);`
`232`	`232`	`if(uv_fs_unlink(uv_default_loop(), req, path.c_str(), [](uv_fs_t* req){`
`@@ -240,7 +240,7 @@ namespace native`
`240`	`240`	`return true;`
`241`	`241`	`}`
`242`	`242`
`243`		`- bool mkdir(const std::string& path, int mode, std::function<void(error e)> callback)`
	`243`	`+ inline bool mkdir(const std::string& path, int mode, std::function<void(error e)> callback)`
`244`	`244`	`{`
`245`	`245`	`auto req = internal::create_req(callback);`
`246`	`246`	`if(uv_fs_mkdir(uv_default_loop(), req, path.c_str(), mode, [](uv_fs_t* req){`
`@@ -254,7 +254,7 @@ namespace native`
`254`	`254`	`return true;`
`255`	`255`	`}`
`256`	`256`
`257`		`- bool rmdir(const std::string& path, std::function<void(error e)> callback)`
	`257`	`+ inline bool rmdir(const std::string& path, std::function<void(error e)> callback)`
`258`	`258`	`{`
`259`	`259`	`auto req = internal::create_req(callback);`
`260`	`260`	`if(uv_fs_rmdir(uv_default_loop(), req, path.c_str(), [](uv_fs_t* req){`
`@@ -268,7 +268,7 @@ namespace native`
`268`	`268`	`return true;`
`269`	`269`	`}`
`270`	`270`
`271`		`- bool rename(const std::string& path, const std::string& new_path, std::function<void(error e)> callback)`
	`271`	`+ inline bool rename(const std::string& path, const std::string& new_path, std::function<void(error e)> callback)`
`272`	`272`	`{`
`273`	`273`	`auto req = internal::create_req(callback);`
`274`	`274`	`if(uv_fs_rename(uv_default_loop(), req, path.c_str(), new_path.c_str(), [](uv_fs_t* req){`
`@@ -282,7 +282,7 @@ namespace native`
`282`	`282`	`return true;`
`283`	`283`	`}`
`284`	`284`
`285`		`- bool chmod(const std::string& path, int mode, std::function<void(error e)> callback)`
	`285`	`+ inline bool chmod(const std::string& path, int mode, std::function<void(error e)> callback)`
`286`	`286`	`{`
`287`	`287`	`auto req = internal::create_req(callback);`
`288`	`288`	`if(uv_fs_chmod(uv_default_loop(), req, path.c_str(), mode, [](uv_fs_t* req){`
`@@ -296,7 +296,7 @@ namespace native`
`296`	`296`	`return true;`
`297`	`297`	`}`
`298`	`298`
`299`		`- bool chown(const std::string& path, int uid, int gid, std::function<void(error e)> callback)`
	`299`	`+ inline bool chown(const std::string& path, int uid, int gid, std::function<void(error e)> callback)`
`300`	`300`	`{`
`301`	`301`	`auto req = internal::create_req(callback);`
`302`	`302`	`if(uv_fs_chown(uv_default_loop(), req, path.c_str(), uid, gid, [](uv_fs_t* req){`
Original file line number	Diff line number	Diff line change
`@@ -10,7 +10,7 @@ namespace native`
`10`	`10`	`{`
`11`	`11`	`class handle;`
`12`	`12`
`13`		`- void _delete_handle(uv_handle_t* h);`
	`13`	`+ inline void _delete_handle(uv_handle_t* h);`
`14`	`14`
`15`	`15`	`class handle`
`16`	`16`	`{`
`@@ -67,7 +67,7 @@ namespace native`
`67`	`67`	`uv_handle_t* uv_handle_;`
`68`	`68`	`};`
`69`	`69`
`70`		`- void _delete_handle(uv_handle_t* h)`
	`70`	`+ inline void _delete_handle(uv_handle_t* h)`
`71`	`71`	`{`
`72`	`72`	`assert(h);`
`73`	`73`
Original file line number	Diff line number	Diff line change
`@@ -501,17 +501,17 @@ namespace native`
`501`	`501`	`typedef http_parser_url_fields url_fields;`
`502`	`502`	`typedef http_errno error;`
`503`	`503`
`504`		`- const char* get_error_name(error err)`
	`504`	`+ inline const char* get_error_name(error err)`
`505`	`505`	`{`
`506`	`506`	`return http_errno_name(err);`
`507`	`507`	`}`
`508`	`508`
`509`		`- const char* get_error_description(error err)`
	`509`	`+ inline const char* get_error_description(error err)`
`510`	`510`	`{`
`511`	`511`	`return http_errno_description(err);`
`512`	`512`	`}`
`513`	`513`
`514`		`- const char* get_method_name(method m)`
	`514`	`+ inline const char* get_method_name(method m)`
`515`	`515`	`{`
`516`	`516`	`return http_method_str(m);`
`517`	`517`	`}`
Original file line number	Diff line number	Diff line change
`@@ -11,10 +11,10 @@ namespace native`
`11`	`11`	`typedef sockaddr_in ip4_addr;`
`12`	`12`	`typedef sockaddr_in6 ip6_addr;`
`13`	`13`
`14`		`- ip4_addr to_ip4_addr(const std::string& ip, int port) { return uv_ip4_addr(ip.c_str(), port); }`
`15`		`- ip6_addr to_ip6_addr(const std::string& ip, int port) { return uv_ip6_addr(ip.c_str(), port); }`
	`14`	`+ inline ip4_addr to_ip4_addr(const std::string& ip, int port) { return uv_ip4_addr(ip.c_str(), port); }`
	`15`	`+ inline ip6_addr to_ip6_addr(const std::string& ip, int port) { return uv_ip6_addr(ip.c_str(), port); }`
`16`	`16`
`17`		`- bool from_ip4_addr(ip4_addr* src, std::string& ip, int& port)`
	`17`	`+ inline bool from_ip4_addr(ip4_addr* src, std::string& ip, int& port)`
`18`	`18`	`{`
`19`	`19`	`char dest[16];`
`20`	`20`	`if(uv_ip4_name(src, dest, 16) == 0)`
`@@ -26,7 +26,7 @@ namespace native`
`26`	`26`	`return false;`
`27`	`27`	`}`
`28`	`28`
`29`		`- bool from_ip6_addr(ip6_addr* src, std::string& ip, int& port)`
	`29`	`+ inline bool from_ip6_addr(ip6_addr* src, std::string& ip, int& port)`
`30`	`30`	`{`
`31`	`31`	`char dest[46];`
`32`	`32`	`if(uv_ip6_name(src, dest, 46) == 0)`