_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.pdf.MoveTo(x-left-margin, y+top)
gc.pdf.CellFormat(w, h, text, "", 0, "BL", false, 0, "")
return w
} | 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.FontStyleItalic})
// Set the fill text color to black
gc.SetFillColor(image.Black)
gc.SetFontSize(14)
// Display Hello World
gc.FillStringAt("Hello World", 8, 52)
} | 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()
if err != nil {
return err
}
return nil
} | 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 filename
return samples.Output("postscript", ext), nil
} | 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.NewInterpreter(gc)
interpreter.Execute(reader)
} | 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.QuadCurveTo(x+sx*100, y+sy*75, x+sx*100, y+sy*37.5)
gc.QuadCurveTo(x+sx*100, y, x+sx*50, y)
gc.Stroke()
} | 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.MoveTo(x+sx*60.0, y)
gc.LineTo(x+sx*60.0, y)
gc.LineTo(x+sx*162, y+sy*205)
rLineTo(gc, sx*-102.4, 0)
gc.CubicCurveTo(x+sx*-17, y+sy*205, x+sx*-17, y+sy*103, x+sx*60.0, y+sy*103.0)
gc.Stroke()
gc.SetLineDash(nil, 0.0)
} | 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(width / 10)
gc.MoveTo(x0, y0)
gc.CubicCurveTo(x1, y1, x2, y2, x3, y3)
gc.Stroke()
gc.SetStrokeColor(color.NRGBA{0xFF, 0x33, 0x33, 0x88})
gc.SetLineWidth(width / 20)
// draw segment of curve
gc.MoveTo(x0, y0)
gc.LineTo(x1, y1)
gc.LineTo(x2, y2)
gc.LineTo(x3, y3)
gc.Stroke()
} | 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*51.2, sy*51.2)
rLineTo(gc, sx*-51.2, sy*51.2)
rLineTo(gc, sx*-51.2, sy*-51.2)
gc.Close()
gc.SetLineWidth(width / 20.0)
gc.SetFillColor(color.NRGBA{0, 0, 0xFF, 0xFF})
gc.SetStrokeColor(image.Black)
gc.FillStroke()
} | 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, sx*40, sy*40, 0, -2*math.Pi)
gc.SetFillRule(draw2d.FillRuleEvenOdd)
gc.SetFillColor(color.NRGBA{0, 0xB2, 0, 0xFF})
gc.SetStrokeColor(image.Black)
gc.FillStroke(&wheel1, &wheel2)
draw2dkit.Rectangle(gc, x, y+sy*140, x+sx*232, y+sy*198)
wheel1.Clear()
wheel1.ArcTo(x+sx*52, y+sy*198, sx*40, sy*40, 0, 2*math.Pi)
wheel2.Clear()
wheel2.ArcTo(x+sx*180, y+sy*198, sx*40, sy*40, 0, -2*math.Pi)
gc.SetFillRule(draw2d.FillRuleWinding)
gc.SetFillColor(color.NRGBA{0, 0, 0xE5, 0xFF})
gc.FillStroke(&wheel1, &wheel2)
} | 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 / 180.0)) // Rotate by degrees on stack from 'for'
gc.MoveTo(0, 0)
gc.LineTo(width/2, 0)
gc.Stroke()
gc.Restore()
}
gc.Restore()
} | 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, 0x80, 0xFF, 0xFF})
x += dx
Dash(gc, x, y, w, h)
x += dx
Arc(gc, x, y, w, h)
x = x0
y += dy
ArcNegative(gc, x, y, w, h)
x += dx
CubicCurve(gc, x, y, w, h)
x += dx
FillString(gc, x, y, w, h)
x += dx
FillStroke(gc, x, y, w, h)
x = x0
y += dy
FillStyle(gc, x, y, w, h)
x += dx
PathTransform(gc, x, y, w, h)
x += dx
Star(gc, x, y, w, h)
x += dx
gopher2.Draw(gc, x, y, w, h/2)
} | 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[i], path.Points[i+1])
i += 2
case draw2d.QuadCurveToCmp:
pdf.CurveTo(path.Points[i], path.Points[i+1], path.Points[i+2], path.Points[i+3])
i += 4
case draw2d.CubicCurveToCmp:
pdf.CurveBezierCubicTo(path.Points[i], path.Points[i+1], path.Points[i+2], path.Points[i+3], path.Points[i+4], path.Points[i+5])
i += 6
case draw2d.ArcToCmp:
pdf.ArcTo(path.Points[i], path.Points[i+1], path.Points[i+2], path.Points[i+3],
0, // degRotate
path.Points[i+4]*deg, // degStart = startAngle
(path.Points[i+4]-path.Points[i+5])*deg) // degEnd = startAngle-angle
i += 6
case draw2d.CloseCmp:
pdf.LineTo(startX, startY)
pdf.ClosePath()
}
}
} | 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], joins[i], x, 50, x, 160, offset)
x += offset
}
// Return the output filename
return samples.Output("linecapjoin", ext), nil
} | 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.LineTo(x1, y1)
gc.Stroke()
// Draw thin helping line
gc.SetStrokeColor(color.NRGBA{0xFF, 0x33, 0x33, 0xFF})
gc.SetLineWidth(2.56)
gc.MoveTo(x0, y0)
gc.LineTo((x0+x1)/2+offset, (y0+y1)/2)
gc.LineTo(x1, y1)
gc.Stroke()
} | 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 {
if on0 {
path.LineTo(qX+dx, qY+dy)
} else {
path.QuadCurveTo(q0X+dx, q0Y+dy, qX+dx, qY+dy)
}
} else {
if on0 {
// No-op.
} else {
midX := (q0X + qX) / 2
midY := (q0Y + qY) / 2
path.QuadCurveTo(q0X+dx, q0Y+dy, midX+dx, midY+dy)
}
}
q0X, q0Y, on0 = qX, qY, on
}
// Close the curve.
if on0 {
path.LineTo(startX+dx, startY+dy)
} else {
path.QuadCurveTo(q0X+dx, q0Y+dy, startX+dx, startY+dy)
}
} | 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
if i != 0 {
flattener.End()
}
flattener.MoveTo(x, y)
i += 2
case draw2d.LineToCmp:
x, y = path.Points[i], path.Points[i+1]
flattener.LineTo(x, y)
flattener.LineJoin()
i += 2
case draw2d.QuadCurveToCmp:
TraceQuad(flattener, path.Points[i-2:], 0.5)
x, y = path.Points[i+2], path.Points[i+3]
flattener.LineTo(x, y)
i += 4
case draw2d.CubicCurveToCmp:
TraceCubic(flattener, path.Points[i-2:], 0.5)
x, y = path.Points[i+4], path.Points[i+5]
flattener.LineTo(x, y)
i += 6
case draw2d.ArcToCmp:
x, y = TraceArc(flattener, path.Points[i], path.Points[i+1], path.Points[i+2], path.Points[i+3], path.Points[i+4], path.Points[i+5], scale)
flattener.LineTo(x, y)
i += 6
case draw2d.CloseCmp:
flattener.LineTo(startX, startY)
flattener.Close()
}
}
flattener.End()
} | 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
}
transformer.Transform(dest, f64.Aff3{tr[0], tr[1], tr[4], tr[2], tr[3], tr[5]}, src, src.Bounds(), op, nil)
} | 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)
// Return the output filename
return samples.Output("frameimage", ext), err
} | 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)
if err != nil {
return err
}
// Size of source image
sw, sh := float64(source.Bounds().Dx()), float64(source.Bounds().Dy())
// Draw image to fit in the frame
// TODO Seems to have a transform bug here on draw image
scale := math.Min((dw-margin*2)/sw, (dh-margin*2)/sh)
gc.Save()
gc.Translate((dw-sw*scale)/2, (dh-sh*scale)/2)
gc.Scale(scale, scale)
gc.Rotate(0.2)
gc.DrawImage(source)
gc.Restore()
return nil
} | 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.ArcTo(x+80, y+70, 50, 50, 180*(math.Pi/180), 180*(math.Pi/180))
gc.Close()
gc.FillStroke()
gc.MoveTo(x+60, y+25)
gc.LineTo(x+50, y+10)
gc.MoveTo(x+100, y+25)
gc.LineTo(x+110, y+10)
gc.Stroke()
// left eye
draw2dkit.Circle(gc, x+60, y+45, 5)
gc.FillStroke()
// right eye
draw2dkit.Circle(gc, x+100, y+45, 5)
gc.FillStroke()
// body
draw2dkit.RoundedRectangle(gc, x+30, y+75, x+30+100, y+75+90, 10, 10)
gc.FillStroke()
draw2dkit.Rectangle(gc, x+30, y+75, x+30+100, y+75+80)
gc.FillStroke()
// left arm
draw2dkit.RoundedRectangle(gc, x+5, y+80, x+5+20, y+80+70, 10, 10)
gc.FillStroke()
// right arm
draw2dkit.RoundedRectangle(gc, x+135, y+80, x+135+20, y+80+70, 10, 10)
gc.FillStroke()
// left leg
draw2dkit.RoundedRectangle(gc, x+50, y+150, x+50+20, y+150+50, 10, 10)
gc.FillStroke()
// right leg
draw2dkit.RoundedRectangle(gc, x+90, y+150, x+90+20, y+150+50, 10, 10)
gc.FillStroke()
} | 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 = rotl32_13(v1) * prime32x1
v2 += u32(in[4:8:len(in)]) * prime32x2
v2 = rotl32_13(v2) * prime32x1
v3 += u32(in[8:12:len(in)]) * prime32x2
v3 = rotl32_13(v3) * prime32x1
v4 += u32(in[12:16:len(in)]) * prime32x2
v4 = rotl32_13(v4) * prime32x1
}
h = rotl32_1(v1) + rotl32_7(v2) + rotl32_12(v3) + rotl32_18(v4)
} else {
h = seed + prime32x5
}
h += uint32(len(in))
for ; i <= len(in)-4; i += 4 {
in := in[i : i+4 : len(in)]
h += u32(in[0:4:len(in)]) * prime32x3
h = rotl32_17(h) * prime32x4
}
for ; i < len(in); i++ {
h += uint32(in[i]) * prime32x5
h = rotl32_11(h) * prime32x1
}
h ^= h >> 15
h *= prime32x2
h ^= h >> 13
h *= prime32x3
h ^= h >> 16
return
} | 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], stageInfo[1], stageInfo[2]
hash := sha1.New()
hash.Write([]byte(stageStr + "/" + tm + "/"))
if check != hex.EncodeToString(hash.Sum([]byte{})) {
// This whole chunk is original data
origValue = daemonStage
} else {
stage, _ = strconv.Atoi(stageStr)
if len(stageTag) == 2 {
origValue = stageTag[1]
}
}
} else {
origValue = daemonStage
}
advanceStage = func() error {
base := fmt.Sprintf("%d/%09d/", stage+1, time.Now().Nanosecond())
hash := sha1.New()
hash.Write([]byte(base))
tag := base + hex.EncodeToString(hash.Sum([]byte{}))
if err := os.Setenv(stageVar, tag+":"+origValue); err != nil {
return fmt.Errorf("can't set %s: %s", stageVar, err)
}
return nil
}
resetEnv = func() error {
return os.Setenv(stageVar, origValue)
}
return stage, advanceStage, resetEnv
} | 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.Stdout,
color: Colorless,
isColor: true,
mode: STD,
},
LOG: {
std: os.Stdout,
color: Colorless,
isColor: true,
mode: STD,
},
INFO: {
std: os.Stdout,
color: Green,
isColor: true,
mode: STD,
},
DEBG: {
std: os.Stdout,
color: Purple,
isColor: true,
mode: STD,
},
OK: {
std: os.Stdout,
color: Cyan,
isColor: true,
mode: STD,
},
WARN: {
std: os.Stdout,
color: Orange,
isColor: true,
mode: STD,
},
// error out
ERR: {
std: os.Stderr,
color: Red,
isColor: true,
mode: STD,
},
FAIL: {
std: os.Stderr,
color: Red,
isColor: true,
mode: STD,
},
FATAL: {
std: os.Stderr,
color: Red,
isColor: true,
mode: STD,
},
} {
log.tag = lev.String()
log.updateMode()
g.logger.Store(lev, log)
}
return g
} | 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.updateMode()
g.logger.Store(lev, l)
return g
} | 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(from, 0)
}
return &da.Array[to].Value
} | 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 := 0; i < len(key)/2; i++ {
key[i], key[len(key)-i-1] = key[len(key)-i-1], key[i]
}
return key, nil
} | 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 {
from := da.Array[to].Check
base := da.Array[from].base()
label := byte(to ^ base)
// if `to` has sibling, remove `to` from the sibling list, then stop
if da.Ninfos[to].Sibling != 0 || da.Ninfos[from].Child != label {
// delete the label from the child ring first
da.popSibling(from, base, label)
// then release the current node `to` to the empty node ring
da.pushEnode(to)
break
}
// otherwise, just release the current node `to` to the empty node ring
da.pushEnode(to)
// then check its parent node
to = from
}
return nil
} | 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)); err != nil {
return fmt.Errorf("failed to validate pre-release: %v", err)
}
if err := validateIdentifier(metadata); err != nil {
return fmt.Errorf("failed to validate metadata: %v", err)
}
parsed := make([]int64, 3, 3)
for i, v := range dotParts[:3] {
val, err := strconv.ParseInt(v, 10, 64)
parsed[i] = val
if err != nil {
return err
}
}
v.Metadata = metadata
v.PreRelease = preRelease
v.Major = parsed[0]
v.Minor = parsed[1]
v.Patch = parsed[2]
return nil
} | 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, err := reader.ReadEvent()
if err != nil {
if err == io.EOF {
return nil
}
// run user specified disconnect function
if c.disconnectcb != nil {
c.disconnectcb(c)
}
return err
}
// If we get an error, ignore it.
if msg, err := c.processEvent(event); err == nil {
if len(msg.ID) > 0 {
c.EventID = string(msg.ID)
} else {
msg.ID = []byte(c.EventID)
}
handler(msg)
}
}
}
return backoff.Retry(operation, backoff.NewExponentialBackOff())
} | 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
}
if resp.StatusCode != 200 {
c.cleanup(resp, ch)
return errors.New("could not connect to stream")
}
if !connected {
errch <- nil
connected = true
}
reader := NewEventStreamReader(resp.Body)
for {
// Read each new line and process the type of event
event, err := reader.ReadEvent()
if err != nil {
if err == io.EOF {
c.cleanup(resp, ch)
return nil
}
// run user specified disconnect function
if c.disconnectcb != nil {
c.disconnectcb(c)
}
return err
}
// If we get an error, ignore it.
if msg, err := c.processEvent(event); err == nil {
if len(msg.ID) > 0 {
c.EventID = string(msg.ID)
} else {
msg.ID = []byte(c.EventID)
}
select {
case <-c.subscribed[ch]:
c.cleanup(resp, ch)
return nil
case ch <- msg:
// message sent
}
}
}
}
err := backoff.Retry(operation, backoff.NewExponentialBackOff())
if err != nil && !connected {
errch <- err
}
}()
err := <-errch
close(errch)
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\n")); i >= 0 {
return i + 1, data[0:i], nil
}
if i := bytes.Index(data, []byte("\r\r")); i >= 0 {
return i + 1, data[0:i], nil
}
if i := bytes.Index(data, []byte("\n\n")); i >= 0 {
return i + 1, data[0:i], nil
}
// If we're at EOF, we have all of the data.
if atEOF {
return len(data), data, nil
}
// Request more data.
return 0, nil, nil
}
// Set the split function for the scanning operation.
scanner.Split(split)
return &EventStreamReader{
scanner: scanner,
}
} | 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("Connection", "keep-alive")
w.Header().Set("Access-Control-Allow-Origin", "*")
// Get the StreamID from the URL
streamID := r.URL.Query().Get("stream")
if streamID == "" {
http.Error(w, "Please specify a stream!", http.StatusInternalServerError)
return
}
stream := s.getStream(streamID)
if stream == nil && !s.AutoStream {
http.Error(w, "Stream not found!", http.StatusInternalServerError)
return
} else if stream == nil && s.AutoStream {
stream = s.CreateStream(streamID)
}
eventid := r.Header.Get("Last-Event-ID")
if eventid == "" {
eventid = "0"
}
// Create the stream subscriber
sub := stream.addSubscriber(eventid)
defer sub.close()
notify := w.(http.CloseNotifier).CloseNotify()
go func() {
<-notify
sub.close()
}()
// Push events to client
for {
select {
case ev, ok := <-sub.connection:
if !ok {
return
}
// If the data buffer is an empty string abort.
if len(ev.Data) == 0 {
break
}
// if the event has expired, dont send it
if s.EventTTL != 0 && time.Now().After(ev.timestamp.Add(s.EventTTL)) {
continue
}
fmt.Fprintf(w, "id: %s\n", ev.ID)
fmt.Fprintf(w, "data: %s\n", ev.Data)
if len(ev.Event) > 0 {
fmt.Fprintf(w, "event: %s\n", ev.Event)
}
if len(ev.Retry) > 0 {
fmt.Fprintf(w, "retry: %s\n", ev.Retry)
}
fmt.Fprint(w, "\n")
flusher.Flush()
}
}
} | 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:
return x509.ParseECPrivateKey(d.Bytes)
default:
return nil, fmt.Errorf("%q is unsupported", d.Type)
}
} | 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 != nil {
f.Close()
return err
}
return f.Close()
} | 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, ecKey)
} | 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.AgreedTerms == "" {
agreed = "no"
} else if a.AgreedTerms == a.CurrentTerms {
agreed = "yes"
}
fmt.Fprintln(tw, "Accepted:\t", agreed)
// TODO: print authorization and certificates
tw.Flush()
} | go | {
"resource": ""
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.