// String renders node as a string using fmt. Acquires a read lock to ensure the
// reflective dump of dependents doesn't race with any concurrent writes.
8517
func (n *node) String() string {
	n.dependentsLock.RLock()
	defer n.dependentsLock.RUnlock()
	return fmt.Sprintf("%#v", n)
}
907803
func (r *Reference) String() string {
	var buf bytes.Buffer
	fmt.Fprintf(&buf, "@SQ\tSN:%s\tLN:%d", r.name, r.lRef)
	if r.md5 != "" {
		fmt.Fprintf(&buf, "\tM5:%x", []byte(r.md5))
	}
	if r.assemID != "" {
		fmt.Fprintf(&buf, "\tAS:%s", r.assemID)
	}
	if r.species != "" {
		fmt.Fprintf(&buf, "\tSP:%s", r.species)
	}
	if r.uri != nil {
		fmt.Fprintf(&buf, "\tUR:%s", r.uri)
	}
	for _, tp := range r.otherTags {
		fmt.Fprintf(&buf, "\t%s:%s", tp.tag, tp.value)
	}
	return buf.String()
}
790084
func (og *OpenGraph) String() string {
	data, err := og.ToJSON()

	if err != nil {
		return err.Error()
	}

	return string(data[:])
}
988711
func (c *ConstructPredicateObjectPair) String() string {
	b := bytes.NewBufferString("")

	// Predicate section.
	predicate := false
	if c.P != nil {
		b.WriteString(" ")
		b.WriteString(c.P.String())
		predicate = true
	}
	if c.PBinding != "" {
		b.WriteString(" ")
		b.WriteString(c.PBinding)
	}
	if c.PID != "" {
		b.WriteString(" \"")
		b.WriteString(c.PID)
		b.WriteString("\"")
	}
	if !predicate {
		if !c.PTemporal {
			b.WriteString("@[]")
		} else {
			b.WriteString("@[")
			if c.PAnchorBinding != "" {
				b.WriteString(c.PAnchorBinding)
			}
		}
		b.WriteString("]")
	}

	// Object section.
	// Node portion.
	object := false
	if c.O != nil {
		b.WriteString(" ")
		b.WriteString(c.O.String())
		object = true
	} else {
		b.WriteString(" ")
		b.WriteString(c.OBinding)
		object = true
	}
	// Predicate portion.
	if !object {
		if c.OBinding != "" {
			b.WriteString(" ")
			b.WriteString(c.OBinding)
		}
		if c.OID != "" {
			b.WriteString(" \"")
			b.WriteString(c.OID)
			b.WriteString("\"")
		}
		if !c.OTemporal {
			b.WriteString("[]")
		} else {
			b.WriteString("[")
			if c.OAnchorBinding != "" {
				b.WriteString(c.OAnchorBinding)
			}
			b.WriteString("]")
		}
	}
	return b.String()
}
312470
func (o Store) String() string {
	return fmt.Sprintf("Timestamp[%s]-Sequence[%d]-Node[%x]", o.Timestamp, o.Sequence, o.Node)
}
1209271
func (t *Transporter) String() string {
	out := "Transporter:\n"
	out += fmt.Sprintf("%s", t.sourceNode.String())
	return out
}
1034057
func (l *LabeledExpr) String() string {
	return fmt.Sprintf("%s: %T{Label: %v, Expr: %v}", l.p, l, l.Label, l.Expr)
}
326930
func (node *Expression) String() string {
	return fmt.Sprintf("Expr{Path:%s, Pos:%d}", node.Path, node.Loc.Pos)
}
1113772
func (c *component) String() string {
	var str string

	for _, fn := range c.fns {
		str += fn.String()
	}
	return str
}
966563
func (mc *MembershipChanges) String() string {
	return fmt.Sprintf("add %d node(s), remove %d node(s)", len(mc.AddedNodes), len(mc.RemovedNodes))
}
309117
func (t *Tree) String() string {
	t.mutex.RLock()
	defer t.mutex.RUnlock()

	return fmt.Sprintf("topic.Tree:%s", t.root.string(0))
}
715969
func (r Rope) String() string {
	if r.node == nil {
		return ""
	}
	// In the trivial case, avoid allocation
	if l, ok := r.node.(leaf); ok {
		return string(l)
	}
	// The rope is not contiguous.
	return string(r.Bytes())
}
17196
func (s ShapeTag) String() string {
	return fmt.Sprintf(`%s:"%s"`, s.Key, s.Val)
}
1054623
func (c *dependency) String() string {
	s := c.name

	switch {
	case DepFlagLesserOrEqual == (c.flags & DepFlagLesserOrEqual):
		s = fmt.Sprintf("%s <=", s)

	case DepFlagLesser == (c.flags & DepFlagLesser):
		s = fmt.Sprintf("%s <", s)

	case DepFlagGreaterOrEqual == (c.flags & DepFlagGreaterOrEqual):
		s = fmt.Sprintf("%s >=", s)

	case DepFlagGreater == (c.flags & DepFlagGreater):
		s = fmt.Sprintf("%s >", s)

	case DepFlagEqual == (c.flags & DepFlagEqual):
		s = fmt.Sprintf("%s =", s)
	}

	if c.version != "" {
		s = fmt.Sprintf("%s %s", s, c.version)
	}

	if c.release != "" {
		s = fmt.Sprintf("%s.%s", s, c.release)
	}

	return s
}
36700
func (t *Tree) String() string {
	var result bytes.Buffer
	path := strings.Join(t.path, ", ")
	if path != "" {
		path = fmt.Sprintf(" (path: %s)", path)
	}
	result.WriteString(t.Name() + path + "\n")

	cs := t.Children()
	if cs == nil {
		result.WriteString("  not loaded")
	} else {
		// Go through each child and get its string value, then indent it
		// by two.
		for _, c := range cs {
			r := strings.NewReader(c.String())
			scanner := bufio.NewScanner(r)
			for scanner.Scan() {
				result.WriteString("  ")
				result.WriteString(scanner.Text())
				result.WriteString("\n")
			}
		}
	}

	return result.String()
}
1050075
func (b *ByteBuffer) String() string {
	b.Lock()
	defer b.Unlock()
	return b.b.String()
}
960711
func (t *Trace) String() string {
	return fmt.Sprintf("addr=%v, reqHeaders=%v, respHeaders=%v", t.Addr, t.ReqHeaders, t.RespHeaders)
}