text string |
|---|
func (m *Message) SetTrackingClicks(trackingClicks bool) {
m.trackingClicks = trackingClicks
m.trackingClicksSet = true
} |
func (c *Conn) LockSession(id string) {
c.object.Call(dbusInterface+".LockSession", 0, id)
} |
func (s *StableBloomFilter) StablePoint() float64 {
var (
subDenom = float64(s.p) * (1/float64(s.k) - 1/float64(s.m))
denom = 1 + 1/subDenom
base = 1 / denom
)
return math.Pow(base, float64(s.max))
} |
func (dec *Decoder) Decode(v interface{}) error {
if dec.isPooled == 1 {
panic(InvalidUsagePooledDecoderError("Invalid usage of pooled decoder"))
}
var err error
switch vt := v.(type) {
case *string:
err = dec.decodeString(vt)
case **string:
err = dec.decodeStringNull(vt)
case *int:
err = dec.decodeInt(v... |
func (cli *Client) SetCredentials(userID, accessToken string) {
cli.AccessToken = accessToken
cli.UserID = userID
} |
func (xc *CommonExchange) setLastFail(t time.Time) {
xc.mtx.Lock()
defer xc.mtx.Unlock()
xc.lastFail = t
} |
func (set *zoomSet) Snip(length int) {
set.Height = set.Height.snip(length)
set.Time = set.Time.snip(length)
set.PoolSize = set.PoolSize.snip(length)
set.PoolValue = set.PoolValue.snip(length)
set.BlockSize = set.BlockSize.snip(length)
set.TxCount = set.TxCount.snip(length)
set.NewAtoms = set.NewAtoms.snip(lengt... |
func (set *windowSet) Snip(length int) {
set.Time = set.Time.snip(length)
set.PowDiff = set.PowDiff.snip(length)
set.TicketPrice = set.TicketPrice.snip(length)
} |
func (d *AddressCacheItem) SetRows(block BlockID, rows []dbtypes.AddressRowCompact) {
d.mtx.Lock()
defer d.mtx.Unlock()
d.setBlock(block)
d.rows = rows
} |
func (s *Status) SetHeight(height uint32) {
s.Lock()
defer s.Unlock()
s.ready = height == s.dbHeight
s.height = height
} |
func (s *Status) SetHeightAndConnections(height uint32, conns int64) {
s.Lock()
defer s.Unlock()
s.nodeConnections = conns
s.ready = height == s.dbHeight
s.height = height
} |
func (s *Status) DBUpdate(height uint32, blockTime int64) {
s.Lock()
defer s.Unlock()
s.dbHeight = height
s.dbLastBlockTime = blockTime
s.ready = s.dbHeight == height
} |
func UpdateTicketPoolData(interval dbtypes.TimeBasedGrouping, timeGraph *dbtypes.PoolTicketsData,
priceGraph *dbtypes.PoolTicketsData, donutcharts *dbtypes.PoolTicketsData, height int64) {
ticketPoolGraphsCache.Lock()
defer ticketPoolGraphsCache.Unlock()
ticketPoolGraphsCache.Height[interval] = height
ticketPoolG... |
func (g *BlockGate) SetFetchToHeight(height int64) {
g.mtx.RLock()
defer g.mtx.RUnlock()
g.fetchToHeight = height
} |
func (c *MempoolDataCache) StoreMPData(stakeData *StakeData, txsCopy []exptypes.MempoolTx, _ *exptypes.MempoolInfo) {
c.mtx.Lock()
defer c.mtx.Unlock()
c.height = uint32(stakeData.LatestBlock.Height)
c.hash = stakeData.LatestBlock.Hash.String()
c.timestamp = stakeData.Time
c.txns = txsCopy
c.numTickets = stak... |
func (w *BatchedFileWriter) init() {
w.totalSize = 0
w.currentMultiPart = 0
w.completedParts = []*s3.CompletedPart{}
w.activeBuffer = newS3ByteBuffer()
w.createMultipartUpload()
} |
func (prod *ElasticSearch) Configure(conf core.PluginConfigReader) {
prod.connection.servers = conf.GetStringArray("Servers", []string{"http://127.0.0.1:9200"})
prod.connection.user = conf.GetString("User", "")
prod.connection.password = conf.GetString("Password", "")
prod.connection.setGzip = conf.GetBool("SetGzip... |
func (router *RoundRobin) Configure(conf core.PluginConfigReader) {
router.index = 0
router.indexByStream = make(map[core.MessageStreamID]*int32)
router.mapInitLock = new(sync.Mutex)
} |
func (prod *File) Configure(conf core.PluginConfigReader) {
prod.Pruner.Logger = prod.Logger
prod.SetRollCallback(prod.rotateLog)
prod.SetStopCallback(prod.close)
prod.filesByStream = make(map[core.MessageStreamID]*components.BatchedWriterAssembly)
prod.files = make(map[string]*components.BatchedWriterAssembly)
... |
func (prod *File) Produce(workers *sync.WaitGroup) {
prod.AddMainWorker(workers)
prod.TickerMessageControlLoop(prod.writeMessage, prod.BatchConfig.BatchTimeout, prod.writeBatchOnTimeOut)
} |
func (prod *AwsFirehose) Produce(workers *sync.WaitGroup) {
defer prod.WorkerDone()
prod.AddMainWorker(workers)
prod.initFirehoseClient()
prod.BatchMessageLoop(workers, prod.sendBatch)
} |
func (prod *Spooling) Produce(workers *sync.WaitGroup) {
prod.AddMainWorker(workers)
prod.spoolCheck = time.AfterFunc(prod.respoolDuration, prod.openExistingFiles)
prod.TickerMessageControlLoop(prod.writeToFile, prod.batchTimeout, prod.writeBatchOnTimeOut)
} |
func (cons *LogConsumer) Configure(conf PluginConfigReader) {
cons.control = make(chan PluginControl, 1)
cons.logRouter = StreamRegistry.GetRouter(LogInternalStreamID)
cons.metric = conf.GetString("MetricKey", "")
cons.queue = NewMessageQueue(1024)
if cons.metric != "" {
cons.metricsRegistry = NewMetricsRegistr... |
func (meta Metadata) SetValue(key string, value []byte) {
meta[key] = value
} |
func (prod *AwsS3) Produce(workers *sync.WaitGroup) {
prod.initS3Client()
prod.AddMainWorker(workers)
prod.TickerMessageControlLoop(prod.writeMessage, prod.BatchConfig.BatchTimeout, prod.writeBatchOnTimeOut)
} |
func (p *Policy) addDefaultElementsWithoutAttrs() {
p.init()
p.setOfElementsAllowedWithoutAttrs["abbr"] = struct{}{}
p.setOfElementsAllowedWithoutAttrs["acronym"] = struct{}{}
p.setOfElementsAllowedWithoutAttrs["address"] = struct{}{}
p.setOfElementsAllowedWithoutAttrs["article"] = struct{}{}
p.setOfElementsAllo... |
func (p *Policy) addDefaultSkipElementContent() {
p.init()
p.setOfElementsToSkipContent["frame"] = struct{}{}
p.setOfElementsToSkipContent["frameset"] = struct{}{}
p.setOfElementsToSkipContent["iframe"] = struct{}{}
p.setOfElementsToSkipContent["noembed"] = struct{}{}
p.setOfElementsToSkipContent["noframes"] = s... |
func (d *jsonDecDriver) readLit4True() {
bs := d.r.readx(3)
d.tok = 0
if jsonValidateSymbols && !bytes.Equal(bs, jsonLiteral4True) {
d.d.errorf("expecting %s: got %s", jsonLiteral4True, bs)
}
} |
func (h *EssentialHeader) Copy(h2 *EssentialHeader) {
h.AgreementPartyUInfo = h2.AgreementPartyUInfo
h.AgreementPartyVInfo = h2.AgreementPartyVInfo
h.Algorithm = h2.Algorithm
h.ContentEncryption = h2.ContentEncryption
h.ContentType = h2.ContentType
h.Compression = h2.Compression
h.Critical = h2.Critical
h.Ephem... |
func (client *flclient_t) connect(endpoint string) {
client.socket.Connect(endpoint)
client.servers++
} |
func (t *Template) backup2(t1 item) {
t.token[1] = t1
t.peekCount = 2
} |
func (s *Set) Delims(left, right string) {
s.leftDelim = left
s.rightDelim = right
} |
func (z *runContainer16) Msgsize() (s int) {
s = 1 + 3 + msgp.ArrayHeaderSize + (len(z.iv) * (12 + msgp.Uint16Size + msgp.Uint16Size)) + 5 + msgp.Int64Size
return
} |
func (r *Range) Fixed(min, max, delta float64) {
r.MinMode.Fixed, r.MaxMode.Fixed = true, true
r.MinMode.Value, r.MaxMode.Value = min, max
r.TicSetting.Delta = delta
} |
func (r *Range) Reset() {
r.Min, r.Max = 0, 0
r.TMin, r.TMax = time.Time{}, time.Time{}
r.Tics = nil
r.Norm, r.InvNorm = nil, nil
r.Data2Screen, r.Screen2Data = nil, nil
if !r.TicSetting.UserDelta {
r.TicSetting.Delta = 0
r.TicSetting.TDelta = nil
}
} |
func autoscale() {
dumper := NewDumper("xautoscale", 2, 2, 600, 400)
defer dumper.Close()
N := 200
points := make([]chart.EPoint, N)
for i := 0; i < N-1; i++ {
points[i].X = rand.Float64()*10000 - 5000 // Full range is [-5000:5000]
points[i].Y = rand.Float64()*10000 - 5000 // Full range is [-5000:5000]
poin... |
func categoricalBarChart() {
dumper := NewDumper("xbar2", 3, 2, 400, 300)
defer dumper.Close()
x := []float64{0, 1, 2, 3}
europe := []float64{10, 15, 25, 20}
asia := []float64{15, 30, 10, 20}
africa := []float64{20, 5, 5, 5}
blue := chart.Style{Symbol: '#', LineColor: color.NRGBA{0x00, 0x00, 0xff, 0xff}, LineWi... |
func Get(region string) (frequencyPlan FrequencyPlan, err error) {
if fp, ok := frequencyPlans[region]; ok {
return fp, nil
}
switch region {
case pb_lorawan.FrequencyPlan_EU_863_870.String():
frequencyPlan.Band, err = lora.GetConfig(lora.EU_863_870, false, lorawan.DwellTimeNoLimit)
// TTN frequency plan incl... |
func (d *Device) FromPb(in *pb_handler.Device) {
d.AppID = in.AppID
d.DevID = in.DevID
d.Description = in.Description
d.Latitude = in.Latitude
d.Longitude = in.Longitude
d.Altitude = in.Altitude
d.Attributes = in.Attributes
d.FromLoRaWANPb(in.GetLoRaWANDevice())
} |
func newClient(apiurl string, apikey string, secret string, async bool, verifyssl bool) *CloudStackClient {
jar, _ := cookiejar.New(nil)
cs := &CloudStackClient{
client: &http.Client{
Jar: jar,
Transport: &http.Transport{
Proxy: http.ProxyFromEnvironment,
DialContext: (&net.Dialer{
Timeout: 30 ... |
func (m *msg) setVersion(v int) {
m.LiVnMode = (m.LiVnMode & 0xc7) | uint8(v)<<3
} |
func (m *msg) setMode(md mode) {
m.LiVnMode = (m.LiVnMode & 0xf8) | uint8(md)
} |
func (root *RootDevice) SetURLBase(urlBase *url.URL) {
root.URLBase = *urlBase
root.URLBaseStr = urlBase.String()
root.Device.SetURLBase(urlBase)
} |
func (t *Tree) backup2(t1 item) {
t.token[1] = t1
t.peekCount = 2
} |
func (k *Key) SetValue(v string) {
if k.s.f.BlockMode {
k.s.f.lock.Lock()
defer k.s.f.lock.Unlock()
}
k.value = v
k.s.keysHash[k.name] = v
} |
func (sw syslogWriter) WriteLevel(level Level, p []byte) (n int, err error) {
switch level {
case DebugLevel:
err = sw.w.Debug(string(p))
case InfoLevel:
err = sw.w.Info(string(p))
case WarnLevel:
err = sw.w.Warning(string(p))
case ErrorLevel:
err = sw.w.Err(string(p))
case FatalLevel:
err = sw.w.Emerg(... |
func (tr *Matrix) Compose(trToCompose Matrix) {
tr0, tr1, tr2, tr3, tr4, tr5 := tr[0], tr[1], tr[2], tr[3], tr[4], tr[5]
tr[0] = trToCompose[0]*tr0 + trToCompose[1]*tr2
tr[1] = trToCompose[1]*tr3 + trToCompose[0]*tr1
tr[2] = trToCompose[2]*tr0 + trToCompose[3]*tr2
tr[3] = trToCompose[3]*tr3 + trToCompose[2]*tr1
t... |
func (tr *Matrix) Translate(tx, ty float64) {
tr[4] = tx*tr[0] + ty*tr[2] + tr[4]
tr[5] = ty*tr[3] + tx*tr[1] + tr[5]
} |
func (vr *vectorRenderer) SetDPI(dpi float64) {
vr.dpi = dpi
vr.c.dpi = dpi
} |
func (vr *vectorRenderer) Close() {
vr.p = append(vr.p, fmt.Sprintf("Z"))
} |
func (s Style) InheritFrom(defaults Style) (final Style) {
final.ClassName = s.GetClassName(defaults.ClassName)
final.StrokeColor = s.GetStrokeColor(defaults.StrokeColor)
final.StrokeWidth = s.GetStrokeWidth(defaults.StrokeWidth)
final.StrokeDashArray = s.GetStrokeDashArray(defaults.StrokeDashArray)
final.DotCol... |
func (gc *StackGraphicContext) ArcTo(cx, cy, rx, ry, startAngle, delta float64) {
gc.current.Path.ArcTo(cx, cy, rx, ry, startAngle, delta)
} |
func (gc *StackGraphicContext) Save() {
context := new(ContextStack)
context.FontSizePoints = gc.current.FontSizePoints
context.Font = gc.current.Font
context.LineWidth = gc.current.LineWidth
context.StrokeColor = gc.current.StrokeColor
context.FillColor = gc.current.FillColor
context.FillRule = gc.current.FillR... |
func (b *Buffer) Clear() {
b.array = make([]float64, bufferDefaultCapacity)
b.head = 0
b.tail = 0
b.size = 0
} |
func (l *Legacy) Set(status bool, interval int) {
l.Force = true
l.Interval = time.Duration(interval) * time.Second
} |
func (a *API) Init(key string, backends *stripe.Backends) {
if backends == nil {
backends = &stripe.Backends{
API: stripe.GetBackend(stripe.APIBackend),
Uploads: stripe.GetBackend(stripe.UploadsBackend),
}
}
a.Account = &account.Client{B: backends.API, Key: key}
a.ApplePayDomains = &applepaydomain.Cl... |
func (v *Assistant) SetPageType(page IWidget, t AssistantPageType) {
C.gtk_assistant_set_page_type(ASSISTANT(v), ToNative(page), C.GtkAssistantPageType(t))
} |
func (v *Range) SetAdjustment(a *Adjustment) {
C.gtk_range_set_adjustment(RANGE(v), a.GAdjustment)
} |
func (attrs *attributes) Add(attrType asn1.ObjectIdentifier, value interface{}) {
attrs.types = append(attrs.types, attrType)
attrs.values = append(attrs.values, value)
} |
func sm2P256Mul(c, a, b *sm2P256FieldElement) {
var tmp sm2P256LargeFieldElement
tmp[0] = uint64(a[0]) * uint64(b[0])
tmp[1] = uint64(a[0])*(uint64(b[1])<<0) +
uint64(a[1])*(uint64(b[0])<<0)
tmp[2] = uint64(a[0])*(uint64(b[2])<<0) +
uint64(a[1])*(uint64(b[1])<<1) +
uint64(a[2])*(uint64(b[0])<<0)
tmp[3] = ui... |
func sm2P256Square(b, a *sm2P256FieldElement) {
var tmp sm2P256LargeFieldElement
tmp[0] = uint64(a[0]) * uint64(a[0])
tmp[1] = uint64(a[0]) * (uint64(a[1]) << 1)
tmp[2] = uint64(a[0])*(uint64(a[2])<<1) +
uint64(a[1])*(uint64(a[1])<<1)
tmp[3] = uint64(a[0])*(uint64(a[3])<<1) +
uint64(a[1])*(uint64(a[2])<<1)
t... |
func cryptBlock(subkeys []uint32, b []uint32, r []byte, dst, src []byte, decrypt bool) {
var x uint32
permuteInitialBlock(b, src)
if decrypt {
for i := 0; i < 8; i++ {
x = b[1] ^ b[2] ^ b[3] ^ subkeys[31-4*i]
b[0] = b[0] ^ sbox0[x&0xff] ^ sbox1[(x>>8)&0xff] ^ sbox2[(x>>16)&0xff] ^ sbox3[(x>>24)&0xff]
x = ... |
func writeSignV2Headers(buf *bytes.Buffer, req http.Request) {
buf.WriteString(req.Method + "\n")
buf.WriteString(req.Header.Get("Content-Md5") + "\n")
buf.WriteString(req.Header.Get("Content-Type") + "\n")
buf.WriteString(req.Header.Get("Date") + "\n")
} |
func escapeKey(r rune, reader *bufio.Reader) rune {
switch r {
case 'b':
r = MetaBackward
case 'f':
r = MetaForward
case 'd':
r = MetaDelete
case CharTranspose:
r = MetaTranspose
case CharBackspace:
r = MetaBackspace
case 'O':
d, _, _ := reader.ReadRune()
switch d {
case 'H':
r = CharLineStart... |
func (s *Server) RunFcgi(addr string) {
s.initServer()
s.Logger.Printf("web.go serving fcgi %s\n", addr)
s.listenAndServeFcgi(addr)
} |
func NewITunesItemExtension(extensions map[string][]Extension) *ITunesItemExtension {
entry := &ITunesItemExtension{}
entry.Author = parseTextExtension("author", extensions)
entry.Block = parseTextExtension("block", extensions)
entry.Duration = parseTextExtension("duration", extensions)
entry.Explicit = parseTextE... |
func NewDublinCoreExtension(extensions map[string][]Extension) *DublinCoreExtension {
dc := &DublinCoreExtension{}
dc.Title = parseTextArrayExtension("title", extensions)
dc.Creator = parseTextArrayExtension("creator", extensions)
dc.Author = parseTextArrayExtension("author", extensions)
dc.Subject = parseTextArra... |
func encode(dst, id []byte) {
_ = dst[19]
_ = id[11]
dst[19] = encoding[(id[11]<<4)&0x1F]
dst[18] = encoding[(id[11]>>1)&0x1F]
dst[17] = encoding[(id[11]>>6)&0x1F|(id[10]<<2)&0x1F]
dst[16] = encoding[id[10]>>3]
dst[15] = encoding[id[9]&0x1F]
dst[14] = encoding[(id[9]>>5)|(id[8]<<3)&0x1F]
dst[13] = encoding[(i... |
func decode(id *ID, src []byte) {
_ = src[19]
_ = id[11]
id[11] = dec[src[17]]<<6 | dec[src[18]]<<1 | dec[src[19]]>>4
id[10] = dec[src[16]]<<3 | dec[src[17]]>>2
id[9] = dec[src[14]]<<5 | dec[src[15]]
id[8] = dec[src[12]]<<7 | dec[src[13]]<<2 | dec[src[14]]>>3
id[7] = dec[src[11]]<<4 | dec[src[12]]>>1
id[6] = d... |
func (k *ExtendedKey) Zero() {
zero(k.key)
zero(k.pubKey)
zero(k.chainCode)
zero(k.parentFP)
k.version = nil
k.key = nil
k.depth = 0
k.childNum = 0
k.isPrivate = false
} |
func (p *siprng) Seed(k [16]byte) {
p.k0 = binary.LittleEndian.Uint64(k[0:8])
p.k1 = binary.LittleEndian.Uint64(k[8:16])
p.ctr = 1
} |
func (l *loopCrosser) startEdge(aj int) {
l.crosser = NewEdgeCrosser(l.a.Vertex(aj), l.a.Vertex(aj+1))
l.aj = aj
l.bjPrev = -2
} |
func (e *EdgeCrosser) RestartAt(c Point) {
e.c = c
e.acb = -triageSign(e.a, e.b, e.c)
} |
func (ed *eventData) writeInt32(value int32) {
binary.Write(&ed.buffer, binary.LittleEndian, value)
} |
func BoundPad(b orb.Bound, meters float64) orb.Bound {
dy := meters / 111131.75
dx := dy / math.Cos(deg2rad(b.Max[1]))
dx = math.Max(dx, dy/math.Cos(deg2rad(b.Min[1])))
b.Min[0] -= dx
b.Min[1] -= dy
b.Max[0] += dx
b.Max[1] += dy
b.Min[0] = math.Max(b.Min[0], -180)
b.Min[1] = math.Max(b.Min[1], -90)
b.Max[... |
func (opts *Options) SetEnv(value *Env) {
opts.env = value
C.rocksdb_options_set_env(opts.c, value.c)
} |
func (opts *Options) SetCompressionOptions(value *CompressionOptions) {
C.rocksdb_options_set_compression_options(opts.c, C.int(value.WindowBits), C.int(value.Level), C.int(value.Strategy), C.int(value.MaxDictBytes))
} |
func (opts *Options) SetRateLimiter(rateLimiter *RateLimiter) {
C.rocksdb_options_set_ratelimiter(opts.c, rateLimiter.c)
} |
func (opts *Options) SetBlockBasedTableFactory(value *BlockBasedTableOptions) {
opts.bbto = value
C.rocksdb_options_set_block_based_table_factory(opts.c, value.c)
} |
func centroid3(p1, p2, p3, c geom.Coord) {
c[0] = p1[0] + p2[0] + p3[0]
c[1] = p1[1] + p2[1] + p3[1]
} |
func FormatBits(scratch *FormatBitsScratch, dst FormatBitsWriter, u uint64, base int, neg bool) {
FormatBits2(dst, u, base, neg)
} |
func (r *ffReader) Reset(d []byte) {
r.s = d
r.i = 0
r.l = len(d)
} |
func (ffl *FFLexer) Reset(input []byte) {
ffl.Token = FFTok_init
ffl.Error = FFErr_e_ok
ffl.BigError = nil
ffl.reader.Reset(input)
ffl.lastCurrentChar = 0
ffl.Output.Reset()
} |
func startCleaner(cache *Cache, interval time.Duration) {
cleaner := &cleaner{
interval: interval,
stop: make(chan bool),
}
cache.cleaner = cleaner
go cleaner.Run(cache)
} |
func Register(format string, p Packager) {
lock.Lock()
packagers[format] = p
lock.Unlock()
} |
func (perm *Permissions) AddAdminPath(prefix string) {
perm.adminPathPrefixes = append(perm.adminPathPrefixes, prefix)
} |
func (perm *Permissions) AddPublicPath(prefix string) {
perm.publicPathPrefixes = append(perm.publicPathPrefixes, prefix)
} |
func InitBaseHeader(v *http.Request) {
v.Header["Accept"] = []string{"application/json"}
v.Header.Set("Content-MD5", "")
v.Header["Content-Type"] = []string{"application/json"}
v.Header["Date"] = []string{util.GetRFCDate()}
v.Header["x-acs-signature-method"] = []string{"HMAC-SHA1"}
v.Header["x-acs-signature-vers... |
func NewClient() *Client {
baseURL, _ := url.Parse(BaseURL)
c := &Client{BaseURL: baseURL, WebSocketURL: WebSocketURL}
c.Pairs = &PairsService{client: c}
c.Stats = &StatsService{client: c}
c.Account = &AccountService{client: c}
c.Ticker = &TickerService{client: c}
c.Balances = &BalancesService{client: c}
c.Off... |
func NewClientWithSynchronousURLNonce(sync Synchronous, url string, nonce utils.NonceGenerator) *Client {
c := &Client{
Synchronous: sync,
nonce: nonce,
}
c.Orders = OrderService{Synchronous: c, requestFactory: c}
c.Book = BookService{Synchronous: c}
c.Candles = CandleService{Synchronous: c}
c.Trades = ... |
func (p *UserAgent) initialize() {
p.ua = ""
p.mozilla = ""
p.platform = ""
p.os = ""
p.localization = ""
p.browser.Engine = ""
p.browser.EngineVersion = ""
p.browser.Name = ""
p.browser.Version = ""
p.bot = false
p.mobile = false
p.undecided = false
} |
func AddStringFuncs(f map[string]interface{}) {
f["strings"] = StrNS
f["replaceAll"] = StrNS().ReplaceAll
f["title"] = StrNS().Title
f["toUpper"] = StrNS().ToUpper
f["toLower"] = StrNS().ToLower
f["trimSpace"] = StrNS().TrimSpace
f["indent"] = StrNS().Indent
f["quote"] = StrNS().Quote
f["squote"] = StrNS().Sq... |
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(... |
func AddMathFuncs(f map[string]interface{}) {
f["math"] = MathNS
f["add"] = MathNS().Add
f["sub"] = MathNS().Sub
f["mul"] = MathNS().Mul
f["div"] = MathNS().Div
f["rem"] = MathNS().Rem
f["pow"] = MathNS().Pow
f["seq"] = MathNS().Seq
} |
func (d *Data) registerReaders() {
d.sourceReaders = make(map[string]func(*Source, ...string) ([]byte, error))
d.sourceReaders["aws+smp"] = readAWSSMP
d.sourceReaders["boltdb"] = readBoltDB
d.sourceReaders["consul"] = readConsul
d.sourceReaders["consul+http"] = readConsul
d.sourceReaders["consul+https"] = readCo... |
func AddDataFuncs(f map[string]interface{}, d *data.Data) {
f["datasource"] = d.Datasource
f["ds"] = d.Datasource
f["datasourceExists"] = d.DatasourceExists
f["datasourceReachable"] = d.DatasourceReachable
f["defineDatasource"] = d.DefineDatasource
f["include"] = d.Include
f["data"] = DataNS
f["json"] = DataN... |
func AddConvFuncs(f map[string]interface{}) {
f["conv"] = ConvNS
f["urlParse"] = ConvNS().URL
f["bool"] = ConvNS().Bool
f["join"] = ConvNS().Join
f["default"] = ConvNS().Default
} |
func (f *File) PackageComment(comment string) {
f.comments = append(f.comments, comment)
} |
func (r *Request) SetChecksum(h hash.Hash, sum []byte, deleteOnError bool) {
r.hash = h
r.checksum = sum
r.deleteOnError = deleteOnError
} |
func (nw *NotifyWorker) tearDown(err error) {
nw.catacomb.Kill(err)
err = nw.config.Handler.TearDown()
nw.catacomb.Kill(err)
} |
End of preview. Expand in Data Studio
README.md exists but content is empty.
- Downloads last month
- 27