static NAN_METHOD(New) {
NanScope();
if (args.Length() != 1) {
EIGENJS_THROW_ERROR_INVALID_ARGUMENT()
NanReturnUndefined();
}
if (!args.IsConstructCall()) {
v8::Local<v8::Value> argv[] ={ args[0] };
NanReturnValue(
base_type::new_instance(
args
, sizeof(argv) / sizeof(v8::Local<v8::Value>)
, argv
)
);
}
if (Matrix::is_matrix(args[0])) {
const Matrix* const& rhs_obj =
node::ObjectWrap::Unwrap<Matrix>(args[0]->ToObject());
const typename Matrix::value_type& rhs_matrix = **rhs_obj;
if (rhs_matrix.rows() != rhs_matrix.cols()) {
NanThrowError("PartialPivLU is only for square "
"(and moreover invertible) matrices");
NanReturnUndefined();
}
PartialPivLU* obj = new PartialPivLU(rhs_matrix);
obj->Wrap(args.This());
NanReturnValue(args.This());
} else if (MatrixBlock::is_matrixblock(args[0])) {
const MatrixBlock* const& rhs_obj =
node::ObjectWrap::Unwrap<MatrixBlock>(args[0]->ToObject());
const typename MatrixBlock::value_type& rhs_matrixblock = **rhs_obj;
if (rhs_matrixblock.rows() != rhs_matrixblock.cols()) {
NanThrowError("PartialPivLU is only for square "
"(and moreover invertible) matrices");
NanReturnUndefined();
}
PartialPivLU* obj = new PartialPivLU(rhs_matrixblock);
obj->Wrap(args.This());
NanReturnValue(args.This());
}
EIGENJS_THROW_ERROR_INVALID_ARGUMENT()
NanReturnUndefined();
}
static NAN_METHOD(GetPortCount)
{
NanScope();
NodeMidiOutput* output = node::ObjectWrap::Unwrap<NodeMidiOutput>(args.This());
v8::Local<v8::Integer> result = NanNew<v8::Uint32>(output->out->getPortCount());
NanReturnValue(result);
}
static inline NAN_METHOD(register_datasource)
{
NanScope();
if (args.Length() != 1 || !args[0]->IsString())
{
NanThrowTypeError("first argument must be a path to a mapnik input plugin (.input)");
NanReturnUndefined();
}
std::vector<std::string> names_before = mapnik::datasource_cache::instance().plugin_names();
std::string path = TOSTR(args[0]);
mapnik::datasource_cache::instance().register_datasource(path);
std::vector<std::string> names_after = mapnik::datasource_cache::instance().plugin_names();
if (names_after.size() > names_before.size())
NanReturnValue(NanTrue());
NanReturnValue(NanFalse());
}
static inline NAN_METHOD(register_fonts)
{
NanScope();
try
{
if (args.Length() == 0 || !args[0]->IsString())
{
NanThrowTypeError("first argument must be a path to a directory of fonts");
NanReturnUndefined();
}
bool found = false;
std::vector<std::string> const names_before = mapnik::freetype_engine::face_names();
// option hash
if (args.Length() == 2){
if (!args[1]->IsObject())
{
NanThrowTypeError("second argument is optional, but if provided must be an object, eg. { recurse:Boolean }");
NanReturnUndefined();
}
Local<Object> options = args[1].As<Object>();
if (options->Has(NanNew("recurse")))
{
Local<Value> recurse_opt = options->Get(NanNew("recurse"));
if (!recurse_opt->IsBoolean())
{
NanThrowTypeError("'recurse' must be a Boolean");
NanReturnUndefined();
}
bool recurse = recurse_opt->BooleanValue();
std::string path = TOSTR(args[0]);
found = mapnik::freetype_engine::register_fonts(path,recurse);
}
}
else
{
std::string path = TOSTR(args[0]);
found = mapnik::freetype_engine::register_fonts(path);
}
std::vector<std::string> const& names_after = mapnik::freetype_engine::face_names();
if (names_after.size() == names_before.size())
found = false;
NanReturnValue(NanNew(found));
}
catch (std::exception const& ex)
{
NanThrowError(ex.what());
NanReturnUndefined();
}
}
static inline NAN_METHOD(available_input_plugins)
{
NanScope();
std::vector<std::string> names = mapnik::datasource_cache::instance().plugin_names();
Local<Array> a = NanNew<Array>(names.size());
for (unsigned i = 0; i < names.size(); ++i)
{
a->Set(i, NanNew(names[i].c_str()));
}
NanReturnValue(a);
}
static inline NAN_METHOD(available_font_faces)
{
NanScope();
std::vector<std::string> const& names = mapnik::freetype_engine::face_names();
Local<Array> a = NanNew<Array>(names.size());
for (unsigned i = 0; i < names.size(); ++i)
{
a->Set(i, NanNew(names[i].c_str()));
}
NanReturnValue(a);
}
static NAN_METHOD(GetPortName)
{
NanScope();
NodeMidiOutput* output = node::ObjectWrap::Unwrap<NodeMidiOutput>(args.This());
if (args.Length() == 0 || !args[0]->IsUint32()) {
return NanThrowTypeError("First argument must be an integer");
}
unsigned int portNumber = args[0]->Uint32Value();
v8::Local<v8::String> result = NanNew<v8::String>(output->out->getPortName(portNumber).c_str());
NanReturnValue(result);
}
static inline NAN_METHOD(available_font_files)
{
NanScope();
std::map<std::string,std::pair<int,std::string> > const& mapping = mapnik::freetype_engine::get_mapping();
Local<Object> obj = NanNew<Object>();
std::map<std::string,std::pair<int,std::string> >::const_iterator itr;
for (itr = mapping.begin();itr!=mapping.end();++itr)
{
obj->Set(NanNew(itr->first.c_str()), NanNew(itr->second.second.c_str()));
}
NanReturnValue(obj);
}
static NAN_METHOD(New)
{
NanScope();
if (!args.IsConstructCall()) {
return NanThrowTypeError("Use the new operator to create instances of this object.");
}
NodeMidiOutput* output = new NodeMidiOutput();
output->Wrap(args.This());
NanReturnValue(args.This());
}
static NAN_METHOD(New) {
NanScope();
if (args.IsConstructCall()) {
double value = args[0]->IsUndefined() ? 0 : args[0]->NumberValue();
MyObject *obj = new MyObject(value);
obj->Wrap(args.This());
NanReturnThis();
} else {
const int argc = 1;
v8::Local<v8::Value> argv[argc] = {args[0]};
v8::Local<v8::Function> cons = NanNew(constructor);
NanReturnValue(cons->NewInstance(argc, argv));
}
}
static NAN_METHOD(New)
{
NanScope();
if (!args.IsConstructCall()) {
return NanThrowTypeError("Use the new operator to create instances of this object.");
}
NodeMidiInput* input = new NodeMidiInput();
input->message_async.data = input;
uv_async_init(uv_default_loop(), &input->message_async, NodeMidiInput::EmitMessage);
input->Wrap(args.This());
NanReturnValue(args.This());
}
static NAN_METHOD(Do) {
NanScope();
EscapeHTML* obj = Unwrap<EscapeHTML>(args.Holder());
hoedown_buffer* ob = obj->ob;
NanUtf8String input (args[0]);
if (ob->asize > obj->maxSize) {
free(ob->data);
ob->data = (uint8_t*) malloc(obj->minSize);
ob->asize = obj->minSize;
}
ob->size = 0;
hoedown_escape_html(ob, (uint8_t*)*input, input.length(), obj->secure);
NanReturnValue(NanNew<String>((char*)ob->data, ob->size));
}
static NAN_METHOD(GetHandle) {
NanScope();
MyObject* obj = node::ObjectWrap::Unwrap<MyObject>(args.This());
NanReturnValue(NanObjectWrapHandle(obj));
}
static NAN_METHOD(New) {
const int& args_length = args.Length();
NanScope();
if (args_length == 1) {
if (!args.IsConstructCall()) {
v8::Local<v8::Value> argv[] = { args[0] };
NanReturnValue(
base_type::new_instance(
args
, sizeof(argv) / sizeof(v8::Local<v8::Value>)
, argv
)
);
}
if (args[0]->IsNumber()) {
typename value_type::Index size = args[0]->Int32Value();
if (size >= 0) {
Vector* obj = new Vector(size);
obj->Wrap(args.This());
NanReturnValue(args.This());
}
} else if (args[0]->IsArray()) {
const v8::Local<v8::Array>& array = args[0].As<v8::Array>();
uint32_t len = array->Length();
Vector* obj = new Vector(len);
Vector::value_type& vector = **obj;
for (uint32_t i = 0; i < len; ++i) {
const v8::Local<v8::Value>& elem = array->Get(i);
vector(i, 0) = elem->NumberValue();
}
obj->Wrap(args.This());
NanReturnValue(args.This());
} else if (Matrix::is_matrix(args[0])) {
const Matrix* const& rhs_obj =
node::ObjectWrap::Unwrap<Matrix>(args[0]->ToObject());
const typename Matrix::value_type& rhs_matrix = **rhs_obj;
const typename Matrix::value_type::Index& rows = rhs_matrix.rows();
const typename Matrix::value_type::Index& cols = rhs_matrix.cols();
if (rows != 1 && cols != 1) {
EIGENJS_THROW_ERROR_THE_MATRIX_SIZE_MUST_BE_1XN_OR_MX1()
NanReturnUndefined();
}
Vector* obj = new Vector(0);
if (rows > cols) {
**obj = rhs_matrix;
} else {
**obj = rhs_matrix.transpose();
}
obj->Wrap(args.This());
NanReturnValue(args.This());
} else if (Vector::is_vector(args[0])) {
const Vector* const& rhs_obj =
node::ObjectWrap::Unwrap<Vector>(args[0]->ToObject());
const typename Vector::value_type& rhs_vector = **rhs_obj;
Vector* obj = new Vector(0);
**obj = rhs_vector;
obj->Wrap(args.This());
NanReturnValue(args.This());
} else if (RowVector::is_rowvector(args[0])) {
const RowVector* const& rhs_obj =
node::ObjectWrap::Unwrap<RowVector>(args[0]->ToObject());
const typename RowVector::value_type& rhs_rowvector = **rhs_obj;
Vector* obj = new Vector(0);
**obj = rhs_rowvector.transpose();
obj->Wrap(args.This());
NanReturnValue(args.This());
} else if (MatrixBlock::is_matrixblock(args[0])) {
const MatrixBlock* const& rhs_obj =
node::ObjectWrap::Unwrap<MatrixBlock>(args[0]->ToObject());
const typename MatrixBlock::value_type& rhs_matrixblock = **rhs_obj;
const typename MatrixBlock::value_type::Index& rows =
rhs_matrixblock.rows();
const typename MatrixBlock::value_type::Index& cols =
rhs_matrixblock.cols();
if (rows != 1 && cols != 1) {
EIGENJS_THROW_ERROR_THE_MATRIX_SIZE_MUST_BE_1XN_OR_MX1()
NanReturnUndefined();
}
Vector* obj = new Vector(0);
if (rows > cols) {
**obj = rhs_matrixblock;
} else {
**obj = rhs_matrixblock.transpose();
}
obj->Wrap(args.This());
NanReturnValue(args.This());
} else if (VectorBlock::is_vectorblock(args[0])) {
const VectorBlock* const& rhs_obj =
node::ObjectWrap::Unwrap<VectorBlock>(args[0]->ToObject());
const typename VectorBlock::value_type& rhs_vectorblock = **rhs_obj;
Vector* obj = new Vector(0);
**obj = rhs_vectorblock;
obj->Wrap(args.This());
NanReturnValue(args.This());
} else if (RowVectorBlock::is_rowvectorblock(args[0])) {
const RowVectorBlock* const& rhs_obj =
node::ObjectWrap::Unwrap<RowVectorBlock>(args[0]->ToObject());
const typename RowVectorBlock::value_type& rhs_rowvectorblock =
**rhs_obj;
Vector* obj = new Vector(0);
**obj = rhs_rowvectorblock.transpose();
obj->Wrap(args.This());
NanReturnValue(args.This());
}
} else if (args_length == 2) {
if (args[0]->IsNumber() && args[1]->IsNumber()) {
const typename value_type::Index& rows = args[0]->Int32Value();
const typename value_type::Index& cols = args[1]->Int32Value();
(void)cols;
if (rows >= 0 && cols >= 0) {
if (args.IsConstructCall()) {
Vector* obj = new Vector(rows);
obj->Wrap(args.This());
NanReturnValue(args.This());
} else {
v8::Local<v8::Value> argv[] = { args[0], args[1] };
NanReturnValue(
base_type::new_instance(
args
, sizeof(argv) / sizeof(v8::Local<v8::Value>)
, argv
)
);
}
}
}
}
EIGENJS_THROW_ERROR_INVALID_ARGUMENT()
NanReturnUndefined();
}