Golang Object.Set方法代碼示例

// pipelines in javascript are chainable, you take in a pipeline, and you return a pipeline
// we just generalize some of that logic here
func (js *JavascriptBuilder) setFunc(obj *otto.Object, token string, fn func(string, Node, otto.FunctionCall) (Node, error)) error {
	return obj.Set(token, func(call otto.FunctionCall) otto.Value {
		this, _ := call.This.Export()

		node, err := CreateNode(this)
		if err != nil {
			js.err = err
			return otto.NullValue()
		}

		node, err = fn(token, node, call)
		if err != nil {
			js.err = err
			return otto.NullValue()
		}

		o, err := node.Object()
		if err != nil {
			js.err = err
			return otto.NullValue()
		}

		js.setFunc(o, "transform", js.transform)
		js.setFunc(o, "save", js.save)

		return o.Value()
	})
}

func ResponseWriterToJso(o *otto.Object, w http.ResponseWriter) {
	o.Set("write", func(c otto.FunctionCall) otto.Value {
		text, _ := c.Argument(0).ToString()
		w.Write([]byte(text))
		return otto.TrueValue()
	})
	o.Set("writeHeader", func(c otto.FunctionCall) otto.Value {
		statusCode, _ := c.Argument(0).ToInteger()
		w.WriteHeader(int(statusCode))
		return otto.TrueValue()
	})
}

func embedFinals(env *otto.Otto, ses *Session, obj *otto.Object) {
	obj.Set("All", allFunc(env, ses, obj))
	obj.Set("GetLimit", limitFunc(env, ses, obj))
	obj.Set("ToArray", toArrayFunc(env, ses, obj, false))
	obj.Set("ToValue", toValueFunc(env, ses, obj, false))
	obj.Set("TagArray", toArrayFunc(env, ses, obj, true))
	obj.Set("TagValue", toValueFunc(env, ses, obj, true))
	obj.Set("Map", mapFunc(env, ses, obj))
	obj.Set("ForEach", mapFunc(env, ses, obj))
}

func (wk *worker) embedFinals(env *otto.Otto, obj *otto.Object) {
	obj.Set("All", wk.allFunc(env, obj))
	obj.Set("GetLimit", wk.limitFunc(env, obj))
	obj.Set("ToArray", wk.toArrayFunc(env, obj, false))
	obj.Set("ToValue", wk.toValueFunc(env, obj, false))
	obj.Set("TagArray", wk.toArrayFunc(env, obj, true))
	obj.Set("TagValue", wk.toValueFunc(env, obj, true))
	obj.Set("Map", wk.mapFunc(env, obj))
	obj.Set("ForEach", wk.mapFunc(env, obj))
}

func (wk *worker) embedTraversals(env *otto.Otto, obj *otto.Object) {
	for _, t := range traversals {
		obj.Set(t, wk.gremlinFunc(t, obj, env))
	}
}

func embedTraversals(env *otto.Otto, ses *GremlinSession, obj *otto.Object) {
	obj.Set("In", gremlinFunc("in", obj, env, ses))
	obj.Set("Out", gremlinFunc("out", obj, env, ses))
	obj.Set("Is", gremlinFunc("is", obj, env, ses))
	obj.Set("Both", gremlinFunc("both", obj, env, ses))
	obj.Set("Follow", gremlinFunc("follow", obj, env, ses))
	obj.Set("FollowR", gremlinFollowR("followr", obj, env, ses))
	obj.Set("And", gremlinFunc("and", obj, env, ses))
	obj.Set("Intersect", gremlinFunc("and", obj, env, ses))
	obj.Set("Union", gremlinFunc("or", obj, env, ses))
	obj.Set("Or", gremlinFunc("or", obj, env, ses))
	obj.Set("Back", gremlinBack("back", obj, env, ses))
	obj.Set("Tag", gremlinFunc("tag", obj, env, ses))
	obj.Set("As", gremlinFunc("tag", obj, env, ses))
	obj.Set("Has", gremlinFunc("has", obj, env, ses))
	obj.Set("Save", gremlinFunc("save", obj, env, ses))
	obj.Set("SaveR", gremlinFunc("saver", obj, env, ses))
}

func RequestToJso(o *otto.Object, r *http.Request) {
	o.Set("url", r.URL.String())
	o.Set("header", r.Header)
	o.Set("cookies", r.Cookies())
	o.Set("method", r.Method)
	o.Set("host", r.Host)
	o.Set("contentLength", r.ContentLength)
	o.Set("proto", r.Proto)
	o.Set("transferEncoding", r.TransferEncoding)
	r.ParseForm()
	o.Set("formValues", r.Form)
}

func ResponseToJso(o *otto.Object, w *http.Response) {
	o.Set("status", w.Status)
	o.Set("header", w.Header)
	o.Set("cookies", w.Cookies())
	o.Set("statusCode", w.StatusCode)
	o.Set("proto", w.Proto)
	c, _ := ioutil.ReadAll(w.Body)
	o.Set("body", string(c))
	if w.TLS != nil {
		o.Set("tlsServerName", w.TLS.ServerName)
		o.Set("tlsNegotiatedProtocol", w.TLS.NegotiatedProtocol)
		names := []string{}
		ips := []string{}
		for _, k := range w.TLS.PeerCertificates {
			for _, n := range k.DNSNames {
				names = append(names, n)
			}
			for _, n := range k.IPAddresses {
				ips = append(ips, n.String())
			}
		}
		o.Set("tlsDNSNames", names)
		o.Set("tlsIPs", ips)
	}
}

func (wk *worker) embedTraversals(env *otto.Otto, obj *otto.Object) {
	obj.Set("In", wk.gremlinFunc("in", obj, env))
	obj.Set("Out", wk.gremlinFunc("out", obj, env))
	obj.Set("Is", wk.gremlinFunc("is", obj, env))
	obj.Set("Both", wk.gremlinFunc("both", obj, env))
	obj.Set("Follow", wk.gremlinFunc("follow", obj, env))
	obj.Set("FollowR", wk.gremlinFollowR("followr", obj, env))
	obj.Set("And", wk.gremlinFunc("and", obj, env))
	obj.Set("Intersect", wk.gremlinFunc("and", obj, env))
	obj.Set("Union", wk.gremlinFunc("or", obj, env))
	obj.Set("Or", wk.gremlinFunc("or", obj, env))
	obj.Set("Back", wk.gremlinBack("back", obj, env))
	obj.Set("Tag", wk.gremlinFunc("tag", obj, env))
	obj.Set("As", wk.gremlinFunc("tag", obj, env))
	obj.Set("Has", wk.gremlinFunc("has", obj, env))
	obj.Set("Save", wk.gremlinFunc("save", obj, env))
	obj.Set("SaveR", wk.gremlinFunc("saver", obj, env))
	obj.Set("Except", wk.gremlinFunc("except", obj, env))
	obj.Set("Difference", wk.gremlinFunc("except", obj, env))
	obj.Set("InPredicates", wk.gremlinFunc("in_predicates", obj, env))
	obj.Set("OutPredicates", wk.gremlinFunc("out_predicates", obj, env))
}