// SpeechEnd is an event fired when speech recognised by the speech recognition
// service has stopped being detected.
//
// https://developer.mozilla.org/docs/Web/Events/speechend
497788
func SpeechEnd(listener func(*vecty.Event)) *vecty.EventListener {
	return &vecty.EventListener{Name: "speechend", Listener: listener}
}
749274
func (handler *Handler) serialSend(msg *pb.ChaincodeMessage) error {
	handler.serialLock.Lock()
	defer handler.serialLock.Unlock()

	err := handler.ChatStream.Send(msg)

	return err
}
604534
func (this *Runtime) start_announcer() {
	switch {
	case this.zk == nil, this.Namespace == nil:
		glog.Infoln("No zk or no announcement namespace defined.  Not announcing.")
		go func() {
			for {
				if a := <-this.announce; a == stop_announce {
					glog.Infoln("Stopping announcer")
					break
				} else {
					glog.Infoln("Skipping announcement:", a)
				}
			}
		}()
	default:
		go func() {
			for {
				if a := <-this.announce; a == stop_announce {
					glog.Infoln("Stopping announcer")
					break
				} else {
					key := a.Key
					if len(key) == 0 {
						key = fmt.Sprintf("%d", time.Now().Unix())
					}

					path := this.Namespace.Sub(key)
					var err error
					switch a.Value.(type) {
					case []byte:
						err = zk.CreateOrSetBytes(this.zk, path, a.Value.([]byte), a.Ephemeral)
					case string:
						err = zk.CreateOrSetString(this.zk, path, a.Value.(string), a.Ephemeral)
					default:
						if value, err := json.Marshal(a.Value); err == nil {
							err = zk.CreateOrSetBytes(this.zk, path, value, a.Ephemeral)
						}
					}

					if err != nil {
						this.Log("Cannot annouce to", path.Path(), "Err=", err.Error())
					} else {
						this.Log("ANNOUNCE", path.Path())
					}
				}
			}
		}()
	}
}
642837
func (builder *SSMLTextBuilder) AppendPlainSpeech(text string) *SSMLTextBuilder {

	builder.buffer.WriteString(text)

	return builder
}
990158
func (pipeline *Pipeline) Stop() {
	endpoints := pipeline.source.Endpoints()
	pipeline.source.Stop()

	// pipeline has stopped, emit one last round of metrics and send the exit event
	close(pipeline.done)
	pipeline.emitMetrics()
	pipeline.source.pipe.Event <- events.NewExitEvent(time.Now().UnixNano(), pipeline.version, endpoints)
	pipeline.emitter.Stop()
}
1197585
func TransitionEnd(listener func(*vecty.Event)) *vecty.EventListener {
	return &vecty.EventListener{Name: "transitionend", Listener: listener}
}
834977
func (c *Callbacks) OnCDOTAUserMsg_TE_UnitAnimationEnd(fn func(*dota.CDOTAUserMsg_TE_UnitAnimationEnd) error) {
	c.onCDOTAUserMsg_TE_UnitAnimationEnd = append(c.onCDOTAUserMsg_TE_UnitAnimationEnd, fn)
}
8428
func (t *TokenEndpointHandlers) Append(h TokenEndpointHandler) {
	for _, this := range *t {
		if reflect.TypeOf(this) == reflect.TypeOf(h) {
			return
		}
	}

	*t = append(*t, h)
}
1206612
func yaml_parser_parse_document_end(parser *yaml_parser_t, event *yaml_event_t) bool {
	token := peek_token(parser)
	if token == nil {
		return false
	}

	start_mark := token.start_mark
	end_mark := token.start_mark

	implicit := true
	if token.typ == yaml_DOCUMENT_END_TOKEN {
		end_mark = token.end_mark
		skip_token(parser)
		implicit = false
	}

	parser.tag_directives = parser.tag_directives[:0]

	parser.state = yaml_PARSE_DOCUMENT_START_STATE
	*event = yaml_event_t{
		typ:        yaml_DOCUMENT_END_EVENT,
		start_mark: start_mark,
		end_mark:   end_mark,
		implicit:   implicit,
	}
	return true
}
670584
func (jst *Tracer) CaptureEnd(output []byte, gasUsed uint64, t time.Duration, err error) error {
	jst.ctx["output"] = output
	jst.ctx["gasUsed"] = gasUsed
	jst.ctx["time"] = t.String()

	if err != nil {
		jst.ctx["error"] = err.Error()
	}
	return nil
}
169736
func (parser *TransitionParser) Stop(stateName string, token string, flags ParserFlag, callback ParsedFunc) {
	parser.AddTransition(stateName, NewTransition(ParserStateStop, flags, callback), token)
}
1134006
func AudioStart(listener func(*vecty.Event)) *vecty.EventListener {
	return &vecty.EventListener{Name: "audiostart", Listener: listener}
}
797425
func stringEnd(data []byte) (int, bool) {
	escaped := false
	for i, c := range data {
		if c == '"' {
			if !escaped {
				return i + 1, false
			} else {
				j := i - 1
				for {
					if j < 0 || data[j] != '\\' {
						return i + 1, true // even number of backslashes
					}
					j--
					if j < 0 || data[j] != '\\' {
						break // odd number of backslashes
					}
					j--

				}
			}
		} else if c == '\\' {
			escaped = true
		}
	}

	return -1, escaped
}
1249564
func (fp *formatParser) staticEnd() error {
	fp.addStatic([]byte(fp.format[fp.start:]))
	fp.commitStatic()
	return nil
}
451449
func (b *buffer) end() (lines int, err error) {
	if b.pos == b.size {
		return
	}

	lastLine, lastColumn := b.pos2xy(b.size)

	for ln, _ := b.pos2xy(b.pos); ln < lastLine; ln++ {
		if _, err = term.Output.Write(CursorDown); err != nil {
			return 0, outputError(err.Error())
		}
	}

	if _, err = fmt.Fprintf(term.Output, "\r\033[%dC", lastColumn); err != nil {
		return 0, outputError(err.Error())
	}
	b.pos = b.size
	return lastLine, nil
}
95482
func CompositionEnd(listener func(*vecty.Event)) *vecty.EventListener {
	return &vecty.EventListener{Name: "compositionend", Listener: listener}
}
1341080
func Abort(listener func(*vecty.Event)) *vecty.EventListener {
	return &vecty.EventListener{Name: "abort", Listener: listener}
}