root/lang/cplusplus/fcgi-v8/trunk/src/libmemcached.cc @ 19067

#include <libmemcached/memcached.h>
#include <v8.h>
#include <cstring>

using namespace v8;

inline memcached_st * _memc(const v8::Arguments& args) {
    v8::Local<v8::Value> field = args.This()->GetInternalField(0);
    return reinterpret_cast<memcached_st *>(v8::Handle<v8::External>::Cast(field)->Value());
}

v8::Handle<v8::Value> _new(const v8::Arguments& args) {
    v8::HandleScope handle_scope;

    memcached_st *memc = memcached_create(NULL);;
    args.This()->SetInternalField(0, v8::External::New((void*)memc));
    return args.This();
}

v8::Handle<v8::Value> _free(const v8::Arguments& args) {
    v8::HandleScope handle_scope;
    memcached_st *memc = _memc(args);
    memcached_free(memc);
}

v8::Handle<v8::Value> _server_add(const v8::Arguments& args) {
    if (args.Length() != 2) {
        return v8::ThrowException(v8::String::New("Exception: missing args: server_add(host, port)"));
    }

    HandleScope handle_scope;
    memcached_return rc;
    memcached_st *memc = _memc(args);

    String::AsciiValue host(args[0]);

    rc = memcached_server_add(memc, *host, args[1]->Int32Value());
    if (rc != MEMCACHED_SUCCESS) {
        return ThrowException(String::New(memcached_strerror(memc, rc)));
    }
    return Undefined();
}

v8::Handle<v8::Value> _get(const v8::Arguments& args) {
    if (args.Length() != 1) {
        return v8::ThrowException(v8::String::New("Exception: missing args: get(key)"));
    }

    HandleScope handle_scope;
    memcached_return rc;
    memcached_st *memc = _memc(args);
    uint32_t flags;
    size_t value_length;

    String::AsciiValue key(args[0]);
    char * value = memcached_get(memc, *key, strlen(*key),
                            &value_length, &flags, &rc);
    if (rc == MEMCACHED_NOTFOUND) {
        return Undefined();
    } else if (rc == MEMCACHED_SUCCESS) {
        Handle<Object> res = Object::New();
        res->Set(String::New("value"), String::New(value, value_length));
        res->Set(String::New("flags"), Integer::New(flags));
        free(value);
        return res;
    } else {
        return ThrowException(String::New(memcached_strerror(memc, rc)));
    }
}

v8::Handle<v8::Value> _set(const v8::Arguments& args) {
    if (args.Length() != 4) {
        return v8::ThrowException(v8::String::New("Exception: missing args: set(key, val, expiration, flags)"));
    }

    HandleScope handle_scope;
    memcached_st *memc = _memc(args);

    String::AsciiValue key(args[0]);
    String::AsciiValue val(args[1]);
    time_t expiration = args[2]->Uint32Value();
    uint32_t flags    = args[3]->Uint32Value();

    memcached_return rc = memcached_set(
        memc,
        *key, args[0]->ToString()->Length(),
        *val, args[1]->ToString()->Length(),
        expiration,
        flags
    );
    if (rc != MEMCACHED_SUCCESS) {
        return ThrowException(String::New(memcached_strerror(memc, rc)));
    } else {
        return Undefined();
    }
}

void setup_memcached(v8::Handle<v8::ObjectTemplate> target) {
    HandleScope scope;

    Handle<FunctionTemplate> ft = FunctionTemplate::New(_new);
    Handle<ObjectTemplate>   ot = ft->InstanceTemplate();

    ot->Set(String::New("server_add"), FunctionTemplate::New(_server_add));
    ot->Set(String::New("get"), FunctionTemplate::New(_get));
    ot->Set(String::New("set"), FunctionTemplate::New(_set));
    ot->Set(String::New("free"), FunctionTemplate::New(_free));

    ot->SetInternalFieldCount(1);
    target->Set(
        String::New("Memcached"),
        ft,
        PropertyAttribute(ReadOnly | DontDelete)
    );
}