_id stringlengths 2 7 | title stringlengths 1 118 | partition stringclasses 3
values | text stringlengths 52 85.5k | language stringclasses 1
value | meta_information dict |
|---|---|---|---|---|---|
q179500 | CreateStringPath | test | func (gc *GraphicContext) CreateStringPath(text string, x, y float64) (cursor float64) {
//fpdf uses the top left corner
left, top, right, bottom := gc.GetStringBounds(text)
w := right - left
h := bottom - top
// gc.pdf.SetXY(x, y-h) do not use this as y-h might be negative
margin := gc.pdf.GetCellMargin()
gc.pd... | go | {
"resource": ""
} |
q179501 | FillStringAt | test | func (gc *GraphicContext) FillStringAt(text string, x, y float64) (cursor float64) {
return gc.CreateStringPath(text, x, y)
} | go | {
"resource": ""
} |
q179502 | SetStrokeColor | test | func (gc *GraphicContext) SetStrokeColor(c color.Color) {
gc.StackGraphicContext.SetStrokeColor(c)
gc.pdf.SetDrawColor(rgb(c))
} | go | {
"resource": ""
} |
q179503 | SetFillColor | test | func (gc *GraphicContext) SetFillColor(c color.Color) {
gc.StackGraphicContext.SetFillColor(c)
gc.pdf.SetFillColor(rgb(c))
gc.pdf.SetTextColor(rgb(c))
} | go | {
"resource": ""
} |
q179504 | SetLineDash | test | func (gc *GraphicContext) SetLineDash(Dash []float64, DashOffset float64) {
gc.StackGraphicContext.SetLineDash(Dash, DashOffset)
gc.pdf.SetDashPattern(Dash, DashOffset)
} | go | {
"resource": ""
} |
q179505 | SetLineWidth | test | func (gc *GraphicContext) SetLineWidth(LineWidth float64) {
gc.StackGraphicContext.SetLineWidth(LineWidth)
gc.pdf.SetLineWidth(LineWidth)
} | go | {
"resource": ""
} |
q179506 | Main | test | func Main(gc draw2d.GraphicContext, ext string) (string, error) {
// Draw hello world
Draw(gc, fmt.Sprintf("Hello World %d dpi", gc.GetDPI()))
// Return the output filename
return samples.Output("helloworld", ext), nil
} | go | {
"resource": ""
} |
q179507 | Draw | test | func Draw(gc draw2d.GraphicContext, text string) {
// Draw a rounded rectangle using default colors
draw2dkit.RoundedRectangle(gc, 5, 5, 135, 95, 10, 10)
gc.FillStroke()
// Set the font luximbi.ttf
gc.SetFontData(draw2d.FontData{Name: "luxi", Family: draw2d.FontFamilyMono, Style: draw2d.FontStyleBold | draw2d.Fon... | go | {
"resource": ""
} |
q179508 | SaveToPngFile | test | func SaveToPngFile(filePath string, m image.Image) error {
// Create the file
f, err := os.Create(filePath)
if err != nil {
return err
}
defer f.Close()
// Create Writer from file
b := bufio.NewWriter(f)
// Write the image into the buffer
err = png.Encode(b, m)
if err != nil {
return err
}
err = b.Flush... | go | {
"resource": ""
} |
q179509 | LoadFromPngFile | test | func LoadFromPngFile(filePath string) (image.Image, error) {
// Open file
f, err := os.OpenFile(filePath, 0, 0)
if err != nil {
return nil, err
}
defer f.Close()
b := bufio.NewReader(f)
img, err := png.Decode(b)
if err != nil {
return nil, err
}
return img, nil
} | go | {
"resource": ""
} |
q179510 | Resource | test | func Resource(folder, filename, ext string) string {
var root string
if ext == "pdf" || ext == "svg" {
root = "../"
}
return fmt.Sprintf("%sresource/%s/%s", root, folder, filename)
} | go | {
"resource": ""
} |
q179511 | Output | test | func Output(name, ext string) string {
var root string
if ext == "pdf" || ext == "svg" {
root = "../"
}
return fmt.Sprintf("%soutput/samples/%s.%s", root, name, ext)
} | go | {
"resource": ""
} |
q179512 | Main | test | func Main(gc draw2d.GraphicContext, ext string) (string, error) {
gc.Save()
// flip the image
gc.Translate(0, 200)
gc.Scale(0.35, -0.35)
gc.Translate(70, -200)
// Tiger postscript drawing
tiger := samples.Resource("image", "tiger.ps", ext)
// Draw tiger
Draw(gc, tiger)
gc.Restore()
// Return the output f... | go | {
"resource": ""
} |
q179513 | Draw | test | func Draw(gc draw2d.GraphicContext, filename string) {
// Open the postscript
src, err := os.OpenFile(filename, 0, 0)
if err != nil {
panic(err)
}
defer src.Close()
bytes, err := ioutil.ReadAll(src)
reader := strings.NewReader(string(bytes))
// Initialize and interpret the postscript
interpreter := ps.NewIn... | go | {
"resource": ""
} |
q179514 | Main | test | func Main(gc draw2d.GraphicContext, ext string) (string, error) {
// Draw the droid
Draw(gc, 297, 210)
// Return the output filename
return samples.Output("geometry", ext), nil
} | go | {
"resource": ""
} |
q179515 | Bubble | test | func Bubble(gc draw2d.GraphicContext, x, y, width, height float64) {
sx, sy := width/100, height/100
gc.MoveTo(x+sx*50, y)
gc.QuadCurveTo(x, y, x, y+sy*37.5)
gc.QuadCurveTo(x, y+sy*75, x+sx*25, y+sy*75)
gc.QuadCurveTo(x+sx*25, y+sy*95, x+sx*5, y+sy*100)
gc.QuadCurveTo(x+sx*35, y+sy*95, x+sx*40, y+sy*75)
gc.QuadC... | go | {
"resource": ""
} |
q179516 | Dash | test | func Dash(gc draw2d.GraphicContext, x, y, width, height float64) {
sx, sy := width/162, height/205
gc.SetStrokeColor(image.Black)
gc.SetLineDash([]float64{height / 10, height / 50, height / 50, height / 50}, -50.0)
gc.SetLineCap(draw2d.ButtCap)
gc.SetLineJoin(draw2d.RoundJoin)
gc.SetLineWidth(height / 50)
gc.Mo... | go | {
"resource": ""
} |
q179517 | CubicCurve | test | func CubicCurve(gc draw2d.GraphicContext, x, y, width, height float64) {
sx, sy := width/162, height/205
x0, y0 := x, y+sy*100.0
x1, y1 := x+sx*75, y+sy*205
x2, y2 := x+sx*125, y
x3, y3 := x+sx*205, y+sy*100
gc.SetStrokeColor(image.Black)
gc.SetFillColor(color.NRGBA{0xAA, 0xAA, 0xAA, 0xFF})
gc.SetLineWidth(wid... | go | {
"resource": ""
} |
q179518 | FillStroke | test | func FillStroke(gc draw2d.GraphicContext, x, y, width, height float64) {
sx, sy := width/210, height/215
gc.MoveTo(x+sx*113.0, y)
gc.LineTo(x+sx*215.0, y+sy*215)
rLineTo(gc, sx*-100, 0)
gc.CubicCurveTo(x+sx*35, y+sy*215, x+sx*35, y+sy*113, x+sx*113.0, y+sy*113)
gc.Close()
gc.MoveTo(x+sx*50.0, y)
rLineTo(gc, sx... | go | {
"resource": ""
} |
q179519 | FillStyle | test | func FillStyle(gc draw2d.GraphicContext, x, y, width, height float64) {
sx, sy := width/232, height/220
gc.SetLineWidth(width / 40)
draw2dkit.Rectangle(gc, x+sx*0, y+sy*12, x+sx*232, y+sy*70)
var wheel1, wheel2 draw2d.Path
wheel1.ArcTo(x+sx*52, y+sy*70, sx*40, sy*40, 0, 2*math.Pi)
wheel2.ArcTo(x+sx*180, y+sy*70... | go | {
"resource": ""
} |
q179520 | PathTransform | test | func PathTransform(gc draw2d.GraphicContext, x, y, width, height float64) {
gc.Save()
gc.SetLineWidth(width / 10)
gc.Translate(x+width/2, y+height/2)
gc.Scale(1, 4)
gc.ArcTo(0, 0, width/8, height/8, 0, math.Pi*2)
gc.Close()
gc.Stroke()
gc.Restore()
} | go | {
"resource": ""
} |
q179521 | Star | test | func Star(gc draw2d.GraphicContext, x, y, width, height float64) {
gc.Save()
gc.Translate(x+width/2, y+height/2)
gc.SetLineWidth(width / 40)
for i := 0.0; i < 360; i = i + 10 { // Go from 0 to 360 degrees in 10 degree steps
gc.Save() // Keep rotations temporary
gc.Rotate(i * (math.Pi / 18... | go | {
"resource": ""
} |
q179522 | Draw | test | func Draw(gc draw2d.GraphicContext, width, height float64) {
mx, my := width*0.025, height*0.025 // margin
dx, dy := (width-2*mx)/4, (height-2*my)/3
w, h := dx-2*mx, dy-2*my
x0, y := 2*mx, 2*my
x := x0
Bubble(gc, x, y, w, h)
x += dx
CurveRectangle(gc, x, y, w, h, color.NRGBA{0x80, 0, 0, 0x80}, color.NRGBA{0x80,... | go | {
"resource": ""
} |
q179523 | ConvertPath | test | func ConvertPath(path *draw2d.Path, pdf Vectorizer) {
var startX, startY float64 = 0, 0
i := 0
for _, cmp := range path.Components {
switch cmp {
case draw2d.MoveToCmp:
startX, startY = path.Points[i], path.Points[i+1]
pdf.MoveTo(startX, startY)
i += 2
case draw2d.LineToCmp:
pdf.LineTo(path.Points[... | go | {
"resource": ""
} |
q179524 | Main | test | func Main(gc draw2d.GraphicContext, ext string) (string, error) {
// Draw the line
const offset = 75.0
x := 35.0
caps := []draw2d.LineCap{draw2d.ButtCap, draw2d.SquareCap, draw2d.RoundCap}
joins := []draw2d.LineJoin{draw2d.BevelJoin, draw2d.MiterJoin, draw2d.RoundJoin}
for i := range caps {
Draw(gc, caps[i], jo... | go | {
"resource": ""
} |
q179525 | Draw | test | func Draw(gc draw2d.GraphicContext, cap draw2d.LineCap, join draw2d.LineJoin,
x0, y0, x1, y1, offset float64) {
gc.SetLineCap(cap)
gc.SetLineJoin(join)
// Draw thick line
gc.SetStrokeColor(color.NRGBA{0x33, 0x33, 0x33, 0xFF})
gc.SetLineWidth(30.0)
gc.MoveTo(x0, y0)
gc.LineTo((x0+x1)/2+offset, (y0+y1)/2)
gc.Li... | go | {
"resource": ""
} |
q179526 | DrawContour | test | func DrawContour(path draw2d.PathBuilder, ps []truetype.Point, dx, dy float64) {
if len(ps) == 0 {
return
}
startX, startY := pointToF64Point(ps[0])
path.MoveTo(startX+dx, startY+dy)
q0X, q0Y, on0 := startX, startY, true
for _, p := range ps[1:] {
qX, qY := pointToF64Point(p)
on := p.Flags&0x01 != 0
if on... | go | {
"resource": ""
} |
q179527 | Flatten | test | func Flatten(path *draw2d.Path, flattener Flattener, scale float64) {
// First Point
var startX, startY float64 = 0, 0
// Current Point
var x, y float64 = 0, 0
i := 0
for _, cmp := range path.Components {
switch cmp {
case draw2d.MoveToCmp:
x, y = path.Points[i], path.Points[i+1]
startX, startY = x, y
... | go | {
"resource": ""
} |
q179528 | Clear | test | func (gc *GraphicContext) Clear() {
width, height := gc.img.Bounds().Dx(), gc.img.Bounds().Dy()
gc.ClearRect(0, 0, width, height)
} | go | {
"resource": ""
} |
q179529 | ClearRect | test | func (gc *GraphicContext) ClearRect(x1, y1, x2, y2 int) {
imageColor := image.NewUniform(gc.Current.FillColor)
draw.Draw(gc.img, image.Rect(x1, y1, x2, y2), imageColor, image.ZP, draw.Over)
} | go | {
"resource": ""
} |
q179530 | DrawImage | test | func DrawImage(src image.Image, dest draw.Image, tr draw2d.Matrix, op draw.Op, filter ImageFilter) {
var transformer draw.Transformer
switch filter {
case LinearFilter:
transformer = draw.NearestNeighbor
case BilinearFilter:
transformer = draw.BiLinear
case BicubicFilter:
transformer = draw.CatmullRom
}
tr... | go | {
"resource": ""
} |
q179531 | Main | test | func Main(gc draw2d.GraphicContext, ext string) (string, error) {
// Margin between the image and the frame
const margin = 30
// Line width od the frame
const lineWidth = 3
// Gopher image
gopher := samples.Resource("image", "gopher.png", ext)
// Draw gopher
err := Draw(gc, gopher, 297, 210, margin, lineWidth... | go | {
"resource": ""
} |
q179532 | Draw | test | func Draw(gc draw2d.GraphicContext, png string,
dw, dh, margin, lineWidth float64) error {
// Draw frame
draw2dkit.RoundedRectangle(gc, lineWidth, lineWidth, dw-lineWidth, dh-lineWidth, 100, 100)
gc.SetLineWidth(lineWidth)
gc.FillStroke()
// load the source image
source, err := draw2dimg.LoadFromPngFile(png)
i... | go | {
"resource": ""
} |
q179533 | Draw | test | func Draw(gc draw2d.GraphicContext, x, y float64) {
// set the fill and stroke color of the droid
gc.SetFillColor(color.RGBA{0x44, 0xff, 0x44, 0xff})
gc.SetStrokeColor(color.RGBA{0x44, 0x44, 0x44, 0xff})
// set line properties
gc.SetLineCap(draw2d.RoundCap)
gc.SetLineWidth(5)
// head
gc.MoveTo(x+30, y+70)
gc... | go | {
"resource": ""
} |
q179534 | ChecksumString32S | test | func ChecksumString32S(s string, seed uint32) uint32 {
if len(s) == 0 {
return Checksum32S(nil, seed)
}
ss := (*reflect.StringHeader)(unsafe.Pointer(&s))
return Checksum32S((*[maxInt32]byte)(unsafe.Pointer(ss.Data))[:len(s):len(s)], seed)
} | go | {
"resource": ""
} |
q179535 | ChecksumString64S | test | func ChecksumString64S(s string, seed uint64) uint64 {
if len(s) == 0 {
return Checksum64S(nil, seed)
}
ss := (*reflect.StringHeader)(unsafe.Pointer(&s))
return Checksum64S((*[maxInt32]byte)(unsafe.Pointer(ss.Data))[:len(s):len(s)], seed)
} | go | {
"resource": ""
} |
q179536 | NewS32 | test | func NewS32(seed uint32) (xx *XXHash32) {
xx = &XXHash32{
seed: seed,
}
xx.Reset()
return
} | go | {
"resource": ""
} |
q179537 | NewS64 | test | func NewS64(seed uint64) (xx *XXHash64) {
xx = &XXHash64{
seed: seed,
}
xx.Reset()
return
} | go | {
"resource": ""
} |
q179538 | round64 | test | func round64(h, v uint64) uint64 {
h += v * prime64x2
h = rotl64_31(h)
h *= prime64x1
return h
} | go | {
"resource": ""
} |
q179539 | Checksum32S | test | func Checksum32S(in []byte, seed uint32) (h uint32) {
var i int
if len(in) > 15 {
var (
v1 = seed + prime32x1 + prime32x2
v2 = seed + prime32x2
v3 = seed + 0
v4 = seed - prime32x1
)
for ; i < len(in)-15; i += 16 {
in := in[i : i+16 : len(in)]
v1 += u32(in[0:4:len(in)]) * prime32x2
v1 = rot... | go | {
"resource": ""
} |
q179540 | Checksum64S | test | func Checksum64S(in []byte, seed uint64) uint64 {
if len(in) == 0 && seed == 0 {
return 0xef46db3751d8e999
}
if len(in) > 31 {
return checksum64(in, seed)
}
return checksum64Short(in, seed)
} | go | {
"resource": ""
} |
q179541 | getStage | test | func getStage() (stage int, advanceStage func() error, resetEnv func() error) {
var origValue string
stage = 0
daemonStage := os.Getenv(stageVar)
stageTag := strings.SplitN(daemonStage, ":", 2)
stageInfo := strings.SplitN(stageTag[0], "/", 3)
if len(stageInfo) == 3 {
stageStr, tm, check := stageInfo[0], stage... | go | {
"resource": ""
} |
q179542 | New | test | func New() *Glg {
g := &Glg{
levelCounter: new(uint32),
buffer: sync.Pool{
New: func() interface{} {
return bytes.NewBuffer(make([]byte, 0, bufferSize))
},
},
}
atomic.StoreUint32(g.levelCounter, uint32(FATAL))
for lev, log := range map[LEVEL]*logger{
// standard out
PRINT: {
std: os.S... | go | {
"resource": ""
} |
q179543 | Get | test | func Get() *Glg {
once.Do(func() {
fastime.SetFormat(timeFormat)
glg = New()
})
return glg
} | go | {
"resource": ""
} |
q179544 | SetMode | test | func (g *Glg) SetMode(mode MODE) *Glg {
g.logger.Range(func(key, val interface{}) bool {
l := val.(*logger)
l.mode = mode
l.updateMode()
g.logger.Store(key.(LEVEL), l)
return true
})
return g
} | go | {
"resource": ""
} |
q179545 | SetPrefix | test | func (g *Glg) SetPrefix(pref string) *Glg {
v, ok := g.logger.Load(PRINT)
if ok {
value := v.(*logger)
value.tag = pref
g.logger.Store(PRINT, value)
}
return g
} | go | {
"resource": ""
} |
q179546 | GetCurrentMode | test | func (g *Glg) GetCurrentMode(level LEVEL) MODE {
l, ok := g.logger.Load(level)
if ok {
return l.(*logger).mode
}
return NONE
} | go | {
"resource": ""
} |
q179547 | InitWriter | test | func (g *Glg) InitWriter() *Glg {
g.logger.Range(func(key, val interface{}) bool {
l := val.(*logger)
l.writer = nil
l.updateMode()
g.logger.Store(key.(LEVEL), l)
return true
})
return g
} | go | {
"resource": ""
} |
q179548 | SetWriter | test | func (g *Glg) SetWriter(writer io.Writer) *Glg {
if writer == nil {
return g
}
g.logger.Range(func(key, val interface{}) bool {
l := val.(*logger)
l.writer = writer
l.updateMode()
g.logger.Store(key.(LEVEL), l)
return true
})
return g
} | go | {
"resource": ""
} |
q179549 | SetLevelColor | test | func (g *Glg) SetLevelColor(level LEVEL, color func(string) string) *Glg {
lev, ok := g.logger.Load(level)
if ok {
l := lev.(*logger)
l.color = color
g.logger.Store(level, l)
}
return g
} | go | {
"resource": ""
} |
q179550 | SetLevelWriter | test | func (g *Glg) SetLevelWriter(level LEVEL, writer io.Writer) *Glg {
if writer == nil {
return g
}
lev, ok := g.logger.Load(level)
if ok {
l := lev.(*logger)
l.writer = writer
l.updateMode()
g.logger.Store(level, l)
}
return g
} | go | {
"resource": ""
} |
q179551 | AddStdLevel | test | func (g *Glg) AddStdLevel(tag string, mode MODE, isColor bool) *Glg {
atomic.AddUint32(g.levelCounter, 1)
lev := LEVEL(atomic.LoadUint32(g.levelCounter))
g.levelMap.Store(tag, lev)
l := &logger{
writer: nil,
std: os.Stdout,
color: Colorless,
isColor: isColor,
mode: mode,
tag: tag,
}
l.up... | go | {
"resource": ""
} |
q179552 | EnableColor | test | func (g *Glg) EnableColor() *Glg {
g.logger.Range(func(key, val interface{}) bool {
l := val.(*logger)
l.isColor = true
l.updateMode()
g.logger.Store(key.(LEVEL), l)
return true
})
return g
} | go | {
"resource": ""
} |
q179553 | EnableLevelColor | test | func (g *Glg) EnableLevelColor(lv LEVEL) *Glg {
ins, ok := g.logger.Load(lv)
if ok {
l := ins.(*logger)
l.isColor = true
l.updateMode()
g.logger.Store(lv, l)
}
return g
} | go | {
"resource": ""
} |
q179554 | DisableLevelColor | test | func (g *Glg) DisableLevelColor(lv LEVEL) *Glg {
ins, ok := g.logger.Load(lv)
if ok {
l := ins.(*logger)
l.isColor = false
l.updateMode()
g.logger.Store(lv, l)
}
return g
} | go | {
"resource": ""
} |
q179555 | RawString | test | func (g *Glg) RawString(data []byte) string {
str := *(*string)(unsafe.Pointer(&data))
return str[strings.Index(str, sep)+sepl : len(str)-rcl]
} | go | {
"resource": ""
} |
q179556 | TagStringToLevel | test | func (g *Glg) TagStringToLevel(tag string) LEVEL {
l, ok := g.levelMap.Load(tag)
if !ok {
return 255
}
return l.(LEVEL)
} | go | {
"resource": ""
} |
q179557 | Println | test | func Println(val ...interface{}) error {
return glg.out(PRINT, blankFormat(len(val)), val...)
} | go | {
"resource": ""
} |
q179558 | Fatal | test | func (g *Glg) Fatal(val ...interface{}) {
err := g.out(FATAL, blankFormat(len(val)), val...)
if err != nil {
err = g.Error(err.Error())
if err != nil {
panic(err)
}
}
exit(1)
} | go | {
"resource": ""
} |
q179559 | Fatalf | test | func (g *Glg) Fatalf(format string, val ...interface{}) {
err := g.out(FATAL, format, val...)
if err != nil {
err = g.Error(err.Error())
if err != nil {
panic(err)
}
}
exit(1)
} | go | {
"resource": ""
} |
q179560 | isModeEnable | test | func (g *Glg) isModeEnable(l LEVEL) bool {
return g.GetCurrentMode(l) != NONE
} | go | {
"resource": ""
} |
q179561 | CaptureMetrics | test | func CaptureMetrics(hnd http.Handler, w http.ResponseWriter, r *http.Request) Metrics {
return CaptureMetricsFn(w, func(ww http.ResponseWriter) {
hnd.ServeHTTP(ww, r)
})
} | go | {
"resource": ""
} |
q179562 | get | test | func (da *cedar) get(key []byte, from, pos int) *int {
for ; pos < len(key); pos++ {
if value := da.Array[from].Value; value >= 0 && value != ValueLimit {
to := da.follow(from, 0)
da.Array[to].Value = value
}
from = da.follow(from, key[pos])
}
to := from
if da.Array[from].Value < 0 {
to = da.follow(fr... | go | {
"resource": ""
} |
q179563 | Save | test | func (da *Cedar) Save(out io.Writer, dataType string) error {
switch dataType {
case "gob", "GOB":
dataEecoder := gob.NewEncoder(out)
return dataEecoder.Encode(da.cedar)
case "json", "JSON":
dataEecoder := json.NewEncoder(out)
return dataEecoder.Encode(da.cedar)
}
return ErrInvalidDataType
} | go | {
"resource": ""
} |
q179564 | SaveToFile | test | func (da *Cedar) SaveToFile(fileName string, dataType string) error {
file, err := os.OpenFile(fileName, os.O_CREATE|os.O_WRONLY, 0666)
if err != nil {
return err
}
defer file.Close()
out := bufio.NewWriter(file)
defer out.Flush()
da.Save(out, dataType)
return nil
} | go | {
"resource": ""
} |
q179565 | Load | test | func (da *Cedar) Load(in io.Reader, dataType string) error {
switch dataType {
case "gob", "GOB":
dataDecoder := gob.NewDecoder(in)
return dataDecoder.Decode(da.cedar)
case "json", "JSON":
dataDecoder := json.NewDecoder(in)
return dataDecoder.Decode(da.cedar)
}
return ErrInvalidDataType
} | go | {
"resource": ""
} |
q179566 | LoadFromFile | test | func (da *Cedar) LoadFromFile(fileName string, dataType string) error {
file, err := os.OpenFile(fileName, os.O_RDONLY, 0600)
defer file.Close()
if err != nil {
return err
}
in := bufio.NewReader(file)
return da.Load(in, dataType)
} | go | {
"resource": ""
} |
q179567 | Key | test | func (da *Cedar) Key(id int) (key []byte, err error) {
for id > 0 {
from := da.Array[id].Check
if from < 0 {
return nil, ErrNoPath
}
if char := byte(da.Array[from].base() ^ id); char != 0 {
key = append(key, char)
}
id = from
}
if id != 0 || len(key) == 0 {
return nil, ErrInvalidKey
}
for i := ... | go | {
"resource": ""
} |
q179568 | Value | test | func (da *Cedar) Value(id int) (value int, err error) {
value = da.Array[id].Value
if value >= 0 {
return value, nil
}
to := da.Array[id].base()
if da.Array[to].Check == id && da.Array[to].Value >= 0 {
return da.Array[to].Value, nil
}
return 0, ErrNoValue
} | go | {
"resource": ""
} |
q179569 | Delete | test | func (da *Cedar) Delete(key []byte) error {
// if the path does not exist, or the end is not a leaf, nothing to delete
to, err := da.Jump(key, 0)
if err != nil {
return ErrNoPath
}
if da.Array[to].Value < 0 {
base := da.Array[to].base()
if da.Array[base].Check == to {
to = base
}
}
for to > 0 {
fr... | go | {
"resource": ""
} |
q179570 | Set | test | func (v *Version) Set(version string) error {
metadata := splitOff(&version, "+")
preRelease := PreRelease(splitOff(&version, "-"))
dotParts := strings.SplitN(version, ".", 3)
if len(dotParts) != 3 {
return fmt.Errorf("%s is not in dotted-tri format", version)
}
if err := validateIdentifier(string(preRelease)... | go | {
"resource": ""
} |
q179571 | Compare | test | func (v Version) Compare(versionB Version) int {
if cmp := recursiveCompare(v.Slice(), versionB.Slice()); cmp != 0 {
return cmp
}
return preReleaseCompare(v, versionB)
} | go | {
"resource": ""
} |
q179572 | Slice | test | func (v Version) Slice() []int64 {
return []int64{v.Major, v.Minor, v.Patch}
} | go | {
"resource": ""
} |
q179573 | BumpMajor | test | func (v *Version) BumpMajor() {
v.Major += 1
v.Minor = 0
v.Patch = 0
v.PreRelease = PreRelease("")
v.Metadata = ""
} | go | {
"resource": ""
} |
q179574 | BumpMinor | test | func (v *Version) BumpMinor() {
v.Minor += 1
v.Patch = 0
v.PreRelease = PreRelease("")
v.Metadata = ""
} | go | {
"resource": ""
} |
q179575 | BumpPatch | test | func (v *Version) BumpPatch() {
v.Patch += 1
v.PreRelease = PreRelease("")
v.Metadata = ""
} | go | {
"resource": ""
} |
q179576 | validateIdentifier | test | func validateIdentifier(id string) error {
if id != "" && !reIdentifier.MatchString(id) {
return fmt.Errorf("%s is not a valid semver identifier", id)
}
return nil
} | go | {
"resource": ""
} |
q179577 | newStream | test | func newStream(bufsize int, replay bool) *Stream {
return &Stream{
AutoReplay: replay,
subscribers: make([]*Subscriber, 0),
register: make(chan *Subscriber),
deregister: make(chan *Subscriber),
event: make(chan *Event, bufsize),
quit: make(chan bool),
Eventlog: make(EventLog, 0),
}
... | go | {
"resource": ""
} |
q179578 | addSubscriber | test | func (str *Stream) addSubscriber(eventid string) *Subscriber {
sub := &Subscriber{
eventid: eventid,
quit: str.deregister,
connection: make(chan *Event, 64),
}
str.register <- sub
return sub
} | go | {
"resource": ""
} |
q179579 | New | test | func New() *Server {
return &Server{
BufferSize: DefaultBufferSize,
AutoStream: false,
AutoReplay: true,
Streams: make(map[string]*Stream),
}
} | go | {
"resource": ""
} |
q179580 | Close | test | func (s *Server) Close() {
s.mu.Lock()
defer s.mu.Unlock()
for id := range s.Streams {
s.Streams[id].quit <- true
delete(s.Streams, id)
}
} | go | {
"resource": ""
} |
q179581 | CreateStream | test | func (s *Server) CreateStream(id string) *Stream {
s.mu.Lock()
defer s.mu.Unlock()
if s.Streams[id] != nil {
return s.Streams[id]
}
str := newStream(s.BufferSize, s.AutoReplay)
str.run()
s.Streams[id] = str
return str
} | go | {
"resource": ""
} |
q179582 | RemoveStream | test | func (s *Server) RemoveStream(id string) {
s.mu.Lock()
defer s.mu.Unlock()
if s.Streams[id] != nil {
s.Streams[id].close()
delete(s.Streams, id)
}
} | go | {
"resource": ""
} |
q179583 | StreamExists | test | func (s *Server) StreamExists(id string) bool {
s.mu.Lock()
defer s.mu.Unlock()
return s.Streams[id] != nil
} | go | {
"resource": ""
} |
q179584 | Publish | test | func (s *Server) Publish(id string, event *Event) {
s.mu.Lock()
defer s.mu.Unlock()
if s.Streams[id] != nil {
s.Streams[id].event <- s.process(event)
}
} | go | {
"resource": ""
} |
q179585 | NewClient | test | func NewClient(url string) *Client {
return &Client{
URL: url,
Connection: &http.Client{},
Headers: make(map[string]string),
subscribed: make(map[chan *Event]chan bool),
}
} | go | {
"resource": ""
} |
q179586 | Subscribe | test | func (c *Client) Subscribe(stream string, handler func(msg *Event)) error {
operation := func() error {
resp, err := c.request(stream)
if err != nil {
return err
}
defer resp.Body.Close()
reader := NewEventStreamReader(resp.Body)
for {
// Read each new line and process the type of event
event, e... | go | {
"resource": ""
} |
q179587 | SubscribeChan | test | func (c *Client) SubscribeChan(stream string, ch chan *Event) error {
var connected bool
errch := make(chan error)
c.mu.Lock()
c.subscribed[ch] = make(chan bool)
c.mu.Unlock()
go func() {
operation := func() error {
resp, err := c.request(stream)
if err != nil {
c.cleanup(resp, ch)
return err
... | go | {
"resource": ""
} |
q179588 | SubscribeRaw | test | func (c *Client) SubscribeRaw(handler func(msg *Event)) error {
return c.Subscribe("", handler)
} | go | {
"resource": ""
} |
q179589 | Unsubscribe | test | func (c *Client) Unsubscribe(ch chan *Event) {
c.mu.Lock()
defer c.mu.Unlock()
if c.subscribed[ch] != nil {
c.subscribed[ch] <- true
}
} | go | {
"resource": ""
} |
q179590 | NewEventStreamReader | test | func NewEventStreamReader(eventStream io.Reader) *EventStreamReader {
scanner := bufio.NewScanner(eventStream)
split := func(data []byte, atEOF bool) (int, []byte, error) {
if atEOF && len(data) == 0 {
return 0, nil, nil
}
// We have a full event payload to parse.
if i := bytes.Index(data, []byte("\r\n\r\... | go | {
"resource": ""
} |
q179591 | ReadEvent | test | func (e *EventStreamReader) ReadEvent() ([]byte, error) {
if e.scanner.Scan() {
event := e.scanner.Bytes()
return event, nil
}
if err := e.scanner.Err(); err != nil {
return nil, err
}
return nil, io.EOF
} | go | {
"resource": ""
} |
q179592 | HTTPHandler | test | func (s *Server) HTTPHandler(w http.ResponseWriter, r *http.Request) {
flusher, err := w.(http.Flusher)
if !err {
http.Error(w, "Streaming unsupported!", http.StatusInternalServerError)
return
}
w.Header().Set("Content-Type", "text/event-stream")
w.Header().Set("Cache-Control", "no-cache")
w.Header().Set("Co... | go | {
"resource": ""
} |
q179593 | Add | test | func (e *EventLog) Add(ev *Event) {
ev.ID = []byte(e.currentindex())
ev.timestamp = time.Now()
(*e) = append((*e), ev)
} | go | {
"resource": ""
} |
q179594 | Replay | test | func (e *EventLog) Replay(s *Subscriber) {
for i := 0; i < len((*e)); i++ {
if string((*e)[i].ID) >= s.eventid {
s.connection <- (*e)[i]
}
}
} | go | {
"resource": ""
} |
q179595 | readKey | test | func readKey(path string) (crypto.Signer, error) {
b, err := ioutil.ReadFile(path)
if err != nil {
return nil, err
}
d, _ := pem.Decode(b)
if d == nil {
return nil, fmt.Errorf("no block found in %q", path)
}
switch d.Type {
case rsaPrivateKey:
return x509.ParsePKCS1PrivateKey(d.Bytes)
case ecPrivateKey:
... | go | {
"resource": ""
} |
q179596 | writeKey | test | func writeKey(path string, k *ecdsa.PrivateKey) error {
f, err := os.OpenFile(path, os.O_WRONLY|os.O_CREATE|os.O_TRUNC, 0600)
if err != nil {
return err
}
bytes, err := x509.MarshalECPrivateKey(k)
if err != nil {
return err
}
b := &pem.Block{Type: ecPrivateKey, Bytes: bytes}
if err := pem.Encode(f, b); err ... | go | {
"resource": ""
} |
q179597 | anyKey | test | func anyKey(filename string, gen bool) (crypto.Signer, error) {
k, err := readKey(filename)
if err == nil {
return k, nil
}
if !os.IsNotExist(err) || !gen {
return nil, err
}
ecKey, err := ecdsa.GenerateKey(elliptic.P256(), rand.Reader)
if err != nil {
return nil, err
}
return ecKey, writeKey(filename, e... | go | {
"resource": ""
} |
q179598 | sameDir | test | func sameDir(existing, filename string) string {
return filepath.Join(filepath.Dir(existing), filename)
} | go | {
"resource": ""
} |
q179599 | printAccount | test | func printAccount(w io.Writer, a *acme.Account, kp string) {
tw := tabwriter.NewWriter(w, 0, 8, 0, '\t', 0)
fmt.Fprintln(tw, "URI:\t", a.URI)
fmt.Fprintln(tw, "Key:\t", kp)
fmt.Fprintln(tw, "Contact:\t", strings.Join(a.Contact, ", "))
fmt.Fprintln(tw, "Terms:\t", a.CurrentTerms)
agreed := a.AgreedTerms
if a.Agre... | go | {
"resource": ""
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.