nodejs与C++交互(二)

http://blog.csdn.net/youyudehexie/article/details/11613603

module.hpp

#pragma once

#include <node.h>

class MyObject : public node::ObjectWrap {
public:
	static v8::Persistent<v8::FunctionTemplate> constructor;
	static void Init(v8::Handle<v8::Object> target);

protected:
	MyObject(int val);
	static v8::Handle<v8::Value> New(const v8::Arguments& args);
	static v8::Handle<v8::Value> Value(const v8::Arguments& args);
	static v8::Handle<v8::Value> SetValue(const v8::Arguments& args);
	int value_;
};

module.cpp

#include <node.h>



#include <cstdlib>
#include <ctime>
using namespace v8;

/* 随机数模块 */
// 返回js格式的0或1
Handle<Value> Random(const Arguments& args) {
	HandleScope scope;
	return scope.Close(Integer::New(rand()%2));
}


/* 函数参数传入 */
Handle<Value> Fibonacci(const Arguments& args) {
	HandleScope scope;

	if (args.Length() < 1) {
		return ThrowException(Exception::TypeError(String::New("First argument must be a number")));
	}

	Local<Integer> integer = args[0]->ToInteger();
	int32_t seq = integer->Value();

	if (seq < 0) {
		return ThrowException(Exception::TypeError(String::New(
			"Fibonacci sequence number must be positive")));
	}

	int32_t current = 1;
	for (int32_t previous = -1, next = 0, i = 0; i <= seq; i++) {
		next = previous + current;
		previous = current;
		current = next;
	}

	return scope.Close(Integer::New(current));
}


/* 回调函数处理 */
Handle<Value> Callback(const Arguments& args) {
	HandleScope scope;

	if (!args[1]->IsFunction()) {
		return ThrowException(Exception::TypeError(
			String::New("Second argument must be a callback function")));
	}

	// 强制转换成函数
	Local<Function> callback = Local<Function>::Cast(args[1]);
	bool error = args[0]->ToBoolean()->Value();
//	bool error = args[0]->BooleanValue();

	if (error) {
		Local<Value> err = Exception::Error(String::New("Something went wrong!"));
		// 为返回的错误，创建更多的属性
		err->ToObject()->Set(NODE_PSYMBOL("errno"), Integer::New(23));

		// 定义回调函数的参数个数和参数数组
		const unsigned argc = 1;
		Local<Value> argv[argc] = {err};
		callback->Call(Context::GetCurrent()->Global(), argc, argv);
	} else {
		const unsigned argc = 2;
		Local<Value> argv[argc] = {
			Local<Value>::New(Null()),
			Local<Value>::New(Integer::New(42))
		};
		callback->Call(Context::GetCurrent()->Global(), argc, argv);
	}
	// 异步函数，可以立即返回
	return scope.Close(Undefined());
}


/* 对象处理 */
#include "module.hpp"

Persistent<FunctionTemplate> MyObject::constructor;
void MyObject::Init(Handle<Object> target) {
	HandleScope scope;
	Local<FunctionTemplate> tp1 = FunctionTemplate::New(New);
	Local<String> name = String::NewSymbol("MyObject");
	constructor = Persistent<FunctionTemplate>::New(tp1);

	// 设置对象
	constructor->InstanceTemplate()->SetInternalFieldCount(1);
	constructor->SetClassName(name);

	// 添加属性value 和对应的数值Value
	NODE_SET_PROTOTYPE_METHOD(constructor, "value", Value);
	NODE_SET_PROTOTYPE_METHOD(constructor, "setValue", SetValue);
	target->Set(name, constructor->GetFunction());
}

MyObject::MyObject(int val)
	: ObjectWrap(), value_(val) {

}

Handle<Value> MyObject::New(const Arguments& args) {
	HandleScope scope;
	if (!args.IsConstructCall()) {
		return ThrowException(Exception::TypeError(
			String::New("Use the new operator to create instances of this object.")));
	}
	if (args.Length() < 1) {
		return ThrowException(Exception::TypeError(
			String::New("First argument must be a number")));
	}

	MyObject* obj = new MyObject(args[0]->ToInteger()->Value());
	obj->Wrap(args.This());
	return args.This();
}

Handle<Value> MyObject::Value(const Arguments& args) {
	HandleScope scope;
	MyObject* obj = ObjectWrap::Unwrap<MyObject>(args.This());
	return scope.Close(Integer::New(obj->value_));
}

Handle<Value> MyObject::SetValue(const Arguments& args) {
	HandleScope scope;
	MyObject* obj = ObjectWrap::Unwrap<MyObject>(args.This());
	if (args[0]->IsNumber()) {
		obj->value_ = args[0]->ToInteger()->Value();
	} else if (args[0]->IsObject()) {
		// 获取js对象的属性
		Local<Object> obj2 = args[0]->ToObject();
		obj->value_ = obj2->Get(String::New("value"))->ToInteger()->Value();
		// 调用js对象的方法
		if (obj2->Get(String::New("func"))->IsFunction()){
			Local<Function> func = Local<Function>::Cast(obj2->Get(String::New("func")));
			const unsigned argc = 2;
			Local<v8::Value> argv[argc] = {
				Local<v8::Value>::New(Null()),
				Local<v8::Value>::New(String::New("member function run success"))
			};
			func->Call(args[0]->ToObject(), argc, argv); // 调用js对象的成员函数
		}
	}
	
	return scope.Close(Integer::New(obj->value_));
}

void RegisterModule(v8::Handle<v8::Object> target) {
	srand(time(NULL));

	target->Set(String::NewSymbol("random"), FunctionTemplate::New(Random)->GetFunction());
	target->Set(String::NewSymbol("fibonacci"), FunctionTemplate::New(Fibonacci)->GetFunction());
	target->Set(String::NewSymbol("callback"), FunctionTemplate::New(Callback)->GetFunction());
	MyObject::Init(target);
}

NODE_MODULE(module, RegisterModule)

run.js

var module = require('./build/Release/module');

console.warn(module.random());

console.warn(module.fibonacci(9));

module.callback(false, function(err, result) {
	console.warn(result);
});

var obj = new module.MyObject(45);
console.warn(obj);
console.warn(obj.value());

console.warn(obj.setValue(48));

var obj2 = {};
obj2.value = 50;
obj2.func = function(err, result) {
	console.log(result);
<span style="white-space:pre">	</span>console.log(this.value);
}
console.warn(obj.setValue(obj2));

binding.gyp

{
	"targets": [
		{
			"target_name": "module",
			"sources": ["module.cpp"]
		}
	]
}