// SetEq sets the Eq field's value.
342388
func (s *NumberFilter) SetEq(v float64) *NumberFilter {
	s.Eq = &v
	return s
}
907227
func (s *GetShardIteratorInput) SetSequenceNumber(v string) *GetShardIteratorInput {
	s.SequenceNumber = &v
	return s
}
855310
func (f Filter) Eq(val interface{}) Filter {
	f.Op = ""
	f.Val = val
	return f
}
463993
func (s *Server) SetQueue(queue data.Queue) error {
	s.queue = queue
	return nil
}
554491
func (s *QueryObjectsInput) SetQuery(v *Query) *QueryObjectsInput {
	s.Query = v
	return s
}
904463
func (i Interval) Eq(o Interval) bool {
	return i.Semitones() == o.Semitones()
}
205635
func (s *PutRecordsResultEntry) SetSequenceNumber(v string) *PutRecordsResultEntry {
	s.SequenceNumber = &v
	return s
}
52488
func NewSeq(s []byte) Seq {
	return Seq{
		Length: len(s),
		Seq:    contract(s),
	}
}
661035
func (s *PutLogEventsInput) SetSequenceToken(v string) *PutLogEventsInput {
	s.SequenceToken = &v
	return s
}
1293636
func eq(m interface{}, value interface{}) (hpredicate, error) {
	switch mapper := m.(type) {
	case toInt:
		return intEQ(mapper, value)
	case toFloat64:
		return float64EQ(mapper, value)
	}
	return nil, fmt.Errorf("eq: unsupported argument: %T", m)
}
471037
func shapeEq(a, b []int) bool {
	if isScalar(a) && isScalar(b) {
		return true
	}

	if len(a) != len(b) {
		return false
	}

	for i, v := range a {
		if b[i] != v {
			return false
		}
	}
	return true
}
1116050
func (s *Condition) SetEq(v []*string) *Condition {
	s.Eq = v
	return s
}
23688
func (srv *Server) serveReq(c *conn, req *Request, h Handler) {
	state := StateActive
	if req.Header.Type == TypeHello {
		state = StateHandshake
	}

	srv.setState(c, state)
	// Define a response version from the request version, so
	// it will potentially reduce the amount of additional
	// header configurations.
	header := Header{
		Version:     req.Header.Version,
		Transaction: req.Header.Transaction,
	}

	// Construct a new response instance with some default
	// attributes and execute respective handler for it.
	resp := &response{conn: c, header: header}
	h.Serve(resp, req)

	// Write the buffer content to the connection, so the
	// pending messages will be written to the wire.
	c.Flush()

	// Update the state as the handler just processed the
	// received request and now the server will wait for a
	// new one.
	srv.setState(c, StateIdle)
}
1130521
func (s *QueryExecution) SetQuery(v string) *QueryExecution {
	s.Query = &v
	return s
}
690352
func (s *QueueConfigurationDeprecated) SetQueue(v string) *QueueConfigurationDeprecated {
	s.Queue = &v
	return s
}
180022
func (i *IntValue) Eq(other *IntValue) bool {
	if i == nil {
		return other == nil
	}

	if other == nil {
		return i == nil
	}

	return *i == *other
}
1021273
func (s *PutRecordOutput) SetSequenceNumber(v string) *PutRecordOutput {
	s.SequenceNumber = &v
	return s
}