node/src/node_file.h

// Copyright 2009 Ryan Dahl <ry@tinyclouds.org>
#ifndef SRC_FILE_H_
#define SRC_FILE_H_

#include <node.h>
#include <node_events.h>
#include <v8.h>

namespace node {

/* Are you missing your favorite POSIX function? It might be very easy to
 * add a wrapper. Take a look in deps/libeio/eio.h at the list of wrapper
 * functions.  If your function is in that list, just follow the lead of
 * EIOPromise::Open. You'll need to add two functions, one static function
 * in EIOPromise, and one static function which interprets the javascript
 * args in src/file.cc. Then just a reference to that function in
 * File::Initialize() and you should be good to go.
 * Don't forget to add a test to test/mjsunit.
 */

#define NODE_V8_METHOD_DECLARE(name) \
  static v8::Handle<v8::Value> name(const v8::Arguments& args)

class File {
 public:
  static void Initialize(v8::Handle<v8::Object> target);
};

class EIOPromise : public Promise {
 public:
  static EIOPromise* Create();
  static v8::Persistent<v8::FunctionTemplate> constructor_template;
  static v8::Handle<v8::Value> New(const v8::Arguments& args);

  static v8::Handle<v8::Object> Open(const char *path, int flags, mode_t mode) {
    EIOPromise *p = Create();
    p->req_ = eio_open(path, flags, mode, EIO_PRI_DEFAULT, After, p);
    return p->handle_;
  }

  static v8::Handle<v8::Object> Close(int fd) {
    EIOPromise *p = Create();
    p->req_ = eio_close(fd, EIO_PRI_DEFAULT, After, p);
    return p->handle_;
  }

  static v8::Handle<v8::Object> Write(int fd,
                                      void *buf,
                                      size_t count,
                                      off_t offset) {
    EIOPromise *p = Create();
    p->req_ = eio_write(fd, buf, count, offset, EIO_PRI_DEFAULT, After, p);
    return p->handle_;
  }

  static v8::Handle<v8::Object> Read(int fd,
                                     size_t count,
                                     off_t offset,
                                     enum encoding encoding) {
    EIOPromise *p = Create();
    p->encoding_ = encoding;
    // NOTE: 2nd param: NULL pointer tells eio to allocate it itself
    p->req_ = eio_read(fd, NULL, count, offset, EIO_PRI_DEFAULT, After, p);
    return p->handle_;
  }

  static v8::Handle<v8::Object> Stat(const char *path) {
    EIOPromise *p = Create();
    p->req_ = eio_stat(path, EIO_PRI_DEFAULT, After, p);
    return p->handle_;
  }

  static v8::Handle<v8::Object> Rename(const char *path, const char *new_path) {
    EIOPromise *p = Create();
    p->req_ = eio_rename(path, new_path, EIO_PRI_DEFAULT, After, p);
    return p->handle_;
  }

  static v8::Handle<v8::Object> Unlink(const char *path) {
    EIOPromise *p = Create();
    p->req_ = eio_unlink(path, EIO_PRI_DEFAULT, After, p);
    return p->handle_;
  }

  static v8::Handle<v8::Object> RMDir(const char *path) {
    EIOPromise *p = Create();
    p->req_ = eio_rmdir(path, EIO_PRI_DEFAULT, After, p);
    return p->handle_;
  }

  static v8::Handle<v8::Object> MKDir(const char *path, mode_t mode) {
    EIOPromise *p = Create();
    p->req_ = eio_mkdir(path, mode, EIO_PRI_DEFAULT, After, p);
    return p->handle_;
  }

  static v8::Handle<v8::Object> ReadDir(const char *path) {
    EIOPromise *p = Create();
    // By using EIO_READDIR_DENTS (or other flags), more complex results can
    // be had from eio_readdir. Doesn't seem that we need that though.
    p->req_ = eio_readdir(path, 0, EIO_PRI_DEFAULT, After, p);
    return p->handle_;
  }

  static v8::Handle<v8::Object> SendFile(int out_fd, int in_fd, off_t in_offset, size_t length) {
    EIOPromise *p = Create();
    p->req_ = eio_sendfile(out_fd, in_fd, in_offset, length, EIO_PRI_DEFAULT, After, p);
    return p->handle_;
  }

 protected:

  void Attach();
  void Detach();

  EIOPromise() : Promise() { }

 private:

  static int After(eio_req *req);

  eio_req *req_;
  enum encoding encoding_;
};

}  // namespace node
#endif  // SRC_FILE_H_