Golang Eye.Show方法代码示例

func (IntString) CognizeString(eye *be.Eye, v interface{}) {
	i, err := strconv.Atoi(v.(string))
	if err != nil {
		panic(err)
	}
	eye.Show("Int", i)
}

func (IgnoreValves) CognizeCircuit(eye *be.Eye, v interface{}) {
	u := v.(Circuit).Copy()
	n := u.Unify("ignoreValves")
	u.Gate[n] = NewVerbAddress("*", "Ignore")
	u.Reflow(Super, n)
	eye.Show(DefaultValve, u)
}

func depthFirst(eye *be.Eye, walk []Name, v interface{}) {
	x, ok := v.(Circuit)
	if !ok {
		return
	}
	for _, n := range x.SortedNames() {
		switch n.(type) { // skip non alpha-numeric names
		case int, string:
			v := x.At(n)
			depthFirst(eye, append(walk, n), v)
		}
	}

	var nm Name = "" // The root circuit is shown with the empty name
	if len(walk) > 0 {
		nm = walk[len(walk)-1]
	}

	frame := New().
		Grow("Address", Circuit(NewAddress(walk...))).
		Grow("Name", nm).
		Grow("View", x)

	eye.Show("Frame", frame)
	if len(walk) == 0 {
		eye.Show("End", v)
	}
}

func (LookPath) CognizeName(eye *be.Eye, value interface{}) {
	p, err := exec.LookPath(value.(string))
	if err != nil {
		log.Fatalf("no file path to %s", value.(string))
	}
	eye.Show(DefaultValve, p)
}

func (Join) CognizeView(eye *be.Eye, v interface{}) {
	u := v.(Circuit)
	var s []string
	for _, n := range u.SortedNames() {
		s = append(s, u.Gate[n].(string))
	}
	eye.Show(DefaultValve, path.Join(s...))
}

func (g *Lens) OverCognize(eye *be.Eye, valve Name, value interface{}) {
	g.remember(valve, value)
	for _, v := range g.valve {
		if v != valve {
			eye.Show(v, value)
		}
	}
}

func (Merge) CognizeIn(eye *be.Eye, v interface{}) {
	var w bytes.Buffer
	x := v.(Circuit)
	for _, name := range x.SortedLetters() {
		w.WriteString(flatten(x.StringAt(name)))
	}
	eye.Show("Out", w.String())
}

func (Gates) Cognize(eye *be.Eye, value interface{}) {
	u := value.(Circuit)
	for name, _ := range u.SortedNames() {
		frame := New()
		frame.Grow("Name", name).Grow("Value", u.At(name))
		eye.Show("Frame", frame)
	}
	eye.Show("End", value)
}

func (Process) CognizeCommand(eye *be.Eye, dvalue interface{}) {
	x := New()
	if exit := spawnProcess(eye, cognizeCommand(dvalue)); exit != nil {
		x.Grow("Exit", 1)
		eye.Show("Exit", x)
	} else {
		x.Grow("Exit", 0)
		eye.Show("Exit", x)
	}
}

func (Parse) CognizeText(eye *be.Eye, v interface{}) {
	src := a.NewSrcString(plumb.AsString(v))
	for {
		v := see.SeeChamber(src)
		if v == nil {
			break
		}
		eye.Show("Value", v)
	}
}

func (Chunk) CognizeReader(eye *be.Eye, v interface{}) {
	r := kio.NewChunkReader(v.(io.Reader))
	for {
		chunk, err := r.Read()
		if err != nil {
			return
		}
		eye.Show("Chunk", chunk)
	}
}

func (Lookup) CognizeView(eye *be.Eye, v interface{}) {
	u := v.(Circuit)
	x := u.CircuitAt("Index")
	addr := u.VerbAt("Address")
	r := be.AsIndex(x).Recall(addr.Address()...)
	if r == nil {
		eye.Show("NotFound", New().Grow("NotFound", Circuit(addr)).Grow("In", x))
	} else {
		eye.Show("Found", r)
	}
}

func (s *Star) OverCognize(eye *be.Eye, name Name, value interface{}) {
	if s.f != nil {
		s.f(name, value)
	}
	for gn_, _ := range s.view.Gate {
		gn := gn_
		if gn == name {
			continue
		}
		go eye.Show(gn, value)
	}
}

func (Index) Spark(eye *be.Eye, matter Circuit, aux ...interface{}) Value {
	index, view := matter.CircuitAt("Index"), matter.CircuitAt("View")
	go func() {
		for vlv, _ := range view.Gate {
			eye.Show(vlv, index)
		}
	}()
	if view.Len() == 0 {
		return index
	}
	return nil
}

func (SourceFile) Spark(eye *be.Eye, _ Circuit, aux ...interface{}) Value {
	go func() {
		name := aux[0].(string)
		file, err := os.Open(name)
		if err != nil {
			log.Printf("Problem opening file %q (%v)", name, err)
			panic("open file")
		}
		eye.Show(DefaultValve, file)
	}()
	return nil
}