Fix windows-x64 platform compile issues

Author: zieckey

benchmark/ioevent/evpp/evpp_ioevent_bench.cc

@@ -20,7 +20,7 @@
 
 using namespace evpp;
 
-std::vector<int> g_pipes;
+std::vector<evpp_socket_t> g_pipes;
 int numPipes;
 int numActive;
 int numWrites;
@@ -30,7 +30,7 @@ std::vector<FdChannel*> g_channels;
 int g_reads, g_writes, g_fired;
 int g_total_reads = 0;
 
-void readCallback(int fd, int idx) {
+void readCallback(evpp_socket_t fd, int idx) {
     g_total_reads++;
     char ch = 0;
     g_reads += static_cast<int>(::recv(fd, &ch, sizeof(ch), 0));

benchmark/ioevent/fd_channel_vs_pipe_event_watcher/fd_channel_vs_pipe_event_watcher.cc

@@ -18,7 +18,7 @@
 
 using namespace evpp;
 
-std::vector<int> g_pipes;
+std::vector<evpp_socket_t> g_pipes;
 int numPipes;
 int numActive;
 int numWrites;
@@ -28,7 +28,7 @@ std::vector<std::shared_ptr<PipeEventWatcher>> g_pipe_event_watchers;
 
 int g_reads, g_writes, g_fired;
 
-void ReadCallbackOfFdChannel(int fd, int idx) {
+void ReadCallbackOfFdChannel(evpp_socket_t fd, int idx) {
     char ch = 'm';
 
     g_reads += static_cast<int>(::recv(fd, &ch, sizeof(ch), 0));
@@ -88,7 +88,7 @@ std::pair<int, int> FdChannelRunOnce() {
 std::pair<int, int> PipeEventWatcherRunOnce() {
     Timestamp beforeInit(Timestamp::Now());
     for (int i = 0; i < numActive; ++i) {
-        int fd = g_pipe_event_watchers[i]->wfd();
+        evpp_socket_t fd = g_pipe_event_watchers[i]->wfd();
         ::send(fd, "m", 1, 0);
     }
 

evpp/buffer.cc

@@ -19,7 +19,7 @@ const char Buffer::kCRLF[] = "\r\n";
 const size_t Buffer::kCheapPrependSize = 8;
 const size_t Buffer::kInitialSize  = 1024;
 
-ssize_t Buffer::ReadFromFD(int fd, int* savedErrno) {
+ssize_t Buffer::ReadFromFD(evpp_socket_t fd, int* savedErrno) {
     // saved an ioctl()/FIONREAD call to tell how much to read
     char extrabuf[65536];
     struct iovec vec[2];

evpp/buffer.h

@@ -235,7 +235,7 @@ class EVPP_EXPORT Buffer {
 
     // ReadFromFD reads data from a fd directly into buffer,
     // and return result of readv, errno is saved into saved_errno
-    ssize_t ReadFromFD(int fd, int* saved_errno);
+    ssize_t ReadFromFD(evpp_socket_t fd, int* saved_errno);
 
     // Next returns a slice containing the next n bytes from the buffer,
     // advancing the buffer as if the bytes had been returned by Read.

evpp/connector.h

@@ -13,7 +13,7 @@ class DNSResolver;
 class TCPClient;
 class EVPP_EXPORT Connector : public std::enable_shared_from_this<Connector> {
 public:
-    typedef std::function<void(int sockfd, const std::string& /*local addr*/)> NewConnectionCallback;
+    typedef std::function<void(evpp_socket_t sockfd, const std::string& /*local addr*/)> NewConnectionCallback;
     Connector(EventLoop* loop, TCPClient* client);
     ~Connector();
     void Start();
@@ -54,7 +54,7 @@ class EVPP_EXPORT Connector : public std::enable_shared_from_this<Connector> {
 
     Duration timeout_;
 
-    int fd_ = -1;
+    evpp_socket_t fd_ = -1;
 
     // A flag indicate whether the Connector owns this fd.
     // If the Connector owns this fd, the Connector has responsibility to close this fd.

evpp/event_watcher.cc

@@ -149,7 +149,7 @@ void PipeEventWatcher::DoClose() {
     }
 }
 
-void PipeEventWatcher::HandlerFn(int /*fd*/, short /*which*/, void* v) {
+void PipeEventWatcher::HandlerFn(evpp_socket_t /*fd*/, short /*which*/, void* v) {
     PipeEventWatcher* e = (PipeEventWatcher*)v;
 #ifdef H_BENCHMARK_TESTING
     // Every time we only read 1 byte for testing the IO event performance.
@@ -213,7 +213,7 @@ bool TimerEventWatcher::DoInit() {
     return true;
 }
 
-void TimerEventWatcher::HandlerFn(int /*fd*/, short /*which*/, void* v) {
+void TimerEventWatcher::HandlerFn(evpp_socket_t /*fd*/, short /*which*/, void* v) {
     TimerEventWatcher* h = (TimerEventWatcher*)v;
     h->handler_();
 }
@@ -226,14 +226,14 @@ bool TimerEventWatcher::AsyncWait() {
 //////////////////////////////////////////////////////////////////////////
 //////////////////////////////////////////////////////////////////////////
 //////////////////////////////////////////////////////////////////////////
-SignalEventWatcher::SignalEventWatcher(int signo, EventLoop* loop,
+SignalEventWatcher::SignalEventWatcher(signal_number_t signo, EventLoop* loop,
                                        const Handler& handler)
     : EventWatcher(loop->event_base(), handler)
     , signo_(signo) {
     assert(signo_);
 }
 
-SignalEventWatcher::SignalEventWatcher(int signo, EventLoop* loop,
+SignalEventWatcher::SignalEventWatcher(signal_number_t signo, EventLoop* loop,
                                        Handler&& h)
     : EventWatcher(loop->event_base(), std::move(h))
     , signo_(signo) {
@@ -246,7 +246,7 @@ bool SignalEventWatcher::DoInit() {
     return true;
 }
 
-void SignalEventWatcher::HandlerFn(int /*sn*/, short /*which*/, void* v) {
+void SignalEventWatcher::HandlerFn(signal_number_t /*sn*/, short /*which*/, void* v) {
     SignalEventWatcher* h = (SignalEventWatcher*)v;
     h->handler_();
 }

evpp/event_watcher.h

@@ -57,13 +57,13 @@ class EVPP_EXPORT PipeEventWatcher : public EventWatcher {
 
     bool AsyncWait();
     void Notify();
-    int wfd() const {        return pipe_[0];    }
+    evpp_socket_t wfd() const { return pipe_[0]; }
 private:
     virtual bool DoInit();
     virtual void DoClose();
-    static void HandlerFn(int fd, short which, void* v);
+    static void HandlerFn(evpp_socket_t fd, short which, void* v);
 
-    int pipe_[2]; // Write to pipe_[0] , Read from pipe_[1]
+    evpp_socket_t pipe_[2]; // Write to pipe_[0] , Read from pipe_[1]
 };
 
 class EVPP_EXPORT TimerEventWatcher : public EventWatcher {
@@ -77,20 +77,20 @@ class EVPP_EXPORT TimerEventWatcher : public EventWatcher {
 
 private:
     virtual bool DoInit();
-    static void HandlerFn(int fd, short which, void* v);
+    static void HandlerFn(evpp_socket_t fd, short which, void* v);
 private:
     Duration timeout_;
 };
 
 class EVPP_EXPORT SignalEventWatcher : public EventWatcher {
 public:
-    SignalEventWatcher(int signo, EventLoop* loop, const Handler& handler);
-    SignalEventWatcher(int signo, EventLoop* loop, Handler&& handler);
+    SignalEventWatcher(signal_number_t signo, EventLoop* loop, const Handler& handler);
+    SignalEventWatcher(signal_number_t signo, EventLoop* loop, Handler&& handler);
 
     bool AsyncWait();
 private:
     virtual bool DoInit();
-    static void HandlerFn(int sn, short which, void* v);
+    static void HandlerFn(signal_number_t sn, short which, void* v);
 
     int signo_;
 };

evpp/fd_channel.cc

@@ -10,7 +10,7 @@ namespace evpp {
 static_assert(FdChannel::kReadable == EV_READ, "");
 static_assert(FdChannel::kWritable == EV_WRITE, "");
 
-FdChannel::FdChannel(EventLoop* l, int f, bool r, bool w)
+FdChannel::FdChannel(EventLoop* l, evpp_socket_t f, bool r, bool w)
     : loop_(l), attached_(false), event_(nullptr), fd_(f) {
     DLOG_TRACE << "fd=" << fd_;
     assert(fd_ > 0);
@@ -147,12 +147,12 @@ std::string FdChannel::EventsToString() const {
     return s;
 }
 
-void FdChannel::HandleEvent(int sockfd, short which, void* v) {
+void FdChannel::HandleEvent(evpp_socket_t sockfd, short which, void* v) {
     FdChannel* c = (FdChannel*)v;
     c->HandleEvent(sockfd, which);
 }
 
-void FdChannel::HandleEvent(int sockfd, short which) {
+void FdChannel::HandleEvent(evpp_socket_t sockfd, short which) {
     assert(sockfd == fd_);
     DLOG_TRACE << "fd=" << sockfd << " " << EventsToString();
 

evpp/fd_channel.h

@@ -25,7 +25,7 @@ class EVPP_EXPORT FdChannel {
     typedef std::function<void()> ReadEventCallback;
 
 public:
-    FdChannel(EventLoop* loop, int fd,
+    FdChannel(EventLoop* loop, evpp_socket_t fd,
               bool watch_read_event, bool watch_write_event);
     ~FdChannel();
 
@@ -56,7 +56,7 @@ class EVPP_EXPORT FdChannel {
     void DisableAllEvent();
 
 public:
-    int fd() const {
+    evpp_socket_t fd() const {
         return fd_;
     }
     std::string EventsToString() const;
@@ -71,8 +71,8 @@ class EVPP_EXPORT FdChannel {
     }
 
 private:
-    void HandleEvent(int fd, short which);
-    static void HandleEvent(int fd, short which, void* v);
+    void HandleEvent(evpp_socket_t fd, short which);
+    static void HandleEvent(evpp_socket_t fd, short which, void* v);
 
     void Update();
     void DetachFromLoop();
@@ -86,7 +86,7 @@ class EVPP_EXPORT FdChannel {
     struct event* event_;
     int events_; // the bitwise OR of zero or more of the EventType flags
 
-    int fd_;
+    evpp_socket_t fd_;
 };
 
 }

evpp/libevent.cc

@@ -2,7 +2,7 @@
 #include "evpp/libevent.h"
 
 #ifdef H_LIBEVENT_VERSION_14
-struct event* event_new(struct event_base* base, int fd, short events,
+struct event* event_new(struct event_base* base, evpp_socket_t fd, short events,
                         void(*cb)(int, short, void*), void* arg) {
     struct event* ev;
     ev = (struct event*)malloc(sizeof(struct event));