// AcceptInclusion implements Visitor
193209
func (t *precompilationTypeChecker) AcceptInclusion(v tree.Inclusion) {
	if v.Positive {
		t.result = fmt.Errorf("no inclusion expressions allowed - this is probably a programmer error: %s", tree.ExpressionString(v))
	} else {
		t.result = fmt.Errorf("no negative inclusion expressions allowed - this is probably a programmer error: %s", tree.ExpressionString(v))
	}
}
772051
func Accept(ctypes ...string) http.HandlerFunc {
	return func(w http.ResponseWriter, r *http.Request) {
		a := r.Header.Get("Accept")
		for _, t := range ctypes {
			if accepts(a, t) > 0 {
				return
			}
		}
		w.WriteHeader(http.StatusNotAcceptable)
	}
}
362043
func (l *ReaderLexer) AcceptRun(valid string) bool {
	guard := Mark("AcceptRun")
	defer guard()
	return AcceptRun(l, valid)
}
1053031
func (s *booleanCompilerVisitor) AcceptNumericLiteral(v tree.NumericLiteral) {
	s.err = errors.New("a numeric literal was found in a boolean expression - this is likely a programmer error")
}
976151
func (s *acceptFirst) Accept(from interface{}) bool {
	if _, ok := s.handled[from]; ok {
		return false
	}
	s.handled[from] = struct{}{}
	return true
}
783784
func AcceptRun(l Lexer, valid string) bool {
	guard := Mark("lex.AcceptRun %q", valid)
	defer guard()
	return AcceptRunFunc(l, func(r rune) bool {
		return strings.IndexRune(valid, r) >= 0
	})
}
1054875
func (t *typeChecker) AcceptInclusion(v tree.Inclusion) {
	if !t.expectBoolean {
		t.result = fmt.Errorf("expected numeric expression but found: %s", tree.ExpressionString(v))
		return
	}

	res := typeCheckExpectingNumeric(v.Left)
	for _, r := range v.Rights {
		res2 := typeCheckExpectingNumeric(r)
		if res == nil {
			res = res2
		}
	}

	if res != nil {
		t.result = res
	}

}
1086132
func (sv *EvaluatorVisitor) AcceptBinaryNegation(v BinaryNegation) {
	v.Operand.Accept(sv)
	sv.pushNumeric(^sv.popNumeric())
}
418502
func (f *mspFilter) Accept(peer fab.Peer) bool {
	return peer.MSPID() == f.mspID
}
649424
func acceptPeering(peer *Peer, messageId uint64) error {
	message := Message{}
	err := message.
		setCommand(CMD_PR_ACK).
		setContact(Me()).
		send(peer)
	if err != nil {
		Logln("Peering Acceptation Failed", err)
		return err
	}
	peer.SetState(STATE_PR_WAIT)
	peer.SetReason("waiting for re-routing")
	Logln("Peering acceptance sent.")
	return nil
}
312600
func (s *numericCompilerVisitor) AcceptNegation(v tree.Negation) {
	s.err = errors.New("a boolean negation was found in a numeric expression - this is likely a programmer error")
}
1277777
func (l TCPKeepAliveListener) Accept() (c net.Conn, err error) {
	tc, err := l.AcceptTCP()
	if err != nil {
		return
	}
	tc.SetKeepAlive(true)
	tc.SetKeepAlivePeriod(keepAlivePeriod)
	return tc, nil
}
301346
func (s *EmptyTransformer) AcceptInclusion(v Inclusion) {
	result := make([]Numeric, len(v.Rights))
	for ix, v2 := range v.Rights {
		result[ix] = s.Transform(v2)
	}
	s.Result = Inclusion{
		Positive: v.Positive,
		Left:     s.Transform(v.Left),
		Rights:   result}
}
1032562
func (n *WhenClause) Accept(v Visitor) (Node, bool) {
	newNode, skipChildren := v.Enter(n)
	if skipChildren {
		return v.Leave(newNode)
	}

	n = newNode.(*WhenClause)
	node, ok := n.Expr.Accept(v)
	if !ok {
		return n, false
	}
	n.Expr = node.(ExprNode)

	node, ok = n.Result.Accept(v)
	if !ok {
		return n, false
	}
	n.Result = node.(ExprNode)
	return v.Leave(n)
}
1232470
func (s *booleanCompilerVisitor) AcceptNegation(v tree.Negation) {
	s.err = compileBoolean(s.ctx, v.Operand, false, s.jf, s.jt)
}
896956
func (aa Acceptors) Accept(from interface{}) bool {
	for _, a := range aa {
		if !a.Accept(from) {
			return false
		}
	}
	return true
}
1074060
func (f FilterFunc) Accept(o *mesos.Offer) bool {
	if f == nil {
		return true
	}
	return f(o)
}