C++ Arguments::Data方法代码示例

/* Generic constructor wrapper.
 * args[0]: row buffer
 * args[1]: array of blob & text column values
 * args.Data(): mapData holding the record and ColumnHandlers
 * args.This(): VO built from the mapping-specific InstanceTemplate
*/
Handle<Value> nroConstructor(const Arguments &args) {
  HandleScope scope;

  if(args.IsConstructCall()) {
    /* Unwrap record from mapData */
    Local<Object> mapData = args.Data()->ToObject();
    const Record * record = 
      unwrapPointer<const Record *>(mapData->Get(0)->ToObject());

    /* Unwrap Column Handlers from mapData */
    ColumnHandlerSet * handlers = 
      unwrapPointer<ColumnHandlerSet *>(mapData->Get(1)->ToObject());

    /* Build NdbRecordObject */
    NdbRecordObject * nro = new NdbRecordObject(record, handlers, args[0], args[1]);

    /* Wrap for JavaScript */
    wrapPointerInObject<NdbRecordObject *>(nro, nroEnvelope, args.This());
    freeFromGC(nro, args.This());
  }
  else {
    ThrowException(Exception::Error(String::New("must be a called as constructor")));
  }
  return args.This();
}

Handle<Value> AppjsSchemeHandler::NodeCallback(const Arguments& args) {
  HandleScope scope;

  AppjsSchemeHandler* me = static_cast<AppjsSchemeHandler *>(UnwrapObject(args.Data()));

  AutoLock lock_scope(me);

  me->status_      = args[0]->NumberValue();
  me->status_text_ = V8StringToChar(args[1]->ToString());
  me->mime_type_   = V8StringToChar(args[2]->ToString());
  me->data_        = node::Buffer::Data(args[4]->ToObject());
  me->data_length_ = node::Buffer::Length(args[4]->ToObject());

  Local<Object> headerSets = args[3]->ToObject();
  Local<Array> names = Local<Array>::Cast(headerSets->Get(String::NewSymbol("names")));
  Local<Array> headers = Local<Array>::Cast(headerSets->Get(String::NewSymbol("headers")));

  for(int i = 0; i < names->Length(); i++) {
    me->headers_.insert(
      std::pair<CefString,CefString>(
        V8StringToChar(names->Get(i)),
        V8StringToChar(headers->Get(i))
      )
    );
  }

  me->callback_->HeadersAvailable();

  return args.This();
}

Handle<Value> Interface::PlatformOpInvoke(const Arguments& args) {
  HandleScope scope;
  jobject ob = (jobject)args.This()->GetPointerFromInternalField(0);
  int opData = args.Data()->Int32Value();
  int opIdx = opData & 0xffff;
  int clsid = opData >> 16;
  Env *env = Env::getEnv_nocheck();
  Interface *interface = env->getInterface(clsid);
  if(interface) {
    Operation *op = interface->operations->addr(opIdx);
    JNIEnv *jniEnv = interface->env->getVM()->getJNIEnv();
    jniEnv->PushLocalFrame(256);
    int result = OK;
    jobjectArray jArgs = 0;
    Local<Value> val;
    int expectedArgs = op->argCount;
    if(expectedArgs > 0) {
      jArgs = (jobjectArray)jniEnv->CallStaticObjectMethod(interface->jPlatformStub, interface->jPlatformGetArgs);
      jniEnv->MonitorEnter(jArgs);
      int suppliedArgs = args.Length();
      int argsToProcess = (suppliedArgs < expectedArgs) ? suppliedArgs : expectedArgs;
      jobject jItem;
      for(int i = 0; i < argsToProcess; i++) {
        result = interface->conv->ToJavaObject(jniEnv, args[i], op->argTypes[i], &jItem);
        if(result != OK) break;
        jniEnv->SetObjectArrayElement(jArgs, i, jItem);    
      }
      if(result == OK) {
        for(int i = argsToProcess; i < expectedArgs; i++) {
          result = interface->conv->ToJavaObject(jniEnv, Undefined(), op->argTypes[i], &jItem);
          if(result != OK) break;
          jniEnv->SetObjectArrayElement(jArgs, i, jItem);
        }
      }
    }
    if(result == OK) {
      jobject jVal = jniEnv->CallStaticObjectMethod(interface->jPlatformStub, interface->jPlatformInvoke, ob, opIdx, jArgs);
      if(env->getConv()->CheckForException(jniEnv)) {
        return Undefined();
      }
      if(result == OK) {
        result = interface->conv->ToV8Value(jniEnv, jVal, op->type, &val);
      }
    }
    if(expectedArgs > 0) {
      jniEnv->MonitorExit(jArgs);
    }
    jniEnv->PopLocalFrame(0);
    if(result == OK && !val.IsEmpty()) {
      return scope.Close(val);
    }
    interface->conv->ThrowV8ExceptionForErrno(result);
    LOGV("Interface::PlatformOpInvoke(): ret (error), result = %d\n", result);
  }
  return Undefined(); 
}

Handle<Value> Proxy::onPropertyChanged(const Arguments& args)
{
	if (args.Length() < 1) {
		return JSException::Error("Requires property name as first parameters.");
	}

	Local<String> name = args.Data()->ToString();
	Local<Value> value = args[0];
	onPropertyChangedForProxy(name, value, args.Holder());

	return Undefined();
}

    Handle< Value > V8Scope::loadCallback( const Arguments &args ) {
        HandleScope scope;
        Handle<External> field = Handle<External>::Cast(args.Data());
        void* ptr = field->Value();
        V8Scope* self = static_cast<V8Scope*>(ptr);

        Context::Scope context_scope(self->_context);
        for (int i = 0; i < args.Length(); ++i) {
            std::string filename(toSTLString(args[i]));
            if (!self->execFile(filename, false , true , false)) {
                return v8::ThrowException(v8::String::New((std::string("error loading file: ") + filename).c_str()));
            }
        }
        return v8::True();
    }

Handle<Value> AppjsSchemeHandler::NodeCallback(const Arguments& args) {

  HandleScope scope;

  AppjsSchemeHandler* me = static_cast<AppjsSchemeHandler *>(UnwrapObject(args.Data()));

  AutoLock lock_scope(me);

  me->status_      = args[0]->NumberValue();
  me->status_text_ = appjs::V8StringToChar(args[1]->ToString());
  me->mime_type_   = appjs::V8StringToChar(args[2]->ToString());
  me->data_        = node::Buffer::Data(args[3]->ToObject());
  me->data_length_ = node::Buffer::Length(args[3]->ToObject());

  me->callback_->HeadersAvailable();

  return args.This();
}

Handle<Value> BGJSView::js_view_on(const Arguments& args) {
	v8::Locker l;
	HandleScope scope;
	BGJSView *view = externalToClassPtr<BGJSView>(args.Data());
	if (args.Length() == 2 && args[0]->IsString() && args[1]->IsObject()) {
		Handle<Object> func = args[1]->ToObject();
		if (func->IsFunction()) {
			String::Utf8Value eventUtf8(args[0]->ToString());
			const char *event = *eventUtf8;
			if (strcmp(event, "event") == 0) {
				view->_cbEvent.push_back(Persistent<Object>::New(func));
			} else if (strcmp(event, "close") == 0) {
				view->_cbClose.push_back(Persistent<Object>::New(func));
			} else if (strcmp(event, "resize") == 0) {
				view->_cbResize.push_back(Persistent<Object>::New(func));
			} else if (strcmp(event, "redraw") == 0) {
				view->_cbRedraw.push_back(Persistent<Object>::New(func));
			}
		}
	}
	return v8::Undefined();
}

// Common function to handle getdns_address/service/hostname
Handle<Value> GNContext::HelperLookup(const Arguments& args) {
    // first argument is a string
    // last argument must be a callback
    // optional argument of extensions
    HandleScope scope;
    // name, type, and callback are required
    if (args.Length() < 2) {
        ThrowException(Exception::TypeError(String::New("At least 2 arguments are required.")));
    }
    // last arg must be a callback
    Local<Value> last = args[args.Length() - 1];
    if (!last->IsFunction()) {
        ThrowException(Exception::TypeError(String::New("Final argument must be a function.")));
    }
    Local<Function> localCb = Local<Function>::Cast(last);
    GNContext* ctx = node::ObjectWrap::Unwrap<GNContext>(args.This());
    if (!ctx || !ctx->context_) {
        Handle<Value> err = makeErrorObj("Context is invalid", GETDNS_RETURN_GENERIC_ERROR);
        Handle<Value> cbArgs[] = { err };
        localCb->Call(Context::GetCurrent()->Global(), 1, cbArgs);
        return scope.Close(Undefined());
    }
    // take first arg and make it a string
    String::Utf8Value name(args[0]->ToString());

    // 2nd arg could be extensions
    // optional third arg is an object
    getdns_dict* extension = NULL;
    if (args.Length() > 2 && args[1]->IsObject()) {
        extension = GNUtil::convertToDict(args[1]->ToObject());
    }

    // figure out what called us
    uint32_t funcType = args.Data()->Uint32Value();
    Persistent<Function> callback = Persistent<Function>::New(localCb);
    // create callback data
    CallbackData *data = new CallbackData();
    data->callback = callback;
    data->ctx = ctx;
    ctx->Ref();

    getdns_transaction_t transId;
    getdns_return_t r = GETDNS_RETURN_GOOD;
    if (funcType == GNAddress) {
        r = getdns_address(ctx->context_, *name, extension,
                           data, &transId, GNContext::Callback);
    } else if(funcType == GNService) {
        r = getdns_service(ctx->context_, *name, extension,
                           data, &transId, GNContext::Callback);
    } else {
        // hostname
        // convert to a dictionary..
        getdns_dict* ip = getdns_util_create_ip(*name);
        if (ip) {
            r = getdns_hostname(ctx->context_, ip, extension,
                                data, &transId, GNContext::Callback);
            getdns_dict_destroy(ip);
        } else {
            r = GETDNS_RETURN_GENERIC_ERROR;
        }
    }

    if (r != GETDNS_RETURN_GOOD) {
        // fail
        data->callback.Dispose();
        data->ctx->Unref();
        delete data;

        Handle<Value> err = makeErrorObj("Error issuing query", r);
        Handle<Value> cbArgs[] = { err };
        localCb->Call(Context::GetCurrent()->Global(), 1, cbArgs);
        return scope.Close(Undefined());
    }
    // done. return as buffer
    return scope.Close(GNUtil::convertToBuffer(&transId, 8));
}

Handle<Value> JSWrapper( const Arguments &args )
{
	JavaMethod* m = (JavaMethod*) External::Unwrap(args.Data());
	m->Invoke(args);
	return Undefined();
}

Handle<Value> Proxy::proxyConstructor(const Arguments& args)
{
	HandleScope scope;
	JNIEnv *env = JNIScope::getEnv();
	Local<Object> jsProxy = args.Holder();

	Handle<Object> properties = Object::New();
	jsProxy->Set(propertiesSymbol, properties, PropertyAttribute(DontEnum));

	Handle<Object> prototype = jsProxy->GetPrototype()->ToObject();

	Handle<Function> constructor = Handle<Function>::Cast(prototype->Get(constructorSymbol));
	jclass javaClass = (jclass) External::Unwrap(constructor->Get(javaClassSymbol));

	// If ProxyFactory::createV8Proxy invoked us, unwrap
	// the pre-created Java proxy it sent.
	jobject javaProxy = ProxyFactory::unwrapJavaProxy(args);
	bool deleteRef = false;
	if (!javaProxy) {
		javaProxy = ProxyFactory::createJavaProxy(javaClass, jsProxy, args);
		deleteRef = true;
	}

	JNIUtil::logClassName("Create proxy: %s", javaClass);

	Proxy *proxy = new Proxy(javaProxy);
	proxy->Wrap(jsProxy);

	int length = args.Length();

	if (length > 0 && args[0]->IsObject()) {
		/*
		Handle<Value> argsStr = V8Util::jsonStringify(args[0]);
		String::Utf8Value str(argsStr);
		LOGV(TAG, "    with args: %s", *str);
		*/

		bool extend = true;
		Handle<Object> createProperties = args[0]->ToObject();
		Local<String> constructorName = createProperties->GetConstructorName();
		if (strcmp(*String::Utf8Value(constructorName), "Arguments") == 0) {
			extend = false;
			int32_t argsLength = createProperties->Get(String::New("length"))->Int32Value();
			if (argsLength > 1) {
				Handle<Value> properties = createProperties->Get(1);
				if (properties->IsObject()) {
					extend = true;
					createProperties = properties->ToObject();
				}
			}
		}

		if (extend) {
			Handle<Array> names = createProperties->GetOwnPropertyNames();
			int length = names->Length();

			for (int i = 0; i < length; ++i) {
				Handle<Value> name = names->Get(i);
				Handle<Value> value = createProperties->Get(name);
				bool isProperty = true;
				if (name->IsString()) {
					Handle<String> nameString = name->ToString();
					if (!jsProxy->HasRealNamedCallbackProperty(nameString)
						&& !jsProxy->HasRealNamedProperty(nameString)) {
						jsProxy->Set(name, value);
						isProperty = false;
					}
				}
				if (isProperty) {
					properties->Set(name, value);
				}
			}
		}
	}


	if (!args.Data().IsEmpty() && args.Data()->IsFunction()) {
		Handle<Function> proxyFn = Handle<Function>::Cast(args.Data());
		Handle<Value> *fnArgs = new Handle<Value>[length];
		for (int i = 0; i < length; ++i) {
			fnArgs[i] = args[i];
		}
		proxyFn->Call(jsProxy, length, fnArgs);
	}

	if (deleteRef) {
		JNIEnv *env = JNIScope::getEnv();
		if (env) {
			env->DeleteLocalRef(javaProxy);
		}
	}

	return jsProxy;
}