| // Copyright 2010 Google Inc. |
| // |
| // Licensed under the Apache License, Version 2.0 (the "License"); you |
| // may not use this file except in compliance with the License. |
| // You may obtain a copy of the License at |
| // |
| // http://www.apache.org/licenses/LICENSE-2.0 |
| // |
| // Unless required by applicable law or agreed to in writing, software |
| // distributed under the License is distributed on an "AS IS" BASIS, |
| // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or |
| // implied. See the License for the specific language governing |
| // permissions and limitations under the License. |
| |
| #include "protobuf_v8.h" |
| |
| #include <map> |
| #include <string> |
| #include <iostream> |
| #include <sstream> |
| |
| #include <google/protobuf/dynamic_message.h> |
| #include <google/protobuf/descriptor.h> |
| #include <google/protobuf/descriptor.pb.h> |
| |
| #include "logging.h" |
| #include "util.h" |
| |
| #include "node_buffer.h" |
| #include "node_object_wrap.h" |
| |
| #include "node_util.h" |
| |
| //#define PROTOBUF_V8_DEBUG |
| #ifdef PROTOBUF_V8_DEBUG |
| |
| #define DBG(...) ALOGD(__VA_ARGS__) |
| |
| #else |
| |
| #define DBG(...) |
| |
| #endif |
| |
| using google::protobuf::Descriptor; |
| using google::protobuf::DescriptorPool; |
| using google::protobuf::DynamicMessageFactory; |
| using google::protobuf::FieldDescriptor; |
| using google::protobuf::FileDescriptorSet; |
| using google::protobuf::Message; |
| using google::protobuf::Reflection; |
| |
| //using ObjectWrap; |
| //using Buffer; |
| |
| using std::map; |
| using std::string; |
| |
| using v8::Array; |
| using v8::AccessorInfo; |
| using v8::Arguments; |
| using v8::Boolean; |
| using v8::Context; |
| using v8::External; |
| using v8::Function; |
| using v8::FunctionTemplate; |
| using v8::Integer; |
| using v8::Handle; |
| using v8::HandleScope; |
| using v8::InvocationCallback; |
| using v8::Local; |
| using v8::NamedPropertyGetter; |
| using v8::Number; |
| using v8::Object; |
| using v8::ObjectTemplate; |
| using v8::Persistent; |
| using v8::Script; |
| using v8::String; |
| using v8::Value; |
| using v8::V8; |
| |
| namespace protobuf_v8 { |
| |
| template <typename T> |
| static T* UnwrapThis(const Arguments& args) { |
| return ObjectWrap::Unwrap<T>(args.This()); |
| } |
| |
| template <typename T> |
| static T* UnwrapThis(const AccessorInfo& args) { |
| return ObjectWrap::Unwrap<T>(args.This()); |
| } |
| |
| Persistent<FunctionTemplate> SchemaTemplate; |
| Persistent<FunctionTemplate> TypeTemplate; |
| Persistent<FunctionTemplate> ParseTemplate; |
| Persistent<FunctionTemplate> SerializeTemplate; |
| |
| class Schema : public ObjectWrap { |
| public: |
| Schema(Handle<Object> self, const DescriptorPool* pool) |
| : pool_(pool) { |
| DBG("Schema::Schema E:"); |
| factory_.SetDelegateToGeneratedFactory(true); |
| self->SetInternalField(1, Array::New()); |
| Wrap(self); |
| DBG("Schema::Schema X:"); |
| } |
| |
| virtual ~Schema() { |
| DBG("~Schema::Schema E:"); |
| if (pool_ != DescriptorPool::generated_pool()) |
| delete pool_; |
| DBG("~Schema::Schema X:"); |
| } |
| |
| class Type : public ObjectWrap { |
| public: |
| Schema* schema_; |
| const Descriptor* descriptor_; |
| |
| Message* NewMessage() const { |
| DBG("Type::NewMessage() EX:"); |
| return schema_->NewMessage(descriptor_); |
| } |
| |
| Handle<Function> Constructor() const { |
| DBG("Type::Constrocutor() EX:"); |
| return handle_->GetInternalField(2).As<Function>(); |
| } |
| |
| Local<Object> NewObject(Handle<Value> properties) const { |
| DBG("Type::NewObjext(properties) EX:"); |
| return Constructor()->NewInstance(1, &properties); |
| } |
| |
| Type(Schema* schema, const Descriptor* descriptor, Handle<Object> self) |
| : schema_(schema), descriptor_(descriptor) { |
| DBG("Type::Type(schema, descriptor, self) E:"); |
| // Generate functions for bulk conversion between a JS object |
| // and an array in descriptor order: |
| // from = function(arr) { this.f0 = arr[0]; this.f1 = arr[1]; ... } |
| // to = function() { return [ this.f0, this.f1, ... ] } |
| // This is faster than repeatedly calling Get/Set on a v8::Object. |
| std::ostringstream from, to; |
| from << "(function(arr) { if(arr) {"; |
| to << "(function() { return [ "; |
| |
| for (int i = 0; i < descriptor->field_count(); i++) { |
| from << |
| "var x = arr[" << i << "]; " |
| "if(x !== undefined) this['" << |
| descriptor->field(i)->camelcase_name() << |
| "'] = x; "; |
| |
| if (i > 0) to << ", "; |
| to << "this['" << descriptor->field(i)->camelcase_name() << "']"; |
| DBG("field name=%s", descriptor->field(i)->name().c_str()); |
| } |
| |
| from << " }})"; |
| to << " ]; })"; |
| |
| // managed type->schema link |
| self->SetInternalField(1, schema_->handle_); |
| |
| Handle<Function> constructor = |
| Script::Compile(String::New(from.str().c_str()))->Run().As<Function>(); |
| constructor->SetHiddenValue(String::New("type"), self); |
| |
| Handle<Function> bind = |
| Script::Compile(String::New( |
| "(function(self) {" |
| " var f = this;" |
| " return function(arg) {" |
| " return f.call(self, arg);" |
| " };" |
| "})"))->Run().As<Function>(); |
| Handle<Value> arg = self; |
| constructor->Set(String::New("parse"), bind->Call(ParseTemplate->GetFunction(), 1, &arg)); |
| constructor->Set(String::New("serialize"), bind->Call(SerializeTemplate->GetFunction(), 1, &arg)); |
| self->SetInternalField(2, constructor); |
| self->SetInternalField(3, Script::Compile(String::New(to.str().c_str()))->Run()); |
| |
| Wrap(self); |
| DBG("Type::Type(schema, descriptor, self) X:"); |
| } |
| |
| #define GET(TYPE) \ |
| (index >= 0 ? \ |
| reflection->GetRepeated##TYPE(instance, field, index) : \ |
| reflection->Get##TYPE(instance, field)) |
| |
| static Handle<Value> ToJs(const Message& instance, |
| const Reflection* reflection, |
| const FieldDescriptor* field, |
| const Type* message_type, |
| int index) { |
| DBG("Type::ToJs(instance, refelction, field, message_type) E:"); |
| switch (field->cpp_type()) { |
| case FieldDescriptor::CPPTYPE_MESSAGE: |
| DBG("Type::ToJs CPPTYPE_MESSAGE"); |
| return message_type->ToJs(GET(Message)); |
| case FieldDescriptor::CPPTYPE_STRING: { |
| DBG("Type::ToJs CPPTYPE_STRING"); |
| const string& value = GET(String); |
| return String::New(value.data(), value.length()); |
| } |
| case FieldDescriptor::CPPTYPE_INT32: |
| DBG("Type::ToJs CPPTYPE_INT32"); |
| return Integer::New(GET(Int32)); |
| case FieldDescriptor::CPPTYPE_UINT32: |
| DBG("Type::ToJs CPPTYPE_UINT32"); |
| return Integer::NewFromUnsigned(GET(UInt32)); |
| case FieldDescriptor::CPPTYPE_INT64: |
| DBG("Type::ToJs CPPTYPE_INT64"); |
| return Number::New(GET(Int64)); |
| case FieldDescriptor::CPPTYPE_UINT64: |
| DBG("Type::ToJs CPPTYPE_UINT64"); |
| return Number::New(GET(UInt64)); |
| case FieldDescriptor::CPPTYPE_FLOAT: |
| DBG("Type::ToJs CPPTYPE_FLOAT"); |
| return Number::New(GET(Float)); |
| case FieldDescriptor::CPPTYPE_DOUBLE: |
| DBG("Type::ToJs CPPTYPE_DOUBLE"); |
| return Number::New(GET(Double)); |
| case FieldDescriptor::CPPTYPE_BOOL: |
| DBG("Type::ToJs CPPTYPE_BOOL"); |
| return Boolean::New(GET(Bool)); |
| case FieldDescriptor::CPPTYPE_ENUM: |
| DBG("Type::ToJs CPPTYPE_ENUM"); |
| return String::New(GET(Enum)->name().c_str()); |
| } |
| |
| return Handle<Value>(); // NOTREACHED |
| } |
| #undef GET |
| |
| Handle<Object> ToJs(const Message& instance) const { |
| DBG("Type::ToJs(Message) E:"); |
| const Reflection* reflection = instance.GetReflection(); |
| const Descriptor* descriptor = instance.GetDescriptor(); |
| |
| Handle<Array> properties = Array::New(descriptor->field_count()); |
| for (int i = 0; i < descriptor->field_count(); i++) { |
| HandleScope scope; |
| |
| const FieldDescriptor* field = descriptor->field(i); |
| bool repeated = field->is_repeated(); |
| if (repeated && !reflection->FieldSize(instance, field)) { |
| DBG("Ignore repeated field with no size in reflection data"); |
| continue; |
| } |
| if (!repeated && !reflection->HasField(instance, field)) { |
| DBG("Ignore field with no field in relfection data"); |
| continue; |
| } |
| |
| const Type* child_type = |
| (field->cpp_type() == FieldDescriptor::CPPTYPE_MESSAGE) ? |
| schema_->GetType(field->message_type()) : NULL; |
| |
| Handle<Value> value; |
| if (field->is_repeated()) { |
| int size = reflection->FieldSize(instance, field); |
| Handle<Array> array = Array::New(size); |
| for (int j = 0; j < size; j++) { |
| array->Set(j, ToJs(instance, reflection, field, child_type, j)); |
| } |
| value = array; |
| } else { |
| value = ToJs(instance, reflection, field, child_type, -1); |
| } |
| |
| DBG("Type::ToJs: set property[%d]=%s", i, ToCString(value)); |
| properties->Set(i, value); |
| } |
| |
| DBG("Type::ToJs(Message) X:"); |
| return NewObject(properties); |
| } |
| |
| static Handle<Value> Parse(const Arguments& args) { |
| DBG("Type::Parse(args) E:"); |
| Type* type = UnwrapThis<Type>(args); |
| Buffer* buf = ObjectWrap::Unwrap<Buffer>(args[0]->ToObject()); |
| |
| Message* message = type->NewMessage(); |
| message->ParseFromArray(buf->data(), buf->length()); |
| Handle<Object> result = type->ToJs(*message); |
| delete message; |
| |
| DBG("Type::Parse(args) X:"); |
| return result; |
| } |
| |
| #define SET(TYPE, EXPR) \ |
| if (repeated) reflection->Add##TYPE(instance, field, EXPR); \ |
| else reflection->Set##TYPE(instance, field, EXPR) |
| |
| static bool ToProto(Message* instance, |
| const FieldDescriptor* field, |
| Handle<Value> value, |
| const Type* type, |
| bool repeated) { |
| DBG("Type::ToProto(instance, field, value, type, repeated) E:"); |
| bool ok = true; |
| HandleScope scope; |
| |
| DBG("Type::ToProto field->name()=%s", field->name().c_str()); |
| const Reflection* reflection = instance->GetReflection(); |
| switch (field->cpp_type()) { |
| case FieldDescriptor::CPPTYPE_MESSAGE: |
| DBG("Type::ToProto CPPTYPE_MESSAGE"); |
| ok = type->ToProto(repeated ? |
| reflection->AddMessage(instance, field) : |
| reflection->MutableMessage(instance, field), |
| value.As<Object>()); |
| break; |
| case FieldDescriptor::CPPTYPE_STRING: { |
| DBG("Type::ToProto CPPTYPE_STRING"); |
| String::AsciiValue ascii(value); |
| SET(String, string(*ascii, ascii.length())); |
| break; |
| } |
| case FieldDescriptor::CPPTYPE_INT32: |
| DBG("Type::ToProto CPPTYPE_INT32"); |
| SET(Int32, value->NumberValue()); |
| break; |
| case FieldDescriptor::CPPTYPE_UINT32: |
| DBG("Type::ToProto CPPTYPE_UINT32"); |
| SET(UInt32, value->NumberValue()); |
| break; |
| case FieldDescriptor::CPPTYPE_INT64: |
| DBG("Type::ToProto CPPTYPE_INT64"); |
| SET(Int64, value->NumberValue()); |
| break; |
| case FieldDescriptor::CPPTYPE_UINT64: |
| DBG("Type::ToProto CPPTYPE_UINT64"); |
| SET(UInt64, value->NumberValue()); |
| break; |
| case FieldDescriptor::CPPTYPE_FLOAT: |
| DBG("Type::ToProto CPPTYPE_FLOAT"); |
| SET(Float, value->NumberValue()); |
| break; |
| case FieldDescriptor::CPPTYPE_DOUBLE: |
| DBG("Type::ToProto CPPTYPE_DOUBLE"); |
| SET(Double, value->NumberValue()); |
| break; |
| case FieldDescriptor::CPPTYPE_BOOL: |
| DBG("Type::ToProto CPPTYPE_BOOL"); |
| SET(Bool, value->BooleanValue()); |
| break; |
| case FieldDescriptor::CPPTYPE_ENUM: |
| DBG("Type::ToProto CPPTYPE_ENUM"); |
| |
| // Don't use SET as vd can be NULL |
| char error_buff[256]; |
| const google::protobuf::EnumValueDescriptor* vd; |
| int i32_value = 0; |
| const char *str_value = NULL; |
| const google::protobuf::EnumDescriptor* ed = field->enum_type(); |
| |
| if (value->IsNumber()) { |
| i32_value = value->Int32Value(); |
| vd = ed->FindValueByNumber(i32_value); |
| if (vd == NULL) { |
| snprintf(error_buff, sizeof(error_buff), |
| "Type::ToProto Bad enum value, %d is not a member of enum %s", |
| i32_value, ed->full_name().c_str()); |
| } |
| } else { |
| str_value = ToCString(value); |
| // TODO: Why can str_value be corrupted sometimes? |
| ALOGD("str_value=%s", str_value); |
| vd = ed->FindValueByName(str_value); |
| if (vd == NULL) { |
| snprintf(error_buff, sizeof(error_buff), |
| "Type::ToProto Bad enum value, %s is not a member of enum %s", |
| str_value, ed->full_name().c_str()); |
| } |
| } |
| if (vd != NULL) { |
| if (repeated) { |
| reflection->AddEnum(instance, field, vd); |
| } else { |
| reflection->SetEnum(instance, field, vd); |
| } |
| } else { |
| v8::ThrowException(String::New(error_buff)); |
| ok = false; |
| } |
| break; |
| } |
| DBG("Type::ToProto(instance, field, value, type, repeated) X: ok=%d", ok); |
| return ok; |
| } |
| #undef SET |
| |
| bool ToProto(Message* instance, Handle<Object> src) const { |
| DBG("ToProto(Message *, Handle<Object>) E:"); |
| |
| Handle<Function> to_array = handle_->GetInternalField(3).As<Function>(); |
| Handle<Array> properties = to_array->Call(src, 0, NULL).As<Array>(); |
| bool ok = true; |
| for (int i = 0; ok && (i < descriptor_->field_count()); i++) { |
| Handle<Value> value = properties->Get(i); |
| if (value->IsUndefined()) continue; |
| |
| const FieldDescriptor* field = descriptor_->field(i); |
| const Type* child_type = |
| (field->cpp_type() == FieldDescriptor::CPPTYPE_MESSAGE) ? |
| schema_->GetType(field->message_type()) : NULL; |
| if (field->is_repeated()) { |
| if(!value->IsArray()) { |
| ok = ToProto(instance, field, value, child_type, true); |
| } else { |
| Handle<Array> array = value.As<Array>(); |
| int length = array->Length(); |
| for (int j = 0; ok && (j < length); j++) { |
| ok = ToProto(instance, field, array->Get(j), child_type, true); |
| } |
| } |
| } else { |
| ok = ToProto(instance, field, value, child_type, false); |
| } |
| } |
| DBG("ToProto(Message *, Handle<Object>) X: ok=%d", ok); |
| return ok; |
| } |
| |
| static Handle<Value> Serialize(const Arguments& args) { |
| Handle<Value> result; |
| DBG("Serialize(Arguments&) E:"); |
| if (!args[0]->IsObject()) { |
| DBG("Serialize(Arguments&) X: not an object"); |
| return v8::ThrowException(args[0]); |
| } |
| |
| Type* type = UnwrapThis<Type>(args); |
| Message* message = type->NewMessage(); |
| if (type->ToProto(message, args[0].As<Object>())) { |
| int length = message->ByteSize(); |
| Buffer* buffer = Buffer::New(length); |
| message->SerializeWithCachedSizesToArray((google::protobuf::uint8*)buffer->data()); |
| delete message; |
| |
| result = buffer->handle_; |
| } else { |
| result = v8::Undefined(); |
| } |
| DBG("Serialize(Arguments&) X"); |
| return result; |
| } |
| |
| static Handle<Value> ToString(const Arguments& args) { |
| return String::New(UnwrapThis<Type>(args)->descriptor_->full_name().c_str()); |
| } |
| }; |
| |
| Message* NewMessage(const Descriptor* descriptor) { |
| DBG("Schema::NewMessage(descriptor) EX:"); |
| return factory_.GetPrototype(descriptor)->New(); |
| } |
| |
| Type* GetType(const Descriptor* descriptor) { |
| DBG("Schema::GetType(descriptor) E:"); |
| Type* result = types_[descriptor]; |
| if (result) return result; |
| |
| result = types_[descriptor] = |
| new Type(this, descriptor, TypeTemplate->GetFunction()->NewInstance()); |
| |
| // managed schema->[type] link |
| Handle<Array> types = handle_->GetInternalField(1).As<Array>(); |
| types->Set(types->Length(), result->handle_); |
| DBG("Schema::GetType(descriptor) X:"); |
| return result; |
| } |
| |
| const DescriptorPool* pool_; |
| map<const Descriptor*, Type*> types_; |
| DynamicMessageFactory factory_; |
| |
| static Handle<Value> GetType(const Local<String> name, |
| const AccessorInfo& args) { |
| DBG("Schema::GetType(name, args) E:"); |
| Schema* schema = UnwrapThis<Schema>(args); |
| const Descriptor* descriptor = |
| schema->pool_->FindMessageTypeByName(*String::AsciiValue(name)); |
| |
| DBG("Schema::GetType(name, args) X:"); |
| return descriptor ? |
| schema->GetType(descriptor)->Constructor() : |
| Handle<Function>(); |
| } |
| |
| static Handle<Value> NewSchema(const Arguments& args) { |
| DBG("Schema::NewSchema E: args.Length()=%d", args.Length()); |
| if (!args.Length()) { |
| return (new Schema(args.This(), |
| DescriptorPool::generated_pool()))->handle_; |
| } |
| |
| Buffer* buf = ObjectWrap::Unwrap<Buffer>(args[0]->ToObject()); |
| |
| FileDescriptorSet descriptors; |
| if (!descriptors.ParseFromArray(buf->data(), buf->length())) { |
| DBG("Schema::NewSchema X: bad descriptor"); |
| return v8::ThrowException(String::New("Malformed descriptor")); |
| } |
| |
| DescriptorPool* pool = new DescriptorPool; |
| for (int i = 0; i < descriptors.file_size(); i++) { |
| pool->BuildFile(descriptors.file(i)); |
| } |
| |
| DBG("Schema::NewSchema X"); |
| return (new Schema(args.This(), pool))->handle_; |
| } |
| }; |
| |
| void Init() { |
| DBG("Init E:"); |
| HandleScope handle_scope; |
| |
| TypeTemplate = Persistent<FunctionTemplate>::New(FunctionTemplate::New()); |
| TypeTemplate->SetClassName(String::New("Type")); |
| // native self |
| // owning schema (so GC can manage our lifecyle) |
| // constructor |
| // toArray |
| TypeTemplate->InstanceTemplate()->SetInternalFieldCount(4); |
| |
| SchemaTemplate = Persistent<FunctionTemplate>::New(FunctionTemplate::New(Schema::NewSchema)); |
| SchemaTemplate->SetClassName(String::New("Schema")); |
| // native self |
| // array of types (so GC can manage our lifecyle) |
| SchemaTemplate->InstanceTemplate()->SetInternalFieldCount(2); |
| SchemaTemplate->InstanceTemplate()->SetNamedPropertyHandler(Schema::GetType); |
| |
| ParseTemplate = Persistent<FunctionTemplate>::New(FunctionTemplate::New(Schema::Type::Parse)); |
| SerializeTemplate = Persistent<FunctionTemplate>::New(FunctionTemplate::New(Schema::Type::Serialize)); |
| |
| DBG("Init X:"); |
| } |
| |
| } // namespace protobuf_v8 |
| |
| extern "C" void SchemaObjectTemplateInit(Handle<ObjectTemplate> target) { |
| DBG("SchemaObjectTemplateInit(target) EX:"); |
| target->Set(String::New("Schema"), protobuf_v8::SchemaTemplate); |
| } |