_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.bufRd.Buffered() > cntPeek {
cntPeek = br.bufRd.Buffered()
}
br.bufPeek, err = br.bufRd.Peek(cntPeek)
br.bufPeek = br.bufPeek[int(br.numBits/8):] // Skip buffered bits
if len(br.bufPeek) == 0 {
if br.numBits >= nb {
break
}
if err == io.EOF {
err = io.ErrUnexpectedEOF
}
errors.Panic(err)
}
}
cnt := int(64-br.numBits) / 8
if cnt > len(br.bufPeek) {
cnt = len(br.bufPeek)
}
for _, c := range br.bufPeek[:cnt] {
br.bufBits |= uint64(c) << br.numBits
br.numBits += 8
}
br.bufPeek = br.bufPeek[cnt:]
if br.numBits > 56 {
break
}
}
br.fedBits = br.numBits
} else {
for br.numBits < nb {
c, err := br.rd.ReadByte()
if err != nil {
if err == io.EOF {
err = io.ErrUnexpectedEOF
}
errors.Panic(err)
}
br.bufBits |= uint64(c) << br.numBits
br.numBits += 8
br.offset++
}
}
} | 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) {
linkIdx := chunk >> prefixCountBits
chunk = pd.links[linkIdx][uint32(br.bufBits>>pd.chunkBits)&pd.linkMask]
nb = uint(chunk & prefixCountMask)
}
if nb <= br.numBits {
br.bufBits >>= nb
br.numBits -= nb
return uint(chunk >> prefixCountBits)
}
}
} | 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[i].len = uint32(lens[i])
}
}
compareSwap := func(i, j int) {
if codes[i].sym > codes[j].sym {
codes[i], codes[j] = codes[j], codes[i]
}
}
switch nsym {
case 1:
copyLens(simpleLens1[:])
case 2:
copyLens(simpleLens2[:])
compareSwap(0, 1)
case 3:
copyLens(simpleLens3[:])
compareSwap(0, 1)
compareSwap(0, 2)
compareSwap(1, 2)
case 4:
if tsel := br.ReadBits(1) == 1; !tsel {
copyLens(simpleLens4a[:])
} else {
copyLens(simpleLens4b[:])
}
compareSwap(0, 1)
compareSwap(2, 3)
compareSwap(0, 2)
compareSwap(1, 3)
compareSwap(1, 2)
}
if uint(codes[nsym-1].sym) >= maxSyms {
errors.Panic(errCorrupted) // Symbol goes beyond range of alphabet
}
pd.Init(codes[:nsym], true) // Must have 1..4 symbols
} | 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 {
codeCLensArr[sym] = prefixCode{sym: uint32(sym), len: uint32(clen)}
if sum -= 32 >> clen; sum <= 0 {
break
}
}
}
codeCLens := codeCLensArr[:0] // Compact the array to have no holes
for _, c := range codeCLensArr {
if c.len > 0 {
codeCLens = append(codeCLens, c)
}
}
if len(codeCLens) < 1 {
errors.Panic(errCorrupted)
}
br.prefix.Init(codeCLens, true) // Must have 1..len(complexLens) symbols
// Use code-lengths table to decode rest of prefix table.
var codesArr [maxNumAlphabetSyms]prefixCode
var sym, repSymLast, repCntLast, clenLast uint = 0, 0, 0, 8
codes := codesArr[:0]
for sym, sum = 0, 32768; sym < maxSyms && sum > 0; {
clen := br.ReadSymbol(&br.prefix)
if clen < 16 {
// Literal bit-length symbol used.
if clen > 0 {
codes = append(codes, prefixCode{sym: uint32(sym), len: uint32(clen)})
clenLast = clen
sum -= 32768 >> clen
}
repSymLast = 0 // Reset last repeater symbol
sym++
} else {
// Repeater symbol used.
// 16: Repeat previous non-zero code-length
// 17: Repeat code length of zero
repSym := clen // Rename clen for better clarity
if repSym != repSymLast {
repCntLast = 0
repSymLast = repSym
}
nb := repSym - 14 // 2..3 bits
rep := br.ReadBits(nb) + 3 // 3..6 or 3..10
if repCntLast > 0 {
rep += (repCntLast - 2) << nb // Modify previous repeat count
}
repDiff := rep - repCntLast // Always positive
repCntLast = rep
if repSym == 16 {
clen := clenLast
for symEnd := sym + repDiff; sym < symEnd; sym++ {
codes = append(codes, prefixCode{sym: uint32(sym), len: uint32(clen)})
}
sum -= int(repDiff) * (32768 >> clen)
} else {
sym += repDiff
}
}
}
if len(codes) < 2 || sym > maxSyms {
errors.Panic(errCorrupted)
}
pd.Init(codes, true) // Must have 2..maxSyms symbols
} | 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
c0 := codes[0]
bitCnts[c0.Len]++
minBits, maxBits, symLast := c0.Len, c0.Len, c0.Sym
for _, c := range codes[1:] {
if c.Sym <= symLast {
return errorf(errors.Invalid, "non-unique or non-monotonically increasing symbols")
}
if minBits > c.Len {
minBits = c.Len
}
if maxBits < c.Len {
maxBits = c.Len
}
bitCnts[c.Len]++ // Histogram of bit counts
symLast = c.Sym // Keep track of last symbol
}
if minBits == 0 {
return errorf(errors.Invalid, "invalid prefix bit-length")
}
// Compute the next code for a symbol of a given bit length.
var nextCodes [valueBits + 1]uint
var code uint
for i := minBits; i <= maxBits; i++ {
code <<= 1
nextCodes[i] = code
code += bitCnts[i]
}
if code != 1<<maxBits {
return errorf(errors.Invalid, "degenerate prefix tree")
}
// Assign the code to each symbol.
for i, c := range codes {
codes[i].Val = internal.ReverseUint32N(uint32(nextCodes[c.Len]), uint(c.Len))
nextCodes[c.Len]++
}
if internal.Debug && !codes.checkPrefixes() {
panic("overlapping prefixes detected")
}
if internal.Debug && !codes.checkCanonical() {
panic("non-canonical prefixes detected")
}
return nil
} | 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 stream
return
}
}
// Read MLEN and MNIBBLES and process meta data.
var blkLen int // 1..1<<24
nibbles := br.rd.ReadBits(2) + 4
if nibbles == 7 {
if reserved := br.rd.ReadBits(1) == 1; reserved {
errors.Panic(errCorrupted)
}
var skipLen int // 0..1<<24
if skipBytes := br.rd.ReadBits(2); skipBytes > 0 {
skipLen = int(br.rd.ReadBits(skipBytes * 8))
if skipBytes > 1 && skipLen>>((skipBytes-1)*8) == 0 {
errors.Panic(errCorrupted) // Shortest representation not used
}
skipLen++
}
if br.rd.ReadPads() > 0 {
errors.Panic(errCorrupted)
}
br.blkLen = skipLen // Use blkLen to track metadata number of bytes
br.readMetaData()
return
}
blkLen = int(br.rd.ReadBits(nibbles * 4))
if nibbles > 4 && blkLen>>((nibbles-1)*4) == 0 {
errors.Panic(errCorrupted) // Shortest representation not used
}
br.blkLen = blkLen + 1
// Read ISUNCOMPRESSED and process uncompressed data.
if !br.last {
if uncompressed := br.rd.ReadBits(1) == 1; uncompressed {
if br.rd.ReadPads() > 0 {
errors.Panic(errCorrupted)
}
br.readRawData()
return
}
}
br.readPrefixCodes()
} | 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(br.blkLen) {
errors.Panic(io.ErrUnexpectedEOF)
}
br.step = (*Reader).readBlockHeader
} | 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.dict.ReadFlush()
br.step = (*Reader).readRawData // We need to continue this work
return
}
br.step = (*Reader).readBlockHeader
} | 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+numTrees)
for i := 0; i < len(cm); {
sym := br.rd.ReadSymbol(&br.rd.prefix)
if sym == 0 || sym > maxRLE {
// Single non-zero value.
if sym > 0 {
sym -= maxRLE
}
cm[i] = uint8(sym)
i++
} else {
// Repeated zeros.
n := int(br.rd.ReadOffset(sym-1, maxRLERanges))
if i+n > len(cm) {
errors.Panic(errCorrupted)
}
for j := i + n; i < j; i++ {
cm[i] = 0
}
}
}
if invert := br.rd.ReadBits(1) == 1; invert {
br.mtf.Decode(cm)
}
} | 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{uint8(symType), bd.types[0]}
symLen := br.rd.ReadSymbol(&bd.decLen)
bd.typeLen = int(br.rd.ReadOffset(symLen, blkLenRanges))
} | 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_ECDSA_WITH_AES_256_GCM_SHA384,
tls.TLS_ECDHE_RSA_WITH_CHACHA20_POLY1305,
tls.TLS_ECDHE_RSA_WITH_AES_128_GCM_SHA256,
tls.TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384,
}
}
return cfg
} | 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.ClientCAs) == 0 {
return nil, nil
}
// Use existing host config if exist
if host.TLSConfig != nil {
return host.TLSConfig, nil
}
// Build and save the host config
host.TLSConfig = a.buildTLSConfig(clientHelloInfo, host)
return host.TLSConfig, nil
} | 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(&mapstructure.DecoderConfig{
TagName: "yaml",
Result: p,
})
err = dec.Decode(r)
if err != nil {
panic(err)
}
return
} | 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)
d.PushGlobalGoFunction("clearTimeout", clearTimeout)
d.PushGlobalGoFunction("clearInterval", clearTimeout)
return nil
} else {
d.Pop()
return errors.New("Timers are already defined")
}
} | 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...)); err != nil {
return nil, err
}
return h.Sum(nil), nil
} | 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{
Hash: hash,
C: c,
leaf: true,
})
}
if len(leafs)%2 == 1 {
duplicate := &Node{
Hash: leafs[len(leafs)-1].Hash,
C: leafs[len(leafs)-1].C,
leaf: true,
dup: true,
}
leafs = append(leafs, duplicate)
}
root, err := buildIntermediate(leafs)
if err != nil {
return nil, nil, err
}
return root, leafs, nil
} | 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 := &Node{
Left: nl[left],
Right: nl[right],
Hash: h.Sum(nil),
}
nodes = append(nodes, n)
nl[left].Parent = n
nl[right].Parent = n
if len(nl) == 2 {
return n, nil
}
}
return buildIntermediate(nodes)
} | 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.calculateNodeHash()
if err != nil {
return false, err
}
leftBytes, err := currentParent.Left.calculateNodeHash()
if err != nil {
return false, err
}
if _, err := h.Write(append(leftBytes, rightBytes...)); err != nil {
return false, err
}
if bytes.Compare(h.Sum(nil), currentParent.Hash) != 0 {
return false, nil
}
currentParent = currentParent.Parent
}
return true, nil
}
}
return false, nil
} | 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"]
}
if args["baseColor"] != "" {
baseColor = args["baseColor"]
}
return &Pattern{BaseColor: baseColor, Color: color, Generator: generator, Hash: utils.Hash(phrase), Svg: new(svg.SVG)}
} | 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, _ = colorful.Hex(utils.BaseColor)
} else {
color, _ = colorful.Hex(p.BaseColor)
}
h, c, l := color.Hcl()
h -= hueOffset
if satOffset >= 0 {
c += float64(satOffset)
} else {
c -= float64(satOffset)
}
rgb = colorful.Color{h, c, l}
}
r, g, b := int(rgb.R*105), int(rgb.G*105), int(rgb.B*150)
args := make(map[string]interface{})
args["fill"] = fmt.Sprintf("rgb(%v, %v, %v)", r, g, b)
p.Svg.Rect(0, 0, "100%", "100%", args)
} | 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.geoConcentricCircles()
case "diamonds":
p.geoDiamonds()
case "hexagons":
p.geoHexagons()
case "mosaic-squares":
p.geoMosaicSquares()
case "nested-squares":
p.geoNestedSquares()
case "octagons":
p.geoOctagons()
case "overlapping-circles":
p.geoOverlappingCircles()
case "overlapping-rings":
p.geoOverlappingRings()
case "plaid":
p.geoPlaid()
case "plus-signs":
p.geoPlusSigns()
case "sine-waves":
p.geoSineWaves()
case "squares":
p.geoSquares()
case "tessellation":
p.geoTessellation()
case "triangles":
p.geoTriangles()
case "xes":
p.geoXes()
}
} | 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++ {
for x := 0; x <= 5; x++ {
val := utils.HexVal(p.Hash, i, 1)
opacity := utils.Opacity(val)
fill := utils.FillColor(val)
styles := make(map[string]interface{})
styles["fill"] = fill
styles["fill-opacity"] = opacity
styles["stroke"] = utils.StrokeColor
styles["stroke-opacity"] = utils.StrokeOpacity
styles["stroke-width"] = 1
style := make(map[string]interface{})
style["transform"] = fmt.Sprintf("translate(%v, %v)", float64(x)*chevronWidth, float64(y)*chevronHeight*0.66-chevronHeight/2)
p.Svg.Group(chevron, utils.Merge(styles, style))
if y == 0 {
style["transform"] = fmt.Sprintf("translate(%v, %v)", float64(x)*chevronWidth, 6*chevronHeight*0.66-chevronHeight/2)
p.Svg.Group(chevron, utils.Merge(styles, style))
}
i = i + 1
}
}
} | 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++ {
val := utils.HexVal(p.Hash, i, 1)
opacity := utils.Opacity(val)
fill := utils.FillColor(val)
cx := float64(x)*ringSize + float64(x)*strokeWidth + (ringSize+strokeWidth)/2
cy := float64(y)*ringSize + float64(y)*strokeWidth + (ringSize+strokeWidth)/2
styles := make(map[string]interface{})
styles["fill"] = "none"
styles["stroke"] = fill
styles["style"] = map[string]string{"opacity": fmt.Sprintf("%v", opacity), "stroke-width": fmt.Sprintf("%vpx", strokeWidth)}
p.Svg.Circle(cx, cy, ringSize/2, styles)
val = utils.HexVal(p.Hash, 39-i, 1)
opacity = utils.Opacity(val)
fill = utils.FillColor(val)
styles = make(map[string]interface{})
styles["fill"] = fill
styles["fill-opacity"] = opacity
p.Svg.Circle(cx, cy, ringSize/4, styles)
i = i + 1
}
}
} | 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 := 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 := utils.FillColor(val)
styles := make(map[string]interface{})
styles["fill"] = fill
styles["fill-opacity"] = opacity
styles["stroke"] = utils.StrokeColor
styles["stroke-opacity"] = utils.StrokeOpacity
var dx float64
if y%2 != 0 {
dx = diamondWidth / 2
}
style := make(map[string]interface{})
style["transform"] = fmt.Sprintf("translate(%v, %v)", dx + float64(x)*diamondWidth - diamondWidth/2, diamondHeight/2*float64(y) - diamondHeight/2)
p.Svg.Polyline(diamond, utils.Merge(styles, style))
if x == 0 {
style["transform"] = fmt.Sprintf("translate(%v, %v)", dx + 6*diamondWidth - diamondWidth/2, diamondHeight/2*float64(y) - diamondHeight/2)
p.Svg.Polyline(diamond, utils.Merge(styles, style))
}
if y == 0 {
style["transform"] = fmt.Sprintf("translate(%v, %v)", dx + float64(x)*diamondWidth - diamondWidth/2, diamondHeight/2*6 - diamondHeight/2)
p.Svg.Polyline(diamond, utils.Merge(styles, style))
}
if x == 0 && y == 0 {
style["transform"] = fmt.Sprintf("translate(%v, %v)", dx + 6*diamondWidth - diamondWidth/2, diamondHeight/2*6 - diamondHeight/2)
p.Svg.Polyline(diamond, utils.Merge(styles, style))
}
i = i + 1
}
}
} | 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.Hash, i+1, 1)}
if x%2 == 0 {
if y%2 == 0 {
shapes.DrawOuterMosaicTile(p.Svg, float64(x)*triangleSize*2, float64(y)*triangleSize*2, triangleSize, utils.HexVal(p.Hash, i, 1))
} else {
shapes.DrawInnerMosaicTile(p.Svg, float64(x)*triangleSize*2, float64(y)*triangleSize*2, triangleSize, values)
}
} else {
if y%2 == 0 {
shapes.DrawInnerMosaicTile(p.Svg, float64(x)*triangleSize*2, float64(y)*triangleSize*2, triangleSize, values)
} else {
shapes.DrawOuterMosaicTile(p.Svg, float64(x)*triangleSize*2, float64(y)*triangleSize*2, triangleSize, utils.HexVal(p.Hash, i, 1))
}
}
i = i + 1
}
}
} | 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++ {
val := utils.HexVal(p.Hash, i, 1)
opacity := utils.Opacity(val)
fill := utils.FillColor(val)
styles := make(map[string]interface{})
styles["fill"] = "none"
styles["stroke"] = fill
styles["style"] = map[string]string{"opacity": fmt.Sprintf("%v", opacity), "stroke-width": fmt.Sprintf("%vpx", blockSize)}
p.Svg.Rect(float64(x)*squareSize+float64(x)*blockSize*2+blockSize/2, float64(y)*squareSize+float64(y)*blockSize*2+blockSize/2, squareSize, squareSize, styles)
val = utils.HexVal(p.Hash, 39-i, 1)
opacity = utils.Opacity(val)
fill = utils.FillColor(val)
styles = make(map[string]interface{})
styles["fill"] = "none"
styles["stroke"] = fill
styles["style"] = map[string]string{"opacity": fmt.Sprintf("%v", opacity), "stroke-width": fmt.Sprintf("%vpx", blockSize)}
p.Svg.Rect(float64(x)*squareSize+float64(x)*blockSize*2+blockSize/2+blockSize*2, float64(y)*squareSize+float64(y)*blockSize*2+blockSize/2+blockSize*2, blockSize*3, blockSize*3, styles)
i = i + 1
}
}
} | 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)
opacity := utils.Opacity(val)
fill := utils.FillColor(val)
styles := make(map[string]interface{})
styles["fill"] = fill
styles["fill-opacity"] = opacity
styles["stroke"] = utils.StrokeColor
styles["stroke-opacity"] = utils.StrokeOpacity
styles["transform"] = fmt.Sprintf("translate(%v, %v)", float64(x)*squareSize, float64(y)*squareSize)
p.Svg.Polyline(tile, styles)
i = 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)
opacity := utils.Opacity(val)
fill := utils.FillColor(val)
styles := make(map[string]interface{})
styles["fill"] = fill
styles["style"] = map[string]string{"opacity": fmt.Sprintf("%v", opacity)}
p.Svg.Circle(float64(x)*radius, float64(y)*radius, radius, styles)
if x == 0 {
p.Svg.Circle(6*radius, float64(y)*radius, radius, styles)
}
if y == 0 {
p.Svg.Circle(float64(x)*radius, 6*radius, radius, styles)
}
if x == 0 && y == 0 {
p.Svg.Circle(6*radius, 6*radius, radius, styles)
}
i = 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, i, 1)
opacity := utils.Opacity(val)
fill := utils.FillColor(val)
styles := make(map[string]interface{})
styles["fill"] = "none"
styles["stroke"] = fill
styles["style"] = map[string]string{"opacity": fmt.Sprintf("%v", opacity), "stroke-width": fmt.Sprintf("%vpx", strokeWidth)}
p.Svg.Circle(float64(x)*ringSize, float64(y)*ringSize, ringSize-(strokeWidth/2), styles)
if x == 0 {
p.Svg.Circle(6*ringSize, float64(y)*ringSize, ringSize-(strokeWidth/2), styles)
}
if y == 0 {
p.Svg.Circle(float64(x)*ringSize, 6*ringSize, ringSize-(strokeWidth/2), styles)
}
if x == 0 && y == 0 {
p.Svg.Circle(6*ringSize, 6*ringSize, ringSize-(strokeWidth/2), styles)
}
i = i + 1
}
}
} | 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]interface{})
styles["opacity"] = opacity
styles["fill"] = fill
p.Svg.Rect(0, height, "100%", stripeHeight, styles)
height = height + int(stripeHeight)
j = j + 2
i = i + 1
}
i = 1
j = 0
for i <= 18 {
space := utils.HexVal(p.Hash, j, 1)
width = width + int(space) + 5
val := utils.HexVal(p.Hash, j+1, 1)
opacity := utils.Opacity(val)
fill := utils.FillColor(val)
stripeWidth := val + 5
styles := make(map[string]interface{})
styles["opacity"] = opacity
styles["fill"] = fill
p.Svg.Rect(width, 0, stripeWidth, "100%", styles)
width = width + int(stripeWidth)
j = j + 2
i = i + 1
}
p.Svg.SetHeight(int(height))
p.Svg.SetWidth(int(width))
} | 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 <= 35; i++ {
val := utils.HexVal(p.Hash, i, 1)
opacity := utils.Opacity(val)
fill := utils.FillColor(val)
xOffset := (period / 4) * 0.7
styles := make(map[string]interface{})
styles["fill"] = "none"
styles["stroke"] = fill
styles["style"] = map[string]string{"opacity": fmt.Sprintf("%v", opacity), "stroke-width": fmt.Sprintf("%vpx", waveWidth)}
str := fmt.Sprintf("M0 %v C %v 0, %v 0, %v %v S %v %v, %v %v S %v 0, %v, %v", amplitude, xOffset, period/2-xOffset, period/2, amplitude, period-xOffset, amplitude*2, period, amplitude, period*1.5-xOffset, period*1.5, amplitude)
style := make(map[string]interface{})
style["transform"] = fmt.Sprintf("translate(-%v, %v)", period/4, (waveWidth*float64(i))-(amplitude*1.5))
p.Svg.Path(str, utils.Merge(styles, style))
style["transform"] = fmt.Sprintf("translate(-%v, %v)", period/4, (waveWidth*float64(i))-(amplitude*1.5)+waveWidth*36)
p.Svg.Path(str, utils.Merge(styles, style))
}
} | 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 := utils.FillColor(val)
styles := make(map[string]interface{})
styles["fill"] = fill
styles["fill-opacity"] = opacity
styles["stroke"] = utils.StrokeColor
styles["stroke-opacity"] = utils.StrokeOpacity
p.Svg.Rect(float64(x)*squareSize, float64(y)*squareSize, squareSize, squareSize, styles)
i = i + 1
}
}
} | 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
for y := 0; y <= 5; y++ {
for x := 0; x <= 5; x++ {
val := utils.HexVal(p.Hash, i, 1)
opacity := utils.Opacity(val)
fill := utils.FillColor(val)
styles := make(map[string]interface{})
styles["fill"] = fill
styles["fill-opacity"] = opacity
styles["stroke"] = utils.StrokeColor
styles["stroke-opacity"] = utils.StrokeOpacity
var rotation int
if y%2 == 0 {
if x%2 == 0 {
rotation = 180
}
} else {
if x%2 != 0 {
rotation = 180
}
}
style := make(map[string]interface{})
style["transform"] = fmt.Sprintf("translate(%v, %v) rotate(%v, %v, %v)", float64(x)*sideLength*0.5-sideLength/2, triangleHeight*float64(y), rotation, sideLength/2, triangleHeight/2)
p.Svg.Polyline(triangle, utils.Merge(styles, style))
if x == 0 {
style["transform"] = fmt.Sprintf("translate(%v, %v) rotate(%v, %v, %v)", 6*sideLength*0.5-sideLength/2, triangleHeight*float64(y), rotation, sideLength/2, triangleHeight/2)
p.Svg.Polyline(triangle, utils.Merge(styles, style))
}
i = i + 1
}
}
} | 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, width, e, width/2, height, width/2, height-e)
return elements
} | 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
styles["stroke-opacity"] = utils.StrokeOpacity
style := make(map[string]interface{})
style["transform"] = fmt.Sprintf("translate(%v, %v) scale(1, -1)", x, y+triangleSize)
s.Polyline(triangle, utils.Merge(styles, style))
style["transform"] = fmt.Sprintf("translate(%v, %v) scale(-1, -1)", x+triangleSize*2, y+triangleSize)
s.Polyline(triangle, utils.Merge(styles, style))
style["transform"] = fmt.Sprintf("translate(%v, %v) scale(1, 1)", x, y+triangleSize)
s.Polyline(triangle, utils.Merge(styles, style))
style["transform"] = fmt.Sprintf("translate(%v, %v) scale(-1, 1)", x+triangleSize*2, y+triangleSize)
s.Polyline(triangle, utils.Merge(styles, style))
} | 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("%s='%v' ", k, v)
default:
{
str += fmt.Sprintf("%s='", k)
for K, V := range v.(map[string]string) {
str += fmt.Sprintf("%s:%s;", K, V)
}
str += "' "
}
}
}
return str
} | 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 set (e.g. utf-8)
cs, ok := params["charset"]
if ok {
res.Charset = cs
}
res.DetectCharset()
} | 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 = true
} else {
det = chardet.NewTextDetector()
}
r, err := det.DetectAll(res.Body)
if err == nil && len(r) > 0 {
cs2 = strings.ToLower(r[0].Charset)
ok2 = r[0].Confidence > 50
}
// Prefer charset if HTML, otherwise ICU
if !ok2 && (ok1 || html) {
res.Charset = cs1
} else {
res.Charset = cs2
}
// fmt.Printf("Detected charset via go.net/html/charset: %s (%t)\n", cs1, ok1)
// fmt.Printf("Detected charset via saintfish/chardet: %s (%d)\n", cs2, r[0].Confidence)
} | 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())
return h
} | 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.Get("Fetched-At")); err != nil {
return res, err
}
mt, params, err := mime.ParseMediaType(h.Get("Content-Type"))
if err != nil {
return res, err
}
res.MediaType = mt
res.Charset = params["charset"]
return res, nil
} | go | {
"resource": ""
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.