atoms.go RawHistoryFolder

1package xturbo
2
3import "time"
4
5// InternAtoms interns every name in one pipelined batch and blocks for one
6// round trip (Sync), writing the atom of names[i] into dst[i] (0 for a name
7// that does not exist when onlyIfExists is set). len(dst) must equal
8// len(names) and every name be at most 65535 bytes (ErrBadLength, nothing
9// sent, the connection unaffected). The first X error on one of these
10// requests is returned as *XError, its Args[0] the index of the name; the
11// other atoms are still filled. Packets read meanwhile go to the last Handler
12// given to Dispatch. Like Sync it gives up after 5 s (os.ErrDeadlineExceeded).
13// Meant for startup; it must not be called from a Handler callback.
14func (c *Conn) InternAtoms(names []string, onlyIfExists bool, dst []uint32) error {
15	if len(names) != len(dst) {
16		return ErrBadLength
17	}
18	for _, name := range names {
19		if len(name) > 0xffff {
20			return ErrBadLength // a caller bug: fail before queuing anything
21		}
22	}
23	if c.dispatching {
24		return errReentrantDispatch
25	}
26	if c.fd < 0 {
27		return ErrClosed
28	}
29	clear(dst)
30	c.atoms = dst
31	defer func() { c.atoms = nil }()
32	deadline := time.Now().Add(c.timeout)
33	c.syncFailed = false
34	for i, name := range names {
35		if err := c.waitSlot(deadline); err != nil {
36			return err
37		}
38		seq := encodeInternAtom(c.buf, onlyIfExists, name)
39		if seq == 0 {
40			return c.buf.Err()
41		}
42		if err := c.expect(seq, kindInternAtom, [4]uint32{uint32(i)}); err != nil {
43			return err
44		}
45	}
46	if err := c.waitUntil(c.h, deadline); err != nil {
47		return err
48	}
49	if c.syncFailed {
50		e := c.syncErr
51		return &e
52	}
53	return nil
54}