_id stringlengths 2 7 | title stringlengths 1 118 | partition stringclasses 3
values | text stringlengths 52 85.5k | language stringclasses 1
value | meta_information dict |
|---|---|---|---|---|---|
q9700 | FeedBits | train | func (br *bitReader) FeedBits(nb uint) {
if br.bufRd != nil {
br.discardBits += int(br.fedBits - br.numBits)
for {
if len(br.bufPeek) == 0 {
br.fedBits = br.numBits // Don't discard bits just added
br.FlushOffset()
var err error
cntPeek := 8 // Minimum Peek amount to make progress
if br.buf... | go | {
"resource": ""
} |
q9701 | ReadBits | train | func (br *bitReader) ReadBits(nb uint) uint {
br.FeedBits(nb)
val := uint(br.bufBits & uint64(1<<nb-1))
br.bufBits >>= nb
br.numBits -= nb
return val
} | go | {
"resource": ""
} |
q9702 | ReadSymbol | train | func (br *bitReader) ReadSymbol(pd *prefixDecoder) uint {
if len(pd.chunks) == 0 {
errors.Panic(errInvalid) // Decode with empty tree
}
nb := uint(pd.minBits)
for {
br.FeedBits(nb)
chunk := pd.chunks[uint32(br.bufBits)&pd.chunkMask]
nb = uint(chunk & prefixCountMask)
if nb > uint(pd.chunkBits) {
linkI... | go | {
"resource": ""
} |
q9703 | ReadOffset | train | func (br *bitReader) ReadOffset(sym uint, rcs []rangeCode) uint {
rc := rcs[sym]
return uint(rc.base) + br.ReadBits(uint(rc.bits))
} | go | {
"resource": ""
} |
q9704 | ReadPrefixCode | train | func (br *bitReader) ReadPrefixCode(pd *prefixDecoder, maxSyms uint) {
hskip := br.ReadBits(2)
if hskip == 1 {
br.readSimplePrefixCode(pd, maxSyms)
} else {
br.readComplexPrefixCode(pd, maxSyms, hskip)
}
} | go | {
"resource": ""
} |
q9705 | readSimplePrefixCode | train | func (br *bitReader) readSimplePrefixCode(pd *prefixDecoder, maxSyms uint) {
var codes [4]prefixCode
nsym := int(br.ReadBits(2)) + 1
clen := neededBits(uint32(maxSyms))
for i := 0; i < nsym; i++ {
codes[i].sym = uint32(br.ReadBits(clen))
}
copyLens := func(lens []uint) {
for i := 0; i < nsym; i++ {
codes[... | go | {
"resource": ""
} |
q9706 | readComplexPrefixCode | train | func (br *bitReader) readComplexPrefixCode(pd *prefixDecoder, maxSyms, hskip uint) {
// Read the code-lengths prefix table.
var codeCLensArr [len(complexLens)]prefixCode // Sorted, but may have holes
sum := 32
for _, sym := range complexLens[hskip:] {
clen := br.ReadSymbol(&decCLens)
if clen > 0 {
codeCLensA... | go | {
"resource": ""
} |
q9707 | Apply | train | func (cs Checksums) Apply(d []byte) []byte {
d = append([]byte(nil), d...)
for _, c := range cs {
setU32(d, c.Offset, c.Value)
}
return d
} | go | {
"resource": ""
} |
q9708 | Verify | train | func (cs Checksums) Verify(d []byte) bool {
for _, c := range cs {
if getU32(d, c.Offset) != c.Value {
return false
}
}
return true
} | go | {
"resource": ""
} |
q9709 | Length | train | func (pc PrefixCodes) Length() (nb uint) {
for _, c := range pc {
nb += uint(c.Len * c.Cnt)
}
return nb
} | go | {
"resource": ""
} |
q9710 | checkLengths | train | func (pc PrefixCodes) checkLengths() bool {
sum := 1 << valueBits
for _, c := range pc {
sum -= (1 << valueBits) >> uint(c.Len)
}
return sum == 0 || len(pc) == 0
} | go | {
"resource": ""
} |
q9711 | checkPrefixes | train | func (pc PrefixCodes) checkPrefixes() bool {
for i, c1 := range pc {
for j, c2 := range pc {
mask := uint32(1)<<c1.Len - 1
if i != j && c1.Len <= c2.Len && c1.Val&mask == c2.Val&mask {
return false
}
}
}
return true
} | go | {
"resource": ""
} |
q9712 | GeneratePrefixes | train | func GeneratePrefixes(codes PrefixCodes) error {
if len(codes) <= 1 {
if len(codes) == 1 {
if codes[0].Len != 0 {
return errorf(errors.Invalid, "degenerate prefix tree with one node")
}
codes[0].Val = 0
}
return nil
}
// Compute basic statistics on the symbols.
var bitCnts [valueBits + 1]uint
c... | go | {
"resource": ""
} |
q9713 | readStreamHeader | train | func (br *Reader) readStreamHeader() {
wbits := br.rd.ReadSymbol(&decWinBits)
if wbits == 0 {
errors.Panic(errCorrupted) // Reserved value used
}
size := int(1<<wbits) - 16
br.dict.Init(size)
br.readBlockHeader()
} | go | {
"resource": ""
} |
q9714 | readBlockHeader | train | func (br *Reader) readBlockHeader() {
if br.last {
if br.rd.ReadPads() > 0 {
errors.Panic(errCorrupted)
}
errors.Panic(io.EOF)
}
// Read ISLAST and ISLASTEMPTY.
if br.last = br.rd.ReadBits(1) == 1; br.last {
if empty := br.rd.ReadBits(1) == 1; empty {
br.readBlockHeader() // Next call will terminate ... | go | {
"resource": ""
} |
q9715 | readMetaData | train | func (br *Reader) readMetaData() {
br.metaRd.R = &br.rd
br.metaRd.N = int64(br.blkLen)
if br.metaBuf == nil {
br.metaBuf = make([]byte, 4096) // Lazy allocate
}
if cnt, err := io.CopyBuffer(br.metaWr, &br.metaRd, br.metaBuf); err != nil {
errors.Panic(err) // Will never panic with io.EOF
} else if cnt < int64... | go | {
"resource": ""
} |
q9716 | readRawData | train | func (br *Reader) readRawData() {
buf := br.dict.WriteSlice()
if len(buf) > br.blkLen {
buf = buf[:br.blkLen]
}
cnt, err := br.rd.Read(buf)
br.blkLen -= cnt
br.dict.WriteMark(cnt)
if err != nil {
if err == io.EOF {
err = io.ErrUnexpectedEOF
}
errors.Panic(err)
}
if br.blkLen > 0 {
br.toRead = br... | go | {
"resource": ""
} |
q9717 | readContextMap | train | func (br *Reader) readContextMap(cm []uint8, numTrees uint) {
// TODO(dsnet): Test the following edge cases:
// * Test with largest and smallest MAXRLE sizes
// * Test with with very large MAXRLE value
// * Test inverseMoveToFront
maxRLE := br.rd.ReadSymbol(&decMaxRLE)
br.rd.ReadPrefixCode(&br.rd.prefix, maxRLE+... | go | {
"resource": ""
} |
q9718 | readBlockSwitch | train | func (br *Reader) readBlockSwitch(bd *blockDecoder) {
symType := br.rd.ReadSymbol(&bd.decType)
switch symType {
case 0:
symType = uint(bd.types[1])
case 1:
symType = uint(bd.types[0]) + 1
if symType >= uint(bd.numTypes) {
symType -= uint(bd.numTypes)
}
default:
symType -= 2
}
bd.types = [2]uint8{uin... | go | {
"resource": ""
} |
q9719 | setupTLSConfig | train | func (a *Armor) setupTLSConfig() *tls.Config {
cfg := new(tls.Config)
cfg.GetConfigForClient = a.GetConfigForClient
if a.TLS.Secured {
cfg.MinVersion = tls.VersionTLS12
cfg.CipherSuites = []uint16{
tls.TLS_ECDHE_ECDSA_WITH_CHACHA20_POLY1305,
tls.TLS_ECDHE_ECDSA_WITH_AES_128_GCM_SHA256,
tls.TLS_ECDHE_EC... | go | {
"resource": ""
} |
q9720 | GetConfigForClient | train | func (a *Armor) GetConfigForClient(clientHelloInfo *tls.ClientHelloInfo) (*tls.Config, error) {
// Get the host from the hello info
host := a.Hosts[clientHelloInfo.ServerName]
// If the host or the clientCAs are not configured the function
// returns the default TLS configuration
if host == nil || len(host.ClientC... | go | {
"resource": ""
} |
q9721 | Decode | train | func Decode(r RawPlugin, e *echo.Echo, l *log.Logger) (p Plugin) {
name := r.Name()
base := Base{
name: name,
mutex: new(sync.RWMutex),
Skip: "false",
Echo: e,
Logger: l,
}
if p = Lookup(base); p == nil {
panic(fmt.Sprintf("plugin=%s not found", name))
}
dec, err := mapstructure.NewDecoder(&map... | go | {
"resource": ""
} |
q9722 | PushTimers | train | func (d *Context) PushTimers() error {
d.PushGlobalStash()
// check if timers already exists
if !d.HasPropString(-1, "timers") {
d.PushObject()
d.PutPropString(-2, "timers") // stash -> [ timers:{} ]
d.Pop()
d.PushGlobalGoFunction("setTimeout", setTimeout)
d.PushGlobalGoFunction("setInterval", setInterval... | go | {
"resource": ""
} |
q9723 | New32WithSeed | train | func New32WithSeed(seed uint32) hash.Hash32 {
d := new(digest32)
d.seed = seed
d.bmixer = d
d.Reset()
return d
} | go | {
"resource": ""
} |
q9724 | New64WithSeed | train | func New64WithSeed(seed uint32) hash.Hash64 {
d := (*digest64)(New128WithSeed(seed).(*digest128))
return d
} | go | {
"resource": ""
} |
q9725 | New128WithSeed | train | func New128WithSeed(seed uint32) Hash128 {
d := new(digest128)
d.seed = seed
d.bmixer = d
d.Reset()
return d
} | go | {
"resource": ""
} |
q9726 | verifyNode | train | func (n *Node) verifyNode() ([]byte, error) {
if n.leaf {
return n.C.CalculateHash()
}
rightBytes, err := n.Right.verifyNode()
if err != nil {
return nil, err
}
leftBytes, err := n.Left.verifyNode()
if err != nil {
return nil, err
}
h := sha256.New()
if _, err := h.Write(append(leftBytes, rightBytes..... | go | {
"resource": ""
} |
q9727 | calculateNodeHash | train | func (n *Node) calculateNodeHash() ([]byte, error) {
if n.leaf {
return n.C.CalculateHash()
}
h := sha256.New()
if _, err := h.Write(append(n.Left.Hash, n.Right.Hash...)); err != nil {
return nil, err
}
return h.Sum(nil), nil
} | go | {
"resource": ""
} |
q9728 | NewTree | train | func NewTree(cs []Content) (*MerkleTree, error) {
root, leafs, err := buildWithContent(cs)
if err != nil {
return nil, err
}
t := &MerkleTree{
Root: root,
merkleRoot: root.Hash,
Leafs: leafs,
}
return t, nil
} | go | {
"resource": ""
} |
q9729 | buildWithContent | train | func buildWithContent(cs []Content) (*Node, []*Node, error) {
if len(cs) == 0 {
return nil, nil, errors.New("error: cannot construct tree with no content")
}
var leafs []*Node
for _, c := range cs {
hash, err := c.CalculateHash()
if err != nil {
return nil, nil, err
}
leafs = append(leafs, &Node{
H... | go | {
"resource": ""
} |
q9730 | buildIntermediate | train | func buildIntermediate(nl []*Node) (*Node, error) {
var nodes []*Node
for i := 0; i < len(nl); i += 2 {
h := sha256.New()
var left, right int = i, i + 1
if i+1 == len(nl) {
right = i
}
chash := append(nl[left].Hash, nl[right].Hash...)
if _, err := h.Write(chash); err != nil {
return nil, err
}
n... | go | {
"resource": ""
} |
q9731 | RebuildTree | train | func (m *MerkleTree) RebuildTree() error {
var cs []Content
for _, c := range m.Leafs {
cs = append(cs, c.C)
}
root, leafs, err := buildWithContent(cs)
if err != nil {
return err
}
m.Root = root
m.Leafs = leafs
m.merkleRoot = root.Hash
return nil
} | go | {
"resource": ""
} |
q9732 | RebuildTreeWith | train | func (m *MerkleTree) RebuildTreeWith(cs []Content) error {
root, leafs, err := buildWithContent(cs)
if err != nil {
return err
}
m.Root = root
m.Leafs = leafs
m.merkleRoot = root.Hash
return nil
} | go | {
"resource": ""
} |
q9733 | VerifyTree | train | func (m *MerkleTree) VerifyTree() (bool, error) {
calculatedMerkleRoot, err := m.Root.verifyNode()
if err != nil {
return false, err
}
if bytes.Compare(m.merkleRoot, calculatedMerkleRoot) == 0 {
return true, nil
}
return false, nil
} | go | {
"resource": ""
} |
q9734 | VerifyContent | train | func (m *MerkleTree) VerifyContent(content Content) (bool, error) {
for _, l := range m.Leafs {
ok, err := l.C.Equals(content)
if err != nil {
return false, err
}
if ok {
currentParent := l.Parent
for currentParent != nil {
h := sha256.New()
rightBytes, err := currentParent.Right.calculateNod... | go | {
"resource": ""
} |
q9735 | String | train | func (m *MerkleTree) String() string {
s := ""
for _, l := range m.Leafs {
s += fmt.Sprint(l)
s += "\n"
}
return s
} | go | {
"resource": ""
} |
q9736 | Load | train | func Load(r io.Reader) (*DotSql, error) {
scanner := &Scanner{}
queries := scanner.Run(bufio.NewScanner(r))
dotsql := &DotSql{
queries: queries,
}
return dotsql, nil
} | go | {
"resource": ""
} |
q9737 | LoadFromFile | train | func LoadFromFile(sqlFile string) (*DotSql, error) {
f, err := os.Open(sqlFile)
if err != nil {
return nil, err
}
defer f.Close()
return Load(f)
} | go | {
"resource": ""
} |
q9738 | LoadFromString | train | func LoadFromString(sql string) (*DotSql, error) {
buf := bytes.NewBufferString(sql)
return Load(buf)
} | go | {
"resource": ""
} |
q9739 | UseLocalCache | train | func (cd *Codec) UseLocalCache(maxLen int, expiration time.Duration) {
cd.localCache = lrucache.New(maxLen, expiration)
} | go | {
"resource": ""
} |
q9740 | Set | train | func (cd *Codec) Set(item *Item) error {
cd.beforeSet(item)
_, err := cd.setItem(item)
cd.afterSet(item)
return err
} | go | {
"resource": ""
} |
q9741 | Exists | train | func (cd *Codec) Exists(key string) bool {
return cd.Get(key, nil) == nil
} | go | {
"resource": ""
} |
q9742 | Get | train | func (cd *Codec) Get(key string, object interface{}) error {
return cd.get(nil, key, object)
} | go | {
"resource": ""
} |
q9743 | Once | train | func (cd *Codec) Once(item *Item) error {
cd.beforeOnce(item)
err := cd.once(item)
cd.afterOnce(item)
return err
} | go | {
"resource": ""
} |
q9744 | Stats | train | func (cd *Codec) Stats() *Stats {
stats := Stats{
Hits: atomic.LoadUint64(&cd.hits),
Misses: atomic.LoadUint64(&cd.misses),
}
if cd.localCache != nil {
stats.LocalHits = atomic.LoadUint64(&cd.localHits)
stats.LocalMisses = atomic.LoadUint64(&cd.localMisses)
}
return &stats
} | go | {
"resource": ""
} |
q9745 | main | train | func main() {
args := map[string]string{}
gp := geopattern.Generate(args)
fmt.Println(gp)
} | go | {
"resource": ""
} |
q9746 | Generate | train | func Generate(args map[string]string) string {
p := pattern.New(args)
return p.SvgStr()
} | go | {
"resource": ""
} |
q9747 | Base64String | train | func Base64String(args map[string]string) string {
svgStr := Generate(args)
base64Str := base64.StdEncoding.EncodeToString([]byte(svgStr))
return base64Str
} | go | {
"resource": ""
} |
q9748 | URIimage | train | func URIimage(args map[string]string) string {
base64Str := Base64String(args)
return fmt.Sprintf("url(data:image/svg+xml;base64,%s);", base64Str)
} | go | {
"resource": ""
} |
q9749 | Hash | train | func Hash(s string) string {
h := sha1.New()
h.Write([]byte(s))
hash := h.Sum(nil)
return fmt.Sprintf("%x", hash)
} | go | {
"resource": ""
} |
q9750 | Map | train | func Map(value, aMin, aMax, bMin, bMax float64) float64 {
aRange := aMax - aMin
bRange := bMax - bMin
return (bMax - (aMax-value)*(bRange/aRange))
} | go | {
"resource": ""
} |
q9751 | HexVal | train | func HexVal(str string, index, length int) float64 {
hexStr := str[index : index+length]
hexVal, err := strconv.ParseInt(hexStr, 16, 0)
if err != nil {
panic(err)
}
return float64(hexVal)
} | go | {
"resource": ""
} |
q9752 | Merge | train | func Merge(mapA map[string]interface{}, mapB map[string]interface{}) map[string]interface{} {
for k, v := range mapA {
mapB[k] = v
}
return mapB
} | go | {
"resource": ""
} |
q9753 | main | train | func main() {
args := map[string]string{}
gp := geopattern.URIimage(args)
fmt.Println(gp)
} | go | {
"resource": ""
} |
q9754 | New | train | func New(args map[string]string) *Pattern {
var phrase, generator, color, baseColor string
phrase = fmt.Sprintf("%s", time.Now().Local())
if args["phrase"] != "" {
phrase = args["phrase"]
}
if args["generator"] != "" {
generator = args["generator"]
}
if args["color"] != "" {
color = args["color"]
}
... | go | {
"resource": ""
} |
q9755 | SvgStr | train | func (p *Pattern) SvgStr() string {
p.generateBackground()
p.genaratePattern()
return p.Svg.Str()
} | go | {
"resource": ""
} |
q9756 | generateBackground | train | func (p *Pattern) generateBackground() {
var rgb, color colorful.Color
if p.Color != "" {
rgb, _ = colorful.Hex(p.Color)
} else {
hueOffset := utils.Map(utils.HexVal(p.Hash, 14, 3), 0, 4095, 0, 359)
satOffset := utils.Map(utils.HexVal(p.Hash, 17, 1), 0, 15, -1, 1)
if p.BaseColor == "" {
color, _ = color... | go | {
"resource": ""
} |
q9757 | isPattern | train | func isPattern(generator string) bool {
for _, ptn := range PATTERNS {
if ptn == generator {
return true
}
}
return false
} | go | {
"resource": ""
} |
q9758 | genaratePattern | train | func (p *Pattern) genaratePattern() {
if p.Generator == "" {
p.Generator = PATTERNS[int(utils.HexVal(p.Hash, 20, 1))]
} else {
if !isPattern(p.Generator) {
panic("Error: the requested generator is invalid.")
}
}
switch p.Generator {
case "chevrons":
p.geoChevrons()
case "concentric-circles":
p.geoCo... | go | {
"resource": ""
} |
q9759 | geoChevrons | train | func (p *Pattern) geoChevrons() {
chevronWidth := utils.Map(utils.HexVal(p.Hash, 0, 1), 0, 15, 30, 80)
chevronHeight := chevronWidth
chevron := shapes.BuildChevron(chevronWidth, chevronHeight)
p.Svg.SetHeight(int(chevronHeight * 6 * 0.66))
p.Svg.SetWidth(int(chevronWidth * 6))
i := 0
for y := 0; y <= 5; y++ {
... | go | {
"resource": ""
} |
q9760 | geoConcentricCircles | train | func (p *Pattern) geoConcentricCircles() {
scale := utils.HexVal(p.Hash, 0, 1)
ringSize := utils.Map(scale, 0, 15, 10, 60)
strokeWidth := ringSize / 5
p.Svg.SetHeight(int((ringSize + strokeWidth) * 6))
p.Svg.SetWidth(int((ringSize + strokeWidth) * 6))
i := 0
for y := 0; y <= 5; y++ {
for x := 0; x <= 5; x++ ... | go | {
"resource": ""
} |
q9761 | geoDiamonds | train | func (p *Pattern) geoDiamonds() {
diamondWidth := utils.Map(utils.HexVal(p.Hash, 0, 1), 0, 15, 10, 50)
diamondHeight := utils.Map(utils.HexVal(p.Hash, 1, 1), 0, 15, 10, 50)
diamond := shapes.BuildDiamond(diamondWidth, diamondHeight)
p.Svg.SetHeight(int(diamondHeight * 3))
p.Svg.SetWidth(int(diamondWidth * 6))
i... | go | {
"resource": ""
} |
q9762 | geoMosaicSquares | train | func (p *Pattern) geoMosaicSquares() {
triangleSize := utils.Map(utils.HexVal(p.Hash, 0, 1), 0, 15, 15, 50)
p.Svg.SetHeight(int(triangleSize * 8))
p.Svg.SetWidth(int(triangleSize * 8))
i := 0
for y := 0; y <= 3; y++ {
for x := 0; x <= 3; x++ {
values := [2]float64{utils.HexVal(p.Hash, i, 1), utils.HexVal(p... | go | {
"resource": ""
} |
q9763 | geoNestedSquares | train | func (p *Pattern) geoNestedSquares() {
blockSize := utils.Map(utils.HexVal(p.Hash, 0, 1), 0, 15, 4, 12)
squareSize := blockSize * 7
p.Svg.SetHeight(int((squareSize+blockSize)*6 + blockSize*6))
p.Svg.SetWidth(int((squareSize+blockSize)*6 + blockSize*6))
i := 0
for y := 0; y <= 5; y++ {
for x := 0; x <= 5; x++ ... | go | {
"resource": ""
} |
q9764 | geoOctagons | train | func (p *Pattern) geoOctagons() {
squareSize := utils.Map(utils.HexVal(p.Hash, 0, 1), 0, 15, 10, 60)
tile := shapes.BuildOctagon(squareSize)
p.Svg.SetHeight(int(squareSize * 6))
p.Svg.SetWidth(int(squareSize * 6))
i := 0
for y := 0; y <= 5; y++ {
for x := 0; x <= 5; x++ {
val := utils.HexVal(p.Hash, i, 1)
... | go | {
"resource": ""
} |
q9765 | geoOverlappingCircles | train | func (p *Pattern) geoOverlappingCircles() {
scale := utils.HexVal(p.Hash, 0, 1)
diameter := utils.Map(scale, 0, 15, 25, 200)
radius := diameter / 2
p.Svg.SetHeight(int(radius * 6))
p.Svg.SetWidth(int(radius * 6))
i := 0
for y := 0; y <= 5; y++ {
for x := 0; x <= 5; x++ {
val := utils.HexVal(p.Hash, i, 1)... | go | {
"resource": ""
} |
q9766 | geoOverlappingRings | train | func (p *Pattern) geoOverlappingRings() {
scale := utils.HexVal(p.Hash, 0, 1)
ringSize := utils.Map(scale, 0, 15, 10, 60)
strokeWidth := ringSize / 4
p.Svg.SetHeight(int(ringSize * 6))
p.Svg.SetWidth(int(ringSize * 6))
i := 0
for y := 0; y <= 5; y++ {
for x := 0; x <= 5; x++ {
val := utils.HexVal(p.Hash,... | go | {
"resource": ""
} |
q9767 | geoPlaid | train | func (p *Pattern) geoPlaid() {
height := 0
width := 0
i := 1
j := 0
for i <= 18 {
space := utils.HexVal(p.Hash, j, 1)
height = height + int(space) + 5
val := utils.HexVal(p.Hash, j+1, 1)
opacity := utils.Opacity(val)
fill := utils.FillColor(val)
stripeHeight := val + 5
styles := make(map[string]i... | go | {
"resource": ""
} |
q9768 | geoSineWaves | train | func (p *Pattern) geoSineWaves() {
period := utils.Map(utils.HexVal(p.Hash, 0, 1), 0, 15, 100, 400)
amplitude := utils.Map(utils.HexVal(p.Hash, 1, 1), 0, 15, 30, 100)
waveWidth := utils.Map(utils.HexVal(p.Hash, 2, 1), 0, 15, 3, 30)
p.Svg.SetHeight(int(waveWidth * 36))
p.Svg.SetWidth(int(period))
for i := 0; i <... | go | {
"resource": ""
} |
q9769 | geoSquares | train | func (p *Pattern) geoSquares() {
squareSize := utils.Map(utils.HexVal(p.Hash, 0, 1), 0, 15, 10, 60)
p.Svg.SetHeight(int(squareSize * 6))
p.Svg.SetWidth(int(squareSize * 6))
i := 0
for y := 0; y <= 5; y++ {
for x := 0; x <= 5; x++ {
val := utils.HexVal(p.Hash, i, 1)
opacity := utils.Opacity(val)
fill ... | go | {
"resource": ""
} |
q9770 | geoTriangles | train | func (p *Pattern) geoTriangles() {
scale := utils.HexVal(p.Hash, 0, 1)
sideLength := utils.Map(scale, 0, 15, 15, 80)
triangleHeight := sideLength / 2 * math.Sqrt(3)
triangle := shapes.BuildTriangle(sideLength, triangleHeight)
p.Svg.SetHeight(int(triangleHeight * 6))
p.Svg.SetWidth(int(sideLength * 3))
i := 0
... | go | {
"resource": ""
} |
q9771 | BuildOctagon | train | func BuildOctagon(squareSize float64) string {
s := squareSize
c := 0.33 * s
return fmt.Sprintf("%v,0,%v,0,%v,%v,%v,%v,%v,%v,%v,%v,0,%v,0,%v,%v,0", c, s-c, s, c, s, s-c, s-c, s, c, s, s-c, c, c)
} | go | {
"resource": ""
} |
q9772 | BuildTriangle | train | func BuildTriangle(sideLength, height float64) string {
halfWidth := sideLength / 2
return fmt.Sprintf("%v,0,%v,%v,0,%v,%v,0", halfWidth, sideLength, height, height, halfWidth)
} | go | {
"resource": ""
} |
q9773 | BuildDiamond | train | func BuildDiamond(width, height float64) string {
return fmt.Sprintf("%v,0,%v,%v,%v,%v,0,%v", width/2, width, height/2, width/2, height, height/2)
} | go | {
"resource": ""
} |
q9774 | BuildRotatedTriangle | train | func BuildRotatedTriangle(sideLength, width float64) string {
halfHeight := sideLength / 2
return fmt.Sprintf("0,0,%v,%v,0,%v,0,0", width, halfHeight, sideLength)
} | go | {
"resource": ""
} |
q9775 | BuildHexagon | train | func BuildHexagon(sideLength float64) string {
c := sideLength
a := c / 2
b := math.Sin(60*math.Pi/180) * c
return fmt.Sprintf("0,%v,%v,0,%v,0,%v,%v,%v,%v,%v,%v,0,%v", b, a, a+c, 2*c, b, a+c, 2*b, a, 2*b, b)
} | go | {
"resource": ""
} |
q9776 | BuildChevron | train | func BuildChevron(width, height float64) [2]string {
e := height * 0.66
var elements [2]string
elements[0] = fmt.Sprintf("<polyline points='0,0,%v,%v,%v,%v,0,%v,0,0' />", width/2, height-e, width/2, height, e)
elements[1] = fmt.Sprintf("<polyline points='%v,%v,%v,0,%v,%v,%v,%v,%v,%v' />", width/2, height-e, width,... | go | {
"resource": ""
} |
q9777 | BuildPlus | train | func BuildPlus(squareSize float64) [2]string {
var elements [2]string
elements[0] = fmt.Sprintf("<rect x='%v' y='0' width='%v' height='%v' />", squareSize, squareSize, squareSize*3)
elements[1] = fmt.Sprintf("<rect x='0' y='%v' width='%v' height='%v' />", squareSize, squareSize*3, squareSize)
return elements
} | go | {
"resource": ""
} |
q9778 | DrawOuterMosaicTile | train | func DrawOuterMosaicTile(s *svg.SVG, x, y, triangleSize, value float64) {
opacity := utils.Opacity(value)
fill := utils.FillColor(value)
triangle := BuildRightTriangle(triangleSize)
styles := make(map[string]interface{})
styles["fill"] = fill
styles["fill-opacity"] = opacity
styles["stroke"] = utils.StrokeColor... | go | {
"resource": ""
} |
q9779 | Str | train | func (s *SVG) Str() string {
return s.header() + s.svgString + s.footer()
} | go | {
"resource": ""
} |
q9780 | Rect | train | func (s *SVG) Rect(x, y, w, h interface{}, args map[string]interface{}) {
rectStr := fmt.Sprintf("<rect x='%v' y='%v' width='%v' height='%v' %s />", x, y, w, h, s.WriteArgs(args))
s.svgString += rectStr
} | go | {
"resource": ""
} |
q9781 | Circle | train | func (s *SVG) Circle(cx, cy, r interface{}, args map[string]interface{}) {
circleStr := fmt.Sprintf("<circle cx='%v' cy='%v' r='%v' %s />", cx, cy, r, s.WriteArgs(args))
s.svgString += circleStr
} | go | {
"resource": ""
} |
q9782 | Path | train | func (s *SVG) Path(str string, args map[string]interface{}) {
pathStr := fmt.Sprintf("<path d='%s' %s />", str, s.WriteArgs(args))
s.svgString += pathStr
} | go | {
"resource": ""
} |
q9783 | Polyline | train | func (s *SVG) Polyline(str string, args map[string]interface{}) {
polylineStr := fmt.Sprintf("<polyline points='%s' %s />", str, s.WriteArgs(args))
s.svgString += polylineStr
} | go | {
"resource": ""
} |
q9784 | Group | train | func (s *SVG) Group(elements [2]string, args map[string]interface{}) {
s.svgString += fmt.Sprintf("<g %s>", s.WriteArgs(args))
s.svgString += elements[0] + elements[1]
s.svgString += "</g>"
} | go | {
"resource": ""
} |
q9785 | WriteArgs | train | func (s *SVG) WriteArgs(args map[string]interface{}) string {
str := ""
for k, v := range args {
objType := fmt.Sprintf("%s", reflect.TypeOf(v))
switch objType {
case "string":
str += fmt.Sprintf("%s='%s' ", k, v)
case "int":
str += fmt.Sprintf("%s='%v' ", k, v)
case "float64":
str += fmt.Sprintf... | go | {
"resource": ""
} |
q9786 | main | train | func main() {
args := map[string]string{}
gp := geopattern.Base64String(args)
fmt.Println(gp)
} | go | {
"resource": ""
} |
q9787 | Text | train | func (a *defaultAdapter) Text(res *Response) ([]byte, error) {
r, err := res.Reader()
if err != nil {
return nil, err
}
text, err := ioutil.ReadAll(r)
if err != nil {
return nil, err
}
return text, nil
} | go | {
"resource": ""
} |
q9788 | adapterFor | train | func adapterFor(host string) Adapter {
if a, ok := adapters[host]; ok {
return a
}
return DefaultAdapter
} | go | {
"resource": ""
} |
q9789 | NewResponse | train | func NewResponse(query, host string) *Response {
return &Response{
Query: query,
Host: host,
FetchedAt: time.Now().UTC(),
MediaType: "text/plain",
Charset: "utf-8",
}
} | go | {
"resource": ""
} |
q9790 | String | train | func (res *Response) String() string {
text, err := res.Text()
if err != nil {
return ""
}
return string(text)
} | go | {
"resource": ""
} |
q9791 | Reader | train | func (res *Response) Reader() (io.Reader, error) {
enc, err := res.Encoding()
if err != nil {
return nil, err
}
return transform.NewReader(bytes.NewReader(res.Body), enc.NewDecoder()), nil
} | go | {
"resource": ""
} |
q9792 | Encoding | train | func (res *Response) Encoding() (encoding.Encoding, error) {
enc, _ := charset.Lookup(res.Charset)
if enc == nil {
return nil, fmt.Errorf("no encoding found for %s", res.Charset)
}
return enc, nil
} | go | {
"resource": ""
} |
q9793 | DetectContentType | train | func (res *Response) DetectContentType(ct string) {
// Autodetect if not passed a Content-Type header
if ct == "" {
ct = http.DetectContentType(res.Body)
}
// Content type (e.g. text/plain or text/html)
mt, params, err := mime.ParseMediaType(ct)
if err != nil {
return
}
res.MediaType = mt
// Character se... | go | {
"resource": ""
} |
q9794 | DetectCharset | train | func (res *Response) DetectCharset() {
// Detect via BOM / HTML meta tag
_, cs1, ok1 := charset.DetermineEncoding(res.Body, res.MediaType)
// Detect via ICU
cs2, ok2, html := "", false, false
var det *chardet.Detector
if strings.Contains(res.MediaType, "html") || true {
det = chardet.NewHtmlDetector()
html =... | go | {
"resource": ""
} |
q9795 | Checksum | train | func (res *Response) Checksum() string {
h := sha1.New()
h.Write(res.Body)
return strings.ToLower(hex.EncodeToString(h.Sum(nil)))
} | go | {
"resource": ""
} |
q9796 | Header | train | func (res *Response) Header() http.Header {
h := make(http.Header)
h.Set("Query", res.Query)
h.Set("Host", res.Host)
h.Set("Fetched-At", res.FetchedAt.Format(time.RFC3339))
h.Set("Content-Type", res.ContentType())
h.Set("Content-Length", strconv.Itoa(len(res.Body)))
h.Set("Content-Checksum", res.Checksum())
ret... | go | {
"resource": ""
} |
q9797 | ContentType | train | func (res *Response) ContentType() string {
return mime.FormatMediaType(res.MediaType, map[string]string{"charset": res.Charset})
} | go | {
"resource": ""
} |
q9798 | WriteMIME | train | func (res *Response) WriteMIME(w io.Writer) error {
io.WriteString(w, "MIME-Version: 1.0\r\n")
err := res.Header().Write(w)
if err != nil {
return err
}
_, err = io.WriteString(w, "\r\n")
if err != nil {
return err
}
_, err = w.Write(res.Body)
if err != nil {
return err
}
return nil
} | go | {
"resource": ""
} |
q9799 | ReadMIME | train | func ReadMIME(r io.Reader) (*Response, error) {
msg, err := mail.ReadMessage(r)
if err != nil {
return nil, err
}
h := msg.Header
res := NewResponse(h.Get("Query"), h.Get("Host"))
if res.Body, err = ioutil.ReadAll(msg.Body); err != nil {
return res, err
}
if res.FetchedAt, err = time.Parse(time.RFC3339, h.G... | go | {
"resource": ""
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.