// IsColliding is handle server side with the compose api v1beta2, so nothing to do here
343996
func (s *stackV1Beta2) IsColliding(servicesClient corev1.ServiceInterface, st Stack) error {
	return nil
}
890194
func (c *ConfigLocal) IsSyncedTlfPath(tlfPath string) bool {
	c.lock.RLock()
	defer c.lock.RUnlock()
	return c.syncedTlfPaths[tlfPath]
}
820231
func (c *ConfigLocal) IsSyncedTlf(tlfID tlf.ID) bool {
	return c.GetTlfSyncState(tlfID).Mode == keybase1.FolderSyncMode_ENABLED
}
77433
func (bf *Filter) IsLoaded() bool {
	bf.mtx.Lock()
	loaded := bf.msgFilterLoad != nil
	bf.mtx.Unlock()
	return loaded
}
310363
func (tl *TaskLogger) IsRunning() bool {
	if tl.lro != nil && tl.lro.isRunning() {
		return true
	}
	if tl.lre != nil && tl.lre.isRunning() {
		return true
	}

	return false
}
229198
func (nc *Conn) IsDraining() bool {
	nc.mu.RLock()
	defer nc.mu.RUnlock()
	return nc.isDraining()
}
312416
func OptServerIsCoordinator(is bool) ServerOption {
	return func(s *Server) error {
		s.isCoordinator = is
		return nil
	}
}
58488
func (c Cap) IsValid() bool {
	return c.center.Vector.IsUnit() && c.radius <= s1.StraightChordAngle
}
961375
func (s *holderSyncer) IsClosing() bool {
	if s.Cluster.abortAntiEntropyQ() {
		return true
	}
	select {
	case <-s.Closing:
		return true
	default:
		return false
	}
}
41159
func (obj *Global) IsValidConnectionStringRaw(ctx context.Context, connection interface{}) (bool, error) {
	result := &struct {
		Return bool	`json:"qReturn"`
	} {}
	err := obj.rpc(ctx, "IsValidConnectionString", result, ensureEncodable(connection))
	return result.Return, err 
}
272764
func (f *FakeProcTableImpl) IsRunning(pvName string) bool {
	f.IsRunningCount++
	return f.realTable.IsRunning(pvName)
}
556417
func (lc *LightningChannel) IsPending() bool {
	lc.RLock()
	defer lc.RUnlock()

	return lc.channelState.IsPending
}
466847
func AddCollFuncs(f map[string]interface{}) {
	f["coll"] = CollNS

	f["has"] = CollNS().Has
	f["slice"] = CollNS().Slice
	f["dict"] = CollNS().Dict
	f["keys"] = CollNS().Keys
	f["values"] = CollNS().Values
	f["append"] = CollNS().Append
	f["prepend"] = CollNS().Prepend
	f["uniq"] = CollNS().Uniq
	f["reverse"] = CollNS().Reverse
	f["merge"] = CollNS().Merge
	f["sort"] = CollNS().Sort
	f["jsonpath"] = CollNS().JSONPath
}
367450
func IsRunning(ep *endpoint.Endpoint) bool {
	if Client() == nil {
		return false
	}

	return Client().IsRunning(ep)
}
465126
func (r *CollaboratorsService) IsCollaborator(uri *Hyperlink,
	params M) (collabStatus bool, result *Result) {
	if uri == nil {
		uri = &CollaboratorsURL
	}
	url, err := uri.Expand(params)
	if err != nil {
		return false, &Result{Err: err}
	}
	result = r.client.get(url, nil)
	collabStatus = false
	if result.Err == nil && result.Response.Response.StatusCode == 204 {
		collabStatus = true
	}
	return
}
1241550
func (b BlockServerMeasured) IsUnflushed(ctx context.Context, tlfID tlf.ID,
	id kbfsblock.ID) (isUnflushed bool, err error) {
	b.isUnflushedTimer.Time(func() {
		isUnflushed, err = b.delegate.IsUnflushed(ctx, tlfID, id)
	})
	return isUnflushed, err

}
975979
func (svc *IService) isFlapping() bool {
	const MINIMUM_VIABLE_LIFESPAN = 60
	const FLAPPING_THRESHOLD = 3

	upTime := time.Since(svc.startTime)
	if upTime.Seconds() < MINIMUM_VIABLE_LIFESPAN {
		svc.restartCount += 1
	} else {
		svc.restartCount = 0
	}

	return svc.restartCount >= FLAPPING_THRESHOLD
}