C++ KObjectRef::GetMethod方法代码示例

	void UIBinding::Log(Logger::Level level, std::string& message)
	{
		if (level > Logger::LWARN)
			return;

		std::string methodName("warn");
		if (level < Logger::LWARN)
			methodName = "error";

		std::string origMethodName(methodName);
		origMethodName.append("_orig");

		std::vector<AutoUserWindow>& openWindows = UIBinding::GetInstance()->GetOpenWindows();
		for (size_t i = 0; i < openWindows.size(); i++)
		{
			KObjectRef domWindow = openWindows[i]->GetDOMWindow();
			if (domWindow.isNull())
				continue;

			KObjectRef console = domWindow->GetObject("console", 0);
			if (console.isNull())
				continue;

			KMethodRef method = console->GetMethod(origMethodName.c_str(), 0);
			if (method.isNull())
				method = console->GetMethod(methodName.c_str(), 0);

			RunOnMainThread(method, ValueList(Value::NewString(message)), false);
		}
	}

	KValueRef Script::Evaluate(const char *mimeType, const char *name, const char *code, KObjectRef scope)
	{
		KObjectRef evaluator = this->FindEvaluatorWithMethod("canEvaluate", mimeType);
		if (!evaluator.isNull())
		{
			KMethodRef evaluate = evaluator->GetMethod("evaluate");
			if (!evaluate.isNull())
			{
				ValueList args;
				args.push_back(Value::NewString(mimeType));
				args.push_back(Value::NewString(name));
				args.push_back(Value::NewString(code));
				args.push_back(Value::NewObject(scope));
				return evaluate->Call(args);
			}
			else
			{
				throw ValueException::FromFormat(
					"Error evaluating: No \"evaluate\" method found on evaluator for mimeType: \"%s\"", mimeType);
			}
		}
		else
		{
			throw ValueException::FromFormat("Error evaluating: No evaluator found for mimeType: \"%s\"", mimeType);
		}
	}

void Notification::Configure(KObjectRef properties)
{
	this->title = properties->GetString("title");
	this->message = properties->GetString("message");
	this->iconURL = properties->GetString("icon");
	this->timeout = properties->GetInt("timeout", -1);
	this->clickedCallback = properties->GetMethod("callback");
}

void Network::_GetHostByAddress(const ValueList& args, KValueRef result)
{
    if (args.at(0)->IsObject())
    {
        KObjectRef obj = args.at(0)->ToObject();
        AutoPtr<IPAddress> b = obj.cast<IPAddress>();
        if (!b.isNull())
        {
            // in this case, they've passed us an IPAddressBinding
            // object, which we can just retrieve the ipaddress
            // instance and resolving using it
            Poco::Net::IPAddress addr(b->GetAddress()->toString());
            AutoPtr<Host> binding = new Host(addr);
            if (binding->IsInvalid())
            {
                throw ValueException::FromString("Could not resolve address");
            }
            result->SetObject(binding);
            return;
        }
        else
        {
            KMethodRef toStringMethod = obj->GetMethod("toString");
            if (toStringMethod.isNull())
                throw ValueException::FromString("Unknown object passed");

            result->SetObject(GetHostBinding(toStringMethod->Call()->ToString()));
            return;
        }
    }
    else if (args.at(0)->IsString())
    {
        // in this case, they just passed in a string so resolve as normal
        result->SetObject(GetHostBinding(args.GetString(0)));
    }
}

	AutoPtr<PreprocessData> Script::Preprocess(const char *url, KObjectRef scope)
	{
		KObjectRef evaluator = this->FindEvaluatorWithMethod("canPreprocess", url);
		if (!evaluator.isNull())
		{
			KMethodRef preprocess = evaluator->GetMethod("preprocess");
			if (!preprocess.isNull())
			{
				ValueList args;
				args.push_back(Value::NewString(url));
				args.push_back(Value::NewObject(scope));
				
				KValueRef result = preprocess->Call(args);
				
				if (result->IsObject())
				{
					KObjectRef object = result->ToObject();
					AutoPtr<PreprocessData> data = new PreprocessData();
					if (object->HasProperty("data"))
					{
						KValueRef objectData = object->Get("data");
						if (objectData->IsObject())
						{
							BlobRef blobData = objectData->ToObject().cast<Blob>();
							if (!blobData.isNull())
							{
								data->data = blobData;
							}
						}
						else if (objectData->IsString())
						{
							data->data = new Blob(objectData->ToString(), strlen(objectData->ToString()));
						}
					}
					else
					{
						throw ValueException::FromString("Preprocessor didn't return any data");
					}
					if (object->HasProperty("mimeType"))
					{
						data->mimeType = object->Get("mimeType")->ToString();
					}
					else
					{
						throw ValueException::FromString("Preprocessor didn't return a mimeType");
					}
					
					return data;
				}
			}
			else
			{
				throw ValueException::FromFormat(
					"Error preprocessing: No \"preprocess\" method found on evaluator for url: \"%s\"", url);
			}
		}
		else
		{
			throw ValueException::FromFormat("Error preprocessing: No evaluator found for url: \"%s\"", url);
		}
		return 0;
	}

	bool HTTPClientBinding::BeginRequest(KValueRef sendData)
	{
		if (this->Get("connected")->ToBool())
		{
			return false;
		}

		// Reset internal variables for new request
		if (this->dirty)
		{
			this->Reset();
		}

		// Determine what data type we have to send
		if (sendData->IsObject())
		{
			KObjectRef dataObject = sendData->ToObject();
			KMethodRef nativePathMethod(dataObject->GetMethod("nativePath"));
			KMethodRef sizeMethod(dataObject->GetMethod("size"));

			if (nativePathMethod.isNull() || sizeMethod.isNull())
			{
				std::string err("Unsupported File-like object: did not have"
					"nativePath and size methods");
				logger->Error(err);
				throw ValueException::FromString(err);
			}

			const char* filename = nativePathMethod->Call()->ToString();
			if (!filename)
			{
				std::string err("Unsupported File-like object: nativePath method"
					"did not return a String");
				logger->Error(err);
				throw ValueException::FromString(err);
			}

			this->datastream = new std::ifstream(filename,
				std::ios::in | std::ios::binary);
			if (this->datastream->fail())
			{
				std::string err("Failed to open file: ");
				err.append(filename);
				logger->Error(err);
				throw ValueException::FromString(err);
			}

			this->contentLength = sizeMethod->Call()->ToInt();
		}
		else if (sendData->IsString())
		{
			std::string dataString(sendData->ToString());
			if (!dataString.empty())
			{
				this->datastream = new std::istringstream(dataString,
						std::ios::in | std::ios::binary);
				this->contentLength = dataString.length();
			}
		}
		else
		{
			// Sending no data
			this->datastream = 0;
		}

		this->dirty = true;
		this->Set("connected", Value::NewBool(true));

		if (this->async)
		{
			this->thread = new Poco::Thread();
			this->thread->start(*this);
		}
		else
		{
			this->ExecuteRequest();
		}

		return true;
	}