watcher-c: remove pipe-based implementation because it is unused, for now

Author: Will

watcher-c/include/wtr/watcher-c.h

@@ -62,15 +62,6 @@ void* wtr_watcher_open(char const* const path, wtr_watcher_callback callback, vo
 
 bool wtr_watcher_close(void* watcher);
 
-/*  The user, or the language we're working with,
-    might not prefer a callback-style API.
-    We provide a pipe-based API for these cases.
-    Instead of forwarding events to a callback,
-    we write json-serialized events to a pipe. */
-void* wtr_watcher_open_pipe(char const* const path, int* read_fd, int* write_fd);
-
-bool wtr_watcher_close_pipe(void* watcher, int read_fd, int write_fd);
-
 #ifdef __cplusplus
 }
 #endif

watcher-c/src/test-watcher-c.c

@@ -74,38 +74,19 @@ void do_poll_read_loop(int read_fd)
 int main(int argc, char** argv)
 {
   char path[4096];
-  char op[32];
   memset(path, 0, sizeof(path));
-  memset(op, 0, sizeof(op));
   bool badargs = argc != 2 && argc != 3;
   bool ishelp = ! badargs && strcmp(argv[1], "-h") == 0;
   if (badargs || ishelp) {
-    fprintf(stderr, "Usage: %s <op> [path]\n", argv[0]);
-    fprintf(stderr, "  op: pipe, cb-with-ctx\n");
+    fprintf(stderr, "Usage: %s [path]\n", argv[0]);
     fprintf(stderr, "  path: path to watch\n");
     return 1;
   }
-  if (argc >= 2) strncpy(op, argv[1], sizeof(op) - 1);
   if (argc == 3) strncpy(path, argv[2], sizeof(path) - 1);
-  if (strcmp(op, "cb-with-ctx") == 0) {
-    int count = 0;
-    void* watcher = wtr_watcher_open(path, callback, &count);
-    if (! watcher) return 1;
-    getchar();
-    if (! wtr_watcher_close(watcher)) return 1;
-    return 0;
-  } else if (strcmp(op, "pipe") == 0) {
-    int read_fd = -1;
-    int write_fd = -1;
-    void* watcher = wtr_watcher_open_pipe(path, &read_fd, &write_fd);
-    if (! watcher) return 1;
-    if (read_fd < 0) return 1;
-    if (write_fd < 0) return 1;
-    do_poll_read_loop(read_fd);
-    if (! wtr_watcher_close_pipe(watcher, read_fd, write_fd)) return 1;
-    return 0;
-  } else {
-    fprintf(stderr, "Unknown op: %s\n", op);
-    return 1;
-  }
+  int count = 0;
+  void* watcher = wtr_watcher_open(path, callback, &count);
+  if (! watcher) return 1;
+  getchar();
+  if (! wtr_watcher_close(watcher)) return 1;
+  return 0;
 }

watcher-c/src/watcher-c.cpp

@@ -7,11 +7,6 @@
 #define PATH_BUF_LEN 4096
 #include <windows.h>
 #include <stringapiset.h>
-#else
-// We support a pipe-based API for non-Windows platforms.
-#include <unistd.h>
-#include <fcntl.h>
-#include <string>
 #endif
 
 extern "C" {
@@ -79,57 +74,4 @@ bool wtr_watcher_close(void* watcher)
   return true;
 }
 
-#ifdef _WIN32
-void* wtr_watcher_open_pipe(char const* const path, int* read_fd, int* write_fd)
-{
-  return NULL;
-}
-
-bool wtr_watcher_close_pipe(void* watcher, int read_fd, int write_fd)
-{
-  return false;
-}
-#else
-void* wtr_watcher_open_pipe(char const* const path, int* read_fd, int* write_fd)
-{
-  if (! path) { fprintf(stderr, "Path is null.\n"); return NULL; }
-  if (! read_fd) { fprintf(stderr, "Read fd is null.\n"); return NULL; }
-  if (! write_fd) { fprintf(stderr, "Write fd is null.\n"); return NULL; }
-  if (*read_fd > 0) { fprintf(stderr, "Read fd is already open.\n"); return NULL; }
-  if (*write_fd > 0) { fprintf(stderr, "Write fd is already open.\n"); return NULL; }
-  int pipe_fds[2];
-  memset(pipe_fds, 0, sizeof(pipe_fds));
-  if (pipe(pipe_fds) == -1) { perror("pipe"); return NULL; }
-  if (pipe_fds[0] <= 0) { fprintf(stderr, "Read fd is invalid.\n"); return NULL; }
-  if (pipe_fds[1] <= 0) { fprintf(stderr, "Write fd is invalid.\n"); return NULL; }
-  fcntl(pipe_fds[0], F_SETFL, O_NONBLOCK);
-  fcntl(pipe_fds[1], F_SETFL, O_NONBLOCK);
-  *read_fd = pipe_fds[0];
-  *write_fd = pipe_fds[1];
-  auto json_serialize_event_to_pipe = [pipe_fds](wtr::watcher::event event) {
-    auto json = wtr::to<std::string>(event) + "\n";
-    write(pipe_fds[1], json.c_str(), json.size());
-  };
-  auto w = new wtr::watcher::watch(path, json_serialize_event_to_pipe);
-  if (! w) {
-    perror("new wtr::watcher::watch");
-    close(pipe_fds[0]);
-    close(pipe_fds[1]);
-    return NULL;
-  }
-  *read_fd = pipe_fds[0];
-  return (void*)w;
-}
-
-bool wtr_watcher_close_pipe(void* watcher, int read_fd, int write_fd)
-{
-  bool ok = false;
-  ok |= watcher && ((wtr::watcher::watch*)watcher)->close();
-  ok |= write_fd > 0 && close(write_fd);
-  ok |= read_fd > 0 && close(read_fd);
-  if (watcher) delete (wtr::watcher::watch*)watcher;
-  return ok;
-}
-#endif
-
 }  // extern "C"