_id stringlengths 2 7 | title stringlengths 1 118 | partition stringclasses 3
values | text stringlengths 52 85.5k | language stringclasses 1
value | meta_information dict |
|---|---|---|---|---|---|
q25300 | exitErr | train | func (s *Session) exitErr(err error) {
s.shutdownLock.Lock()
if s.shutdownErr == nil {
s.shutdownErr = err
}
s.shutdownLock.Unlock()
s.Close()
} | go | {
"resource": ""
} |
q25301 | GoAway | train | func (s *Session) GoAway() error {
return s.waitForSend(s.goAway(goAwayNormal), nil)
} | go | {
"resource": ""
} |
q25302 | goAway | train | func (s *Session) goAway(reason uint32) header {
atomic.SwapInt32(&s.localGoAway, 1)
hdr := header(make([]byte, headerSize))
hdr.encode(typeGoAway, 0, 0, reason)
return hdr
} | go | {
"resource": ""
} |
q25303 | Ping | train | func (s *Session) Ping() (time.Duration, error) {
// Get a channel for the ping
ch := make(chan struct{})
// Get a new ping id, mark as pending
s.pingLock.Lock()
id := s.pingID
s.pingID++
s.pings[id] = ch
s.pingLock.Unlock()
// Send the ping request
hdr := header(make([]byte, headerSize))
hdr.encode(typePi... | go | {
"resource": ""
} |
q25304 | keepalive | train | func (s *Session) keepalive() {
for {
select {
case <-time.After(s.config.KeepAliveInterval):
_, err := s.Ping()
if err != nil {
if err != ErrSessionShutdown {
s.logger.Printf("[ERR] yamux: keepalive failed: %v", err)
s.exitErr(ErrKeepAliveTimeout)
}
return
}
case <-s.shutdownCh:
... | go | {
"resource": ""
} |
q25305 | waitForSend | train | func (s *Session) waitForSend(hdr header, body io.Reader) error {
errCh := make(chan error, 1)
return s.waitForSendErr(hdr, body, errCh)
} | go | {
"resource": ""
} |
q25306 | waitForSendErr | train | func (s *Session) waitForSendErr(hdr header, body io.Reader, errCh chan error) error {
t := timerPool.Get()
timer := t.(*time.Timer)
timer.Reset(s.config.ConnectionWriteTimeout)
defer func() {
timer.Stop()
select {
case <-timer.C:
default:
}
timerPool.Put(t)
}()
ready := sendReady{Hdr: hdr, Body: bod... | go | {
"resource": ""
} |
q25307 | sendNoWait | train | func (s *Session) sendNoWait(hdr header) error {
t := timerPool.Get()
timer := t.(*time.Timer)
timer.Reset(s.config.ConnectionWriteTimeout)
defer func() {
timer.Stop()
select {
case <-timer.C:
default:
}
timerPool.Put(t)
}()
select {
case s.sendCh <- sendReady{Hdr: hdr}:
return nil
case <-s.shutd... | go | {
"resource": ""
} |
q25308 | send | train | func (s *Session) send() {
for {
select {
case ready := <-s.sendCh:
// Send a header if ready
if ready.Hdr != nil {
sent := 0
for sent < len(ready.Hdr) {
n, err := s.conn.Write(ready.Hdr[sent:])
if err != nil {
s.logger.Printf("[ERR] yamux: Failed to write header: %v", err)
asyn... | go | {
"resource": ""
} |
q25309 | recv | train | func (s *Session) recv() {
if err := s.recvLoop(); err != nil {
s.exitErr(err)
}
} | go | {
"resource": ""
} |
q25310 | recvLoop | train | func (s *Session) recvLoop() error {
defer close(s.recvDoneCh)
hdr := header(make([]byte, headerSize))
for {
// Read the header
if _, err := io.ReadFull(s.bufRead, hdr); err != nil {
if err != io.EOF && !strings.Contains(err.Error(), "closed") && !strings.Contains(err.Error(), "reset by peer") {
s.logger.... | go | {
"resource": ""
} |
q25311 | handleStreamMessage | train | func (s *Session) handleStreamMessage(hdr header) error {
// Check for a new stream creation
id := hdr.StreamID()
flags := hdr.Flags()
if flags&flagSYN == flagSYN {
if err := s.incomingStream(id); err != nil {
return err
}
}
// Get the stream
s.streamLock.Lock()
stream := s.streams[id]
s.streamLock.Unl... | go | {
"resource": ""
} |
q25312 | handlePing | train | func (s *Session) handlePing(hdr header) error {
flags := hdr.Flags()
pingID := hdr.Length()
// Check if this is a query, respond back in a separate context so we
// don't interfere with the receiving thread blocking for the write.
if flags&flagSYN == flagSYN {
go func() {
hdr := header(make([]byte, headerSi... | go | {
"resource": ""
} |
q25313 | handleGoAway | train | func (s *Session) handleGoAway(hdr header) error {
code := hdr.Length()
switch code {
case goAwayNormal:
atomic.SwapInt32(&s.remoteGoAway, 1)
case goAwayProtoErr:
s.logger.Printf("[ERR] yamux: received protocol error go away")
return fmt.Errorf("yamux protocol error")
case goAwayInternalErr:
s.logger.Print... | go | {
"resource": ""
} |
q25314 | incomingStream | train | func (s *Session) incomingStream(id uint32) error {
// Reject immediately if we are doing a go away
if atomic.LoadInt32(&s.localGoAway) == 1 {
hdr := header(make([]byte, headerSize))
hdr.encode(typeWindowUpdate, flagRST, id, 0)
return s.sendNoWait(hdr)
}
// Allocate a new stream
stream := newStream(s, id, s... | go | {
"resource": ""
} |
q25315 | closeStream | train | func (s *Session) closeStream(id uint32) {
s.streamLock.Lock()
if _, ok := s.inflight[id]; ok {
select {
case <-s.synCh:
default:
s.logger.Printf("[ERR] yamux: SYN tracking out of sync")
}
}
delete(s.streams, id)
s.streamLock.Unlock()
} | go | {
"resource": ""
} |
q25316 | InitializeGraphiteCollector | train | func InitializeGraphiteCollector(config *GraphiteCollectorConfig) {
go metrics.Graphite(metrics.DefaultRegistry, config.TickInterval, config.Prefix, config.GraphiteAddr)
} | go | {
"resource": ""
} |
q25317 | GetCircuit | train | func GetCircuit(name string) (*CircuitBreaker, bool, error) {
circuitBreakersMutex.RLock()
_, ok := circuitBreakers[name]
if !ok {
circuitBreakersMutex.RUnlock()
circuitBreakersMutex.Lock()
defer circuitBreakersMutex.Unlock()
// because we released the rlock before we obtained the exclusive lock,
// we nee... | go | {
"resource": ""
} |
q25318 | Flush | train | func Flush() {
circuitBreakersMutex.Lock()
defer circuitBreakersMutex.Unlock()
for name, cb := range circuitBreakers {
cb.metrics.Reset()
cb.executorPool.Metrics.Reset()
delete(circuitBreakers, name)
}
} | go | {
"resource": ""
} |
q25319 | newCircuitBreaker | train | func newCircuitBreaker(name string) *CircuitBreaker {
c := &CircuitBreaker{}
c.Name = name
c.metrics = newMetricExchange(name)
c.executorPool = newExecutorPool(name)
c.mutex = &sync.RWMutex{}
return c
} | go | {
"resource": ""
} |
q25320 | toggleForceOpen | train | func (circuit *CircuitBreaker) toggleForceOpen(toggle bool) error {
circuit, _, err := GetCircuit(circuit.Name)
if err != nil {
return err
}
circuit.forceOpen = toggle
return nil
} | go | {
"resource": ""
} |
q25321 | IsOpen | train | func (circuit *CircuitBreaker) IsOpen() bool {
circuit.mutex.RLock()
o := circuit.forceOpen || circuit.open
circuit.mutex.RUnlock()
if o {
return true
}
if uint64(circuit.metrics.Requests().Sum(time.Now())) < getSettings(circuit.Name).RequestVolumeThreshold {
return false
}
if !circuit.metrics.IsHealthy(... | go | {
"resource": ""
} |
q25322 | ReportEvent | train | func (circuit *CircuitBreaker) ReportEvent(eventTypes []string, start time.Time, runDuration time.Duration) error {
if len(eventTypes) == 0 {
return fmt.Errorf("no event types sent for metrics")
}
circuit.mutex.RLock()
o := circuit.open
circuit.mutex.RUnlock()
if eventTypes[0] == "success" && o {
circuit.set... | go | {
"resource": ""
} |
q25323 | NewNumber | train | func NewNumber() *Number {
r := &Number{
Buckets: make(map[int64]*numberBucket),
Mutex: &sync.RWMutex{},
}
return r
} | go | {
"resource": ""
} |
q25324 | Increment | train | func (r *Number) Increment(i float64) {
if i == 0 {
return
}
r.Mutex.Lock()
defer r.Mutex.Unlock()
b := r.getCurrentBucket()
b.Value += i
r.removeOldBuckets()
} | go | {
"resource": ""
} |
q25325 | UpdateMax | train | func (r *Number) UpdateMax(n float64) {
r.Mutex.Lock()
defer r.Mutex.Unlock()
b := r.getCurrentBucket()
if n > b.Value {
b.Value = n
}
r.removeOldBuckets()
} | go | {
"resource": ""
} |
q25326 | Sum | train | func (r *Number) Sum(now time.Time) float64 {
sum := float64(0)
r.Mutex.RLock()
defer r.Mutex.RUnlock()
for timestamp, bucket := range r.Buckets {
// TODO: configurable rolling window
if timestamp >= now.Unix()-10 {
sum += bucket.Value
}
}
return sum
} | go | {
"resource": ""
} |
q25327 | Max | train | func (r *Number) Max(now time.Time) float64 {
var max float64
r.Mutex.RLock()
defer r.Mutex.RUnlock()
for timestamp, bucket := range r.Buckets {
// TODO: configurable rolling window
if timestamp >= now.Unix()-10 {
if bucket.Value > max {
max = bucket.Value
}
}
}
return max
} | go | {
"resource": ""
} |
q25328 | Go | train | func Go(name string, run runFunc, fallback fallbackFunc) chan error {
runC := func(ctx context.Context) error {
return run()
}
var fallbackC fallbackFuncC
if fallback != nil {
fallbackC = func(ctx context.Context, err error) error {
return fallback(err)
}
}
return GoC(context.Background(), name, runC, fa... | go | {
"resource": ""
} |
q25329 | DoC | train | func DoC(ctx context.Context, name string, run runFuncC, fallback fallbackFuncC) error {
done := make(chan struct{}, 1)
r := func(ctx context.Context) error {
err := run(ctx)
if err != nil {
return err
}
done <- struct{}{}
return nil
}
f := func(ctx context.Context, e error) error {
err := fallbac... | go | {
"resource": ""
} |
q25330 | errorWithFallback | train | func (c *command) errorWithFallback(ctx context.Context, err error) {
eventType := "failure"
if err == ErrCircuitOpen {
eventType = "short-circuit"
} else if err == ErrMaxConcurrency {
eventType = "rejected"
} else if err == ErrTimeout {
eventType = "timeout"
} else if err == context.Canceled {
eventType =... | go | {
"resource": ""
} |
q25331 | Configure | train | func Configure(cmds map[string]CommandConfig) {
for k, v := range cmds {
ConfigureCommand(k, v)
}
} | go | {
"resource": ""
} |
q25332 | ConfigureCommand | train | func ConfigureCommand(name string, config CommandConfig) {
settingsMutex.Lock()
defer settingsMutex.Unlock()
timeout := DefaultTimeout
if config.Timeout != 0 {
timeout = config.Timeout
}
max := DefaultMaxConcurrent
if config.MaxConcurrentRequests != 0 {
max = config.MaxConcurrentRequests
}
volume := Def... | go | {
"resource": ""
} |
q25333 | NumRequests | train | func (d *DefaultMetricCollector) NumRequests() *rolling.Number {
d.mutex.RLock()
defer d.mutex.RUnlock()
return d.numRequests
} | go | {
"resource": ""
} |
q25334 | Errors | train | func (d *DefaultMetricCollector) Errors() *rolling.Number {
d.mutex.RLock()
defer d.mutex.RUnlock()
return d.errors
} | go | {
"resource": ""
} |
q25335 | Successes | train | func (d *DefaultMetricCollector) Successes() *rolling.Number {
d.mutex.RLock()
defer d.mutex.RUnlock()
return d.successes
} | go | {
"resource": ""
} |
q25336 | Failures | train | func (d *DefaultMetricCollector) Failures() *rolling.Number {
d.mutex.RLock()
defer d.mutex.RUnlock()
return d.failures
} | go | {
"resource": ""
} |
q25337 | Rejects | train | func (d *DefaultMetricCollector) Rejects() *rolling.Number {
d.mutex.RLock()
defer d.mutex.RUnlock()
return d.rejects
} | go | {
"resource": ""
} |
q25338 | ShortCircuits | train | func (d *DefaultMetricCollector) ShortCircuits() *rolling.Number {
d.mutex.RLock()
defer d.mutex.RUnlock()
return d.shortCircuits
} | go | {
"resource": ""
} |
q25339 | Timeouts | train | func (d *DefaultMetricCollector) Timeouts() *rolling.Number {
d.mutex.RLock()
defer d.mutex.RUnlock()
return d.timeouts
} | go | {
"resource": ""
} |
q25340 | FallbackSuccesses | train | func (d *DefaultMetricCollector) FallbackSuccesses() *rolling.Number {
d.mutex.RLock()
defer d.mutex.RUnlock()
return d.fallbackSuccesses
} | go | {
"resource": ""
} |
q25341 | FallbackFailures | train | func (d *DefaultMetricCollector) FallbackFailures() *rolling.Number {
d.mutex.RLock()
defer d.mutex.RUnlock()
return d.fallbackFailures
} | go | {
"resource": ""
} |
q25342 | TotalDuration | train | func (d *DefaultMetricCollector) TotalDuration() *rolling.Timing {
d.mutex.RLock()
defer d.mutex.RUnlock()
return d.totalDuration
} | go | {
"resource": ""
} |
q25343 | RunDuration | train | func (d *DefaultMetricCollector) RunDuration() *rolling.Timing {
d.mutex.RLock()
defer d.mutex.RUnlock()
return d.runDuration
} | go | {
"resource": ""
} |
q25344 | Reset | train | func (d *DefaultMetricCollector) Reset() {
d.mutex.Lock()
defer d.mutex.Unlock()
d.numRequests = rolling.NewNumber()
d.errors = rolling.NewNumber()
d.successes = rolling.NewNumber()
d.rejects = rolling.NewNumber()
d.shortCircuits = rolling.NewNumber()
d.failures = rolling.NewNumber()
d.timeouts = rolling.NewN... | go | {
"resource": ""
} |
q25345 | NewTiming | train | func NewTiming() *Timing {
r := &Timing{
Buckets: make(map[int64]*timingBucket),
Mutex: &sync.RWMutex{},
}
return r
} | go | {
"resource": ""
} |
q25346 | SortedDurations | train | func (r *Timing) SortedDurations() []time.Duration {
r.Mutex.RLock()
t := r.LastCachedTime
r.Mutex.RUnlock()
if t+time.Duration(1*time.Second).Nanoseconds() > time.Now().UnixNano() {
// don't recalculate if current cache is still fresh
return r.CachedSortedDurations
}
var durations byDuration
now := time.N... | go | {
"resource": ""
} |
q25347 | Add | train | func (r *Timing) Add(duration time.Duration) {
b := r.getCurrentBucket()
r.Mutex.Lock()
defer r.Mutex.Unlock()
b.Durations = append(b.Durations, duration)
r.removeOldBuckets()
} | go | {
"resource": ""
} |
q25348 | Percentile | train | func (r *Timing) Percentile(p float64) uint32 {
sortedDurations := r.SortedDurations()
length := len(sortedDurations)
if length <= 0 {
return 0
}
pos := r.ordinal(len(sortedDurations), p) - 1
return uint32(sortedDurations[pos].Nanoseconds() / 1000000)
} | go | {
"resource": ""
} |
q25349 | Mean | train | func (r *Timing) Mean() uint32 {
sortedDurations := r.SortedDurations()
var sum time.Duration
for _, d := range sortedDurations {
sum += d
}
length := int64(len(sortedDurations))
if length == 0 {
return 0
}
return uint32(sum.Nanoseconds()/length) / 1000000
} | go | {
"resource": ""
} |
q25350 | DefaultCollector | train | func (m *metricExchange) DefaultCollector() *metricCollector.DefaultMetricCollector {
if len(m.metricCollectors) < 1 {
panic("No Metric Collectors Registered.")
}
collection, ok := m.metricCollectors[0].(*metricCollector.DefaultMetricCollector)
if !ok {
panic("Default metric collector is not registered correctl... | go | {
"resource": ""
} |
q25351 | Start | train | func (sh *StreamHandler) Start() {
sh.requests = make(map[*http.Request]chan []byte)
sh.done = make(chan struct{})
go sh.loop()
} | go | {
"resource": ""
} |
q25352 | InitializeMetricCollectors | train | func (m *metricCollectorRegistry) InitializeMetricCollectors(name string) []MetricCollector {
m.lock.RLock()
defer m.lock.RUnlock()
metrics := make([]MetricCollector, len(m.registry))
for i, metricCollectorInitializer := range m.registry {
metrics[i] = metricCollectorInitializer(name)
}
return metrics
} | go | {
"resource": ""
} |
q25353 | Register | train | func (m *metricCollectorRegistry) Register(initMetricCollector func(string) MetricCollector) {
m.lock.Lock()
defer m.lock.Unlock()
m.registry = append(m.registry, initMetricCollector)
} | go | {
"resource": ""
} |
q25354 | versionAtMost | train | func versionAtMost(version, max []int) (bool, error) {
if comp, err := versionCompare(version, max); err != nil {
return false, err
} else if comp == 1 {
return false, nil
}
return true, nil
} | go | {
"resource": ""
} |
q25355 | versionCompare | train | func versionCompare(v1, v2 []int) (int, error) {
if len(v1) != len(v2) {
return 0, errors.New("version length mismatch")
}
for idx, v2S := range v2 {
v1S := v1[idx]
if v1S > v2S {
return 1, nil
}
if v1S < v2S {
return -1, nil
}
}
return 0, nil
} | go | {
"resource": ""
} |
q25356 | parseVersion | train | func parseVersion(v string) []int {
version := make([]int, 3)
for idx, vStr := range strings.Split(v, ".") {
vS, err := strconv.Atoi(vStr)
if err != nil {
return nil
}
version[idx] = vS
}
return version
} | go | {
"resource": ""
} |
q25357 | New | train | func New(i Interface, c *Config) (Service, error) {
if len(c.Name) == 0 {
return nil, ErrNameFieldRequired
}
if system == nil {
return nil, ErrNoServiceSystemDetected
}
return system.New(i, c)
} | go | {
"resource": ""
} |
q25358 | bool | train | func (kv KeyValue) bool(name string, defaultValue bool) bool {
if v, found := kv[name]; found {
if castValue, is := v.(bool); is {
return castValue
}
}
return defaultValue
} | go | {
"resource": ""
} |
q25359 | Control | train | func Control(s Service, action string) error {
var err error
switch action {
case ControlAction[0]:
err = s.Start()
case ControlAction[1]:
err = s.Stop()
case ControlAction[2]:
err = s.Restart()
case ControlAction[3]:
err = s.Install()
case ControlAction[4]:
err = s.Uninstall()
default:
err = fmt.Er... | go | {
"resource": ""
} |
q25360 | Errorf | train | func (l WindowsLogger) Errorf(format string, a ...interface{}) error {
return l.send(l.ev.Error(3, fmt.Sprintf(format, a...)))
} | go | {
"resource": ""
} |
q25361 | Warningf | train | func (l WindowsLogger) Warningf(format string, a ...interface{}) error {
return l.send(l.ev.Warning(2, fmt.Sprintf(format, a...)))
} | go | {
"resource": ""
} |
q25362 | Infof | train | func (l WindowsLogger) Infof(format string, a ...interface{}) error {
return l.send(l.ev.Info(1, fmt.Sprintf(format, a...)))
} | go | {
"resource": ""
} |
q25363 | NError | train | func (l WindowsLogger) NError(eventID uint32, v ...interface{}) error {
return l.send(l.ev.Error(eventID, fmt.Sprint(v...)))
} | go | {
"resource": ""
} |
q25364 | NWarning | train | func (l WindowsLogger) NWarning(eventID uint32, v ...interface{}) error {
return l.send(l.ev.Warning(eventID, fmt.Sprint(v...)))
} | go | {
"resource": ""
} |
q25365 | NInfo | train | func (l WindowsLogger) NInfo(eventID uint32, v ...interface{}) error {
return l.send(l.ev.Info(eventID, fmt.Sprint(v...)))
} | go | {
"resource": ""
} |
q25366 | NErrorf | train | func (l WindowsLogger) NErrorf(eventID uint32, format string, a ...interface{}) error {
return l.send(l.ev.Error(eventID, fmt.Sprintf(format, a...)))
} | go | {
"resource": ""
} |
q25367 | NWarningf | train | func (l WindowsLogger) NWarningf(eventID uint32, format string, a ...interface{}) error {
return l.send(l.ev.Warning(eventID, fmt.Sprintf(format, a...)))
} | go | {
"resource": ""
} |
q25368 | NInfof | train | func (l WindowsLogger) NInfof(eventID uint32, format string, a ...interface{}) error {
return l.send(l.ev.Info(eventID, fmt.Sprintf(format, a...)))
} | go | {
"resource": ""
} |
q25369 | getStopTimeout | train | func getStopTimeout() time.Duration {
// For default and paths see https://support.microsoft.com/en-us/kb/146092
defaultTimeout := time.Millisecond * 20000
key, err := registry.OpenKey(registry.LOCAL_MACHINE, `SYSTEM\CurrentControlSet\Control`, registry.READ)
if err != nil {
return defaultTimeout
}
sv, _, err :... | go | {
"resource": ""
} |
q25370 | simpleEditor | train | func simpleEditor(v *View, key Key, ch rune, mod Modifier) {
switch {
case ch != 0 && mod == 0:
v.EditWrite(ch)
case key == KeySpace:
v.EditWrite(' ')
case key == KeyBackspace || key == KeyBackspace2:
v.EditDelete(true)
case key == KeyDelete:
v.EditDelete(false)
case key == KeyInsert:
v.Overwrite = !v.O... | go | {
"resource": ""
} |
q25371 | EditWrite | train | func (v *View) EditWrite(ch rune) {
v.writeRune(v.cx, v.cy, ch)
v.MoveCursor(1, 0, true)
} | go | {
"resource": ""
} |
q25372 | EditDelete | train | func (v *View) EditDelete(back bool) {
x, y := v.ox+v.cx, v.oy+v.cy
if y < 0 {
return
} else if y >= len(v.viewLines) {
v.MoveCursor(-1, 0, true)
return
}
maxX, _ := v.Size()
if back {
if x == 0 { // start of the line
if y < 1 {
return
}
var maxPrevWidth int
if v.Wrap {
maxPrevWidth ... | go | {
"resource": ""
} |
q25373 | EditNewLine | train | func (v *View) EditNewLine() {
v.breakLine(v.cx, v.cy)
v.ox = 0
v.cx = 0
v.MoveCursor(0, 1, true)
} | go | {
"resource": ""
} |
q25374 | mergeLines | train | func (v *View) mergeLines(y int) error {
v.tainted = true
_, y, err := v.realPosition(0, y)
if err != nil {
return err
}
if y < 0 || y >= len(v.lines) {
return errors.New("invalid point")
}
if y < len(v.lines)-1 { // otherwise we don't need to merge anything
v.lines[y] = append(v.lines[y], v.lines[y+1].... | go | {
"resource": ""
} |
q25375 | newKeybinding | train | func newKeybinding(viewname string, key Key, ch rune, mod Modifier, handler func(*Gui, *View) error) (kb *keybinding) {
kb = &keybinding{
viewName: viewname,
key: key,
ch: ch,
mod: mod,
handler: handler,
}
return kb
} | go | {
"resource": ""
} |
q25376 | matchKeypress | train | func (kb *keybinding) matchKeypress(key Key, ch rune, mod Modifier) bool {
return kb.key == key && kb.ch == ch && kb.mod == mod
} | go | {
"resource": ""
} |
q25377 | matchView | train | func (kb *keybinding) matchView(v *View) bool {
if kb.viewName == "" {
return true
}
return v != nil && kb.viewName == v.name
} | go | {
"resource": ""
} |
q25378 | String | train | func (l lineType) String() string {
str := ""
for _, c := range l {
str += string(c.chr)
}
return str
} | go | {
"resource": ""
} |
q25379 | newView | train | func newView(name string, x0, y0, x1, y1 int, mode OutputMode) *View {
v := &View{
name: name,
x0: x0,
y0: y0,
x1: x1,
y1: y1,
Frame: true,
Editor: DefaultEditor,
tainted: true,
ei: newEscapeInterpreter(mode),
}
return v
} | go | {
"resource": ""
} |
q25380 | Size | train | func (v *View) Size() (x, y int) {
return v.x1 - v.x0 - 1, v.y1 - v.y0 - 1
} | go | {
"resource": ""
} |
q25381 | setRune | train | func (v *View) setRune(x, y int, ch rune, fgColor, bgColor Attribute) error {
maxX, maxY := v.Size()
if x < 0 || x >= maxX || y < 0 || y >= maxY {
return errors.New("invalid point")
}
var (
ry, rcy int
err error
)
if v.Highlight {
_, ry, err = v.realPosition(x, y)
if err != nil {
return err
}
... | go | {
"resource": ""
} |
q25382 | SetCursor | train | func (v *View) SetCursor(x, y int) error {
maxX, maxY := v.Size()
if x < 0 || x >= maxX || y < 0 || y >= maxY {
return errors.New("invalid point")
}
v.cx = x
v.cy = y
return nil
} | go | {
"resource": ""
} |
q25383 | Cursor | train | func (v *View) Cursor() (x, y int) {
return v.cx, v.cy
} | go | {
"resource": ""
} |
q25384 | SetOrigin | train | func (v *View) SetOrigin(x, y int) error {
if x < 0 || y < 0 {
return errors.New("invalid point")
}
v.ox = x
v.oy = y
return nil
} | go | {
"resource": ""
} |
q25385 | Origin | train | func (v *View) Origin() (x, y int) {
return v.ox, v.oy
} | go | {
"resource": ""
} |
q25386 | Write | train | func (v *View) Write(p []byte) (n int, err error) {
v.tainted = true
for _, ch := range bytes.Runes(p) {
switch ch {
case '\n':
v.lines = append(v.lines, nil)
case '\r':
nl := len(v.lines)
if nl > 0 {
v.lines[nl-1] = nil
} else {
v.lines = make([][]cell, 1)
}
default:
cells := v.par... | go | {
"resource": ""
} |
q25387 | parseInput | train | func (v *View) parseInput(ch rune) []cell {
cells := []cell{}
isEscape, err := v.ei.parseOne(ch)
if err != nil {
for _, r := range v.ei.runes() {
c := cell{
fgColor: v.FgColor,
bgColor: v.BgColor,
chr: r,
}
cells = append(cells, c)
}
v.ei.reset()
} else {
if isEscape {
return ni... | go | {
"resource": ""
} |
q25388 | draw | train | func (v *View) draw() error {
maxX, maxY := v.Size()
if v.Wrap {
if maxX == 0 {
return errors.New("X size of the view cannot be 0")
}
v.ox = 0
}
if v.tainted {
v.viewLines = nil
for i, line := range v.lines {
if v.Wrap {
if len(line) < maxX {
vline := viewLine{linesX: 0, linesY: i, line: l... | go | {
"resource": ""
} |
q25389 | Clear | train | func (v *View) Clear() {
v.tainted = true
v.lines = nil
v.viewLines = nil
v.readOffset = 0
v.clearRunes()
} | go | {
"resource": ""
} |
q25390 | clearRunes | train | func (v *View) clearRunes() {
maxX, maxY := v.Size()
for x := 0; x < maxX; x++ {
for y := 0; y < maxY; y++ {
termbox.SetCell(v.x0+x+1, v.y0+y+1, ' ',
termbox.Attribute(v.FgColor), termbox.Attribute(v.BgColor))
}
}
} | go | {
"resource": ""
} |
q25391 | BufferLines | train | func (v *View) BufferLines() []string {
lines := make([]string, len(v.lines))
for i, l := range v.lines {
str := lineType(l).String()
str = strings.Replace(str, "\x00", " ", -1)
lines[i] = str
}
return lines
} | go | {
"resource": ""
} |
q25392 | Buffer | train | func (v *View) Buffer() string {
str := ""
for _, l := range v.lines {
str += lineType(l).String() + "\n"
}
return strings.Replace(str, "\x00", " ", -1)
} | go | {
"resource": ""
} |
q25393 | ViewBufferLines | train | func (v *View) ViewBufferLines() []string {
lines := make([]string, len(v.viewLines))
for i, l := range v.viewLines {
str := lineType(l.line).String()
str = strings.Replace(str, "\x00", " ", -1)
lines[i] = str
}
return lines
} | go | {
"resource": ""
} |
q25394 | ViewBuffer | train | func (v *View) ViewBuffer() string {
str := ""
for _, l := range v.viewLines {
str += lineType(l.line).String() + "\n"
}
return strings.Replace(str, "\x00", " ", -1)
} | go | {
"resource": ""
} |
q25395 | runes | train | func (ei *escapeInterpreter) runes() []rune {
switch ei.state {
case stateNone:
return []rune{0x1b}
case stateEscape:
return []rune{0x1b, ei.curch}
case stateCSI:
return []rune{0x1b, '[', ei.curch}
case stateParams:
ret := []rune{0x1b, '['}
for _, s := range ei.csiParam {
ret = append(ret, []rune(s)..... | go | {
"resource": ""
} |
q25396 | newEscapeInterpreter | train | func newEscapeInterpreter(mode OutputMode) *escapeInterpreter {
ei := &escapeInterpreter{
state: stateNone,
curFgColor: ColorDefault,
curBgColor: ColorDefault,
mode: mode,
}
return ei
} | go | {
"resource": ""
} |
q25397 | reset | train | func (ei *escapeInterpreter) reset() {
ei.state = stateNone
ei.curFgColor = ColorDefault
ei.curBgColor = ColorDefault
ei.csiParam = nil
} | go | {
"resource": ""
} |
q25398 | parseOne | train | func (ei *escapeInterpreter) parseOne(ch rune) (isEscape bool, err error) {
// Sanity checks
if len(ei.csiParam) > 20 {
return false, errCSITooLong
}
if len(ei.csiParam) > 0 && len(ei.csiParam[len(ei.csiParam)-1]) > 255 {
return false, errCSITooLong
}
ei.curch = ch
switch ei.state {
case stateNone:
if c... | go | {
"resource": ""
} |
q25399 | NewGui | train | func NewGui(mode OutputMode) (*Gui, error) {
if err := termbox.Init(); err != nil {
return nil, err
}
g := &Gui{}
g.outputMode = mode
termbox.SetOutputMode(termbox.OutputMode(mode))
g.tbEvents = make(chan termbox.Event, 20)
g.userEvents = make(chan userEvent, 20)
g.maxX, g.maxY = termbox.Size()
g.BgColo... | go | {
"resource": ""
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.