_id stringlengths 2 7 | title stringlengths 1 118 | partition stringclasses 3
values | text stringlengths 52 85.5k | language stringclasses 1
value | meta_information dict |
|---|---|---|---|---|---|
q179400 | Facets | test | func (t *Iterator) Facets() ([][]FacetResult, error) {
t.fetchMore()
if t.err != nil && t.err != Done {
return nil, t.err
}
var facets [][]FacetResult
for _, f := range t.facetRes {
fres := make([]FacetResult, 0, len(f.Value))
for _, v := range f.Value {
ref := v.Refinement
facet := FacetResult{
F... | go | {
"resource": ""
} |
q179401 | DefaultBucketName | test | func DefaultBucketName(c context.Context) (string, error) {
req := &aipb.GetDefaultGcsBucketNameRequest{}
res := &aipb.GetDefaultGcsBucketNameResponse{}
err := internal.Call(c, "app_identity_service", "GetDefaultGcsBucketName", req, res)
if err != nil {
return "", fmt.Errorf("file: no default bucket name returne... | go | {
"resource": ""
} |
q179402 | valid | test | func (k *Key) valid() bool {
if k == nil {
return false
}
for ; k != nil; k = k.parent {
if k.kind == "" || k.appID == "" {
return false
}
if k.stringID != "" && k.intID != 0 {
return false
}
if k.parent != nil {
if k.parent.Incomplete() {
return false
}
if k.parent.appID != k.appID ||... | go | {
"resource": ""
} |
q179403 | Equal | test | func (k *Key) Equal(o *Key) bool {
for k != nil && o != nil {
if k.kind != o.kind || k.stringID != o.stringID || k.intID != o.intID || k.appID != o.appID || k.namespace != o.namespace {
return false
}
k, o = k.parent, o.parent
}
return k == o
} | go | {
"resource": ""
} |
q179404 | root | test | func (k *Key) root() *Key {
for k.parent != nil {
k = k.parent
}
return k
} | go | {
"resource": ""
} |
q179405 | marshal | test | func (k *Key) marshal(b *bytes.Buffer) {
if k.parent != nil {
k.parent.marshal(b)
}
b.WriteByte('/')
b.WriteString(k.kind)
b.WriteByte(',')
if k.stringID != "" {
b.WriteString(k.stringID)
} else {
b.WriteString(strconv.FormatInt(k.intID, 10))
}
} | go | {
"resource": ""
} |
q179406 | String | test | func (k *Key) String() string {
if k == nil {
return ""
}
b := bytes.NewBuffer(make([]byte, 0, 512))
k.marshal(b)
return b.String()
} | go | {
"resource": ""
} |
q179407 | Encode | test | func (k *Key) Encode() string {
ref := keyToProto("", k)
b, err := proto.Marshal(ref)
if err != nil {
panic(err)
}
// Trailing padding is stripped.
return strings.TrimRight(base64.URLEncoding.EncodeToString(b), "=")
} | go | {
"resource": ""
} |
q179408 | DecodeKey | test | func DecodeKey(encoded string) (*Key, error) {
// Re-add padding.
if m := len(encoded) % 4; m != 0 {
encoded += strings.Repeat("=", 4-m)
}
b, err := base64.URLEncoding.DecodeString(encoded)
if err != nil {
return nil, err
}
ref := new(pb.Reference)
if err := proto.Unmarshal(b, ref); err != nil {
return ... | go | {
"resource": ""
} |
q179409 | NewIncompleteKey | test | func NewIncompleteKey(c context.Context, kind string, parent *Key) *Key {
return NewKey(c, kind, "", 0, parent)
} | go | {
"resource": ""
} |
q179410 | NewKey | test | func NewKey(c context.Context, kind, stringID string, intID int64, parent *Key) *Key {
// If there's a parent key, use its namespace.
// Otherwise, use any namespace attached to the context.
var namespace string
if parent != nil {
namespace = parent.namespace
} else {
namespace = internal.NamespaceFromContext(... | go | {
"resource": ""
} |
q179411 | AllocateIDs | test | func AllocateIDs(c context.Context, kind string, parent *Key, n int) (low, high int64, err error) {
if kind == "" {
return 0, 0, errors.New("datastore: AllocateIDs given an empty kind")
}
if n < 0 {
return 0, 0, fmt.Errorf("datastore: AllocateIDs given a negative count: %d", n)
}
if n == 0 {
return 0, 0, nil... | go | {
"resource": ""
} |
q179412 | IsOverQuota | test | func IsOverQuota(err error) bool {
callErr, ok := err.(*internal.CallError)
return ok && callErr.Code == 4
} | go | {
"resource": ""
} |
q179413 | ClassicContextFromContext | test | func ClassicContextFromContext(ctx netcontext.Context) (appengine.Context, error) {
c := fromContext(ctx)
if c == nil {
return nil, errNotAppEngineContext
}
return c, nil
} | go | {
"resource": ""
} |
q179414 | Send | test | func Send(c context.Context, msg *Message) error {
return send(c, "Send", msg)
} | go | {
"resource": ""
} |
q179415 | SendToAdmins | test | func SendToAdmins(c context.Context, msg *Message) error {
return send(c, "SendToAdmins", msg)
} | go | {
"resource": ""
} |
q179416 | Failures | test | func (r *Report) Failures() int {
count := 0
for _, p := range r.Packages {
for _, t := range p.Tests {
if t.Result == FAIL {
count++
}
}
}
return count
} | go | {
"resource": ""
} |
q179417 | decodeFieldNumberAndTyp3 | test | func decodeFieldNumberAndTyp3(bz []byte) (num uint32, typ Typ3, n int, err error) {
// Read uvarint value.
var value64 = uint64(0)
value64, n, err = DecodeUvarint(bz)
if err != nil {
return
}
// Decode first typ3 byte.
typ = Typ3(value64 & 0x07)
// Decode num.
var num64 uint64
num64 = value64 >> 3
if nu... | go | {
"resource": ""
} |
q179418 | checkTyp3 | test | func checkTyp3(rt reflect.Type, typ Typ3, fopts FieldOptions) (err error) {
typWanted := typeToTyp3(rt, fopts)
if typ != typWanted {
err = fmt.Errorf("unexpected Typ3. want %v, got %v", typWanted, typ)
}
return
} | go | {
"resource": ""
} |
q179419 | decodeTyp3 | test | func decodeTyp3(bz []byte) (typ Typ3, n int, err error) {
if len(bz) == 0 {
err = fmt.Errorf("EOF while reading typ3 byte")
return
}
if bz[0]&0xF8 != 0 {
err = fmt.Errorf("invalid typ3 byte: %v", Typ3(bz[0]).String())
return
}
typ = Typ3(bz[0])
n = 1
return
} | go | {
"resource": ""
} |
q179420 | NewPrefixBytes | test | func NewPrefixBytes(prefixBytes []byte) PrefixBytes {
pb := PrefixBytes{}
copy(pb[:], prefixBytes)
return pb
} | go | {
"resource": ""
} |
q179421 | getLengthStr | test | func getLengthStr(info *TypeInfo) string {
switch info.Type.Kind() {
case reflect.Array,
reflect.Int8,
reflect.Int16, reflect.Int32, reflect.Int64,
reflect.Float32, reflect.Float64,
reflect.Complex64, reflect.Complex128:
s := info.Type.Size()
return fmt.Sprintf("0x%X", s)
default:
return "variable"
}
... | go | {
"resource": ""
} |
q179422 | collectImplementers_nolock | test | func (cdc *Codec) collectImplementers_nolock(info *TypeInfo) {
for _, cinfo := range cdc.concreteInfos {
if cinfo.PtrToType.Implements(info.Type) {
info.Implementers[cinfo.Prefix] = append(
info.Implementers[cinfo.Prefix], cinfo)
}
}
} | go | {
"resource": ""
} |
q179423 | checkConflictsInPrio_nolock | test | func (cdc *Codec) checkConflictsInPrio_nolock(iinfo *TypeInfo) error {
for _, cinfos := range iinfo.Implementers {
if len(cinfos) < 2 {
continue
}
for _, cinfo := range cinfos {
var inPrio = false
for _, disfix := range iinfo.InterfaceInfo.Priority {
if cinfo.GetDisfix() == disfix {
inPrio = t... | go | {
"resource": ""
} |
q179424 | constructConcreteType | test | func constructConcreteType(cinfo *TypeInfo) (crv, irvSet reflect.Value) {
// Construct new concrete type.
if cinfo.PointerPreferred {
cPtrRv := reflect.New(cinfo.Type)
crv = cPtrRv.Elem()
irvSet = cPtrRv
} else {
crv = reflect.New(cinfo.Type).Elem()
irvSet = crv
}
return
} | go | {
"resource": ""
} |
q179425 | MarshalBinaryLengthPrefixedWriter | test | func (cdc *Codec) MarshalBinaryLengthPrefixedWriter(w io.Writer, o interface{}) (n int64, err error) {
var bz, _n = []byte(nil), int(0)
bz, err = cdc.MarshalBinaryLengthPrefixed(o)
if err != nil {
return 0, err
}
_n, err = w.Write(bz) // TODO: handle overflow in 32-bit systems.
n = int64(_n)
return
} | go | {
"resource": ""
} |
q179426 | MarshalBinaryBare | test | func (cdc *Codec) MarshalBinaryBare(o interface{}) ([]byte, error) {
// Dereference value if pointer.
var rv, _, isNilPtr = derefPointers(reflect.ValueOf(o))
if isNilPtr {
// NOTE: You can still do so by calling
// `.MarshalBinaryLengthPrefixed(struct{ *SomeType })` or so on.
panic("MarshalBinaryBare cannot m... | go | {
"resource": ""
} |
q179427 | UnmarshalBinaryLengthPrefixed | test | func (cdc *Codec) UnmarshalBinaryLengthPrefixed(bz []byte, ptr interface{}) error {
if len(bz) == 0 {
return errors.New("UnmarshalBinaryLengthPrefixed cannot decode empty bytes")
}
// Read byte-length prefix.
u64, n := binary.Uvarint(bz)
if n < 0 {
return fmt.Errorf("Error reading msg byte-length prefix: got ... | go | {
"resource": ""
} |
q179428 | UnmarshalBinaryBare | test | func (cdc *Codec) UnmarshalBinaryBare(bz []byte, ptr interface{}) error {
rv := reflect.ValueOf(ptr)
if rv.Kind() != reflect.Ptr {
panic("Unmarshal expects a pointer")
}
rv = rv.Elem()
rt := rv.Type()
info, err := cdc.getTypeInfo_wlock(rt)
if err != nil {
return err
}
// If registered concrete, consume an... | go | {
"resource": ""
} |
q179429 | MustMarshalJSON | test | func (cdc *Codec) MustMarshalJSON(o interface{}) []byte {
bz, err := cdc.MarshalJSON(o)
if err != nil {
panic(err)
}
return bz
} | go | {
"resource": ""
} |
q179430 | MustUnmarshalJSON | test | func (cdc *Codec) MustUnmarshalJSON(bz []byte, ptr interface{}) {
if err := cdc.UnmarshalJSON(bz, ptr); err != nil {
panic(err)
}
} | go | {
"resource": ""
} |
q179431 | MarshalJSONIndent | test | func (cdc *Codec) MarshalJSONIndent(o interface{}, prefix, indent string) ([]byte, error) {
bz, err := cdc.MarshalJSON(o)
if err != nil {
return nil, err
}
var out bytes.Buffer
err = json.Indent(&out, bz, prefix, indent)
if err != nil {
return nil, err
}
return out.Bytes(), nil
} | go | {
"resource": ""
} |
q179432 | newDataReader | test | func newDataReader(r io.Reader) *internalDataReader {
buffered := bufio.NewReader(r)
reader := internalDataReader{
wrapped:r,
buffered:buffered,
}
return &reader
} | go | {
"resource": ""
} |
q179433 | Read | test | func (r *internalDataReader) Read(data []byte) (n int, err error) {
const IAC = 255
const SB = 250
const SE = 240
const WILL = 251
const WONT = 252
const DO = 253
const DONT = 254
p := data
for len(p) > 0 {
var b byte
b, err = r.buffered.ReadByte()
if nil != err {
return n, err
}
if IAC =... | go | {
"resource": ""
} |
q179434 | ListenAndServeTLS | test | func (server *Server) ListenAndServeTLS(certFile string, keyFile string) error {
addr := server.Addr
if "" == addr {
addr = ":telnets"
}
listener, err := net.Listen("tcp", addr)
if nil != err {
return err
}
// Apparently have to make a copy of the TLS config this way, rather than by
// simple assignmen... | go | {
"resource": ""
} |
q179435 | Produce | test | func (fn ProducerFunc) Produce(ctx telnet.Context, name string, args ...string) Handler {
return fn(ctx, name, args...)
} | go | {
"resource": ""
} |
q179436 | PromoteHandlerFunc | test | func PromoteHandlerFunc(fn HandlerFunc, args ...string) Handler {
stdin, stdinPipe := io.Pipe()
stdoutPipe, stdout := io.Pipe()
stderrPipe, stderr := io.Pipe()
argsCopy := make([]string, len(args))
for i, datum := range args {
argsCopy[i] = datum
}
handler := internalPromotedHandlerFunc{
err:nil... | go | {
"resource": ""
} |
q179437 | Serve | test | func Serve(listener net.Listener, handler Handler) error {
server := &Server{Handler: handler}
return server.Serve(listener)
} | go | {
"resource": ""
} |
q179438 | Serve | test | func (server *Server) Serve(listener net.Listener) error {
defer listener.Close()
logger := server.logger()
handler := server.Handler
if nil == handler {
//@TODO: Should this be a "ShellHandler" instead, that gives a shell-like experience by default
// If this is changd, then need to change the comment i... | go | {
"resource": ""
} |
q179439 | Fail | test | func (p *Parser) Fail(msg string) {
p.WriteUsage(os.Stderr)
fmt.Fprintln(os.Stderr, "error:", msg)
os.Exit(-1)
} | go | {
"resource": ""
} |
q179440 | WriteUsage | test | func (p *Parser) WriteUsage(w io.Writer) {
var positionals, options []*spec
for _, spec := range p.specs {
if spec.positional {
positionals = append(positionals, spec)
} else {
options = append(options, spec)
}
}
if p.version != "" {
fmt.Fprintln(w, p.version)
}
fmt.Fprintf(w, "Usage: %s", p.confi... | go | {
"resource": ""
} |
q179441 | WriteHelp | test | func (p *Parser) WriteHelp(w io.Writer) {
var positionals, options []*spec
for _, spec := range p.specs {
if spec.positional {
positionals = append(positionals, spec)
} else {
options = append(options, spec)
}
}
if p.description != "" {
fmt.Fprintln(w, p.description)
}
p.WriteUsage(w)
// write th... | go | {
"resource": ""
} |
q179442 | MustParse | test | func MustParse(dest ...interface{}) *Parser {
p, err := NewParser(Config{}, dest...)
if err != nil {
fmt.Println(err)
os.Exit(-1)
}
err = p.Parse(flags())
if err == ErrHelp {
p.WriteHelp(os.Stdout)
os.Exit(0)
}
if err == ErrVersion {
fmt.Println(p.version)
os.Exit(0)
}
if err != nil {
p.Fail(err.... | go | {
"resource": ""
} |
q179443 | Parse | test | func Parse(dest ...interface{}) error {
p, err := NewParser(Config{}, dest...)
if err != nil {
return err
}
return p.Parse(flags())
} | go | {
"resource": ""
} |
q179444 | walkFields | test | func walkFields(v reflect.Value, visit func(field reflect.StructField, val reflect.Value, owner reflect.Type) bool) {
t := v.Type()
for i := 0; i < t.NumField(); i++ {
field := t.Field(i)
val := v.Field(i)
expand := visit(field, val, t)
if expand && field.Type.Kind() == reflect.Struct {
walkFields(val, vis... | go | {
"resource": ""
} |
q179445 | Parse | test | func (p *Parser) Parse(args []string) error {
// If -h or --help were specified then print usage
for _, arg := range args {
if arg == "-h" || arg == "--help" {
return ErrHelp
}
if arg == "--version" {
return ErrVersion
}
if arg == "--" {
break
}
}
// Process all command line arguments
return ... | go | {
"resource": ""
} |
q179446 | setSlice | test | func setSlice(dest reflect.Value, values []string, trunc bool) error {
if !dest.CanSet() {
return fmt.Errorf("field is not writable")
}
var ptr bool
elem := dest.Type().Elem()
if elem.Kind() == reflect.Ptr && !elem.Implements(textUnmarshalerType) {
ptr = true
elem = elem.Elem()
}
// Truncate the dest sli... | go | {
"resource": ""
} |
q179447 | canParse | test | func canParse(t reflect.Type) (parseable, boolean, multiple bool) {
parseable = scalar.CanParse(t)
boolean = isBoolean(t)
if parseable {
return
}
// Look inside pointer types
if t.Kind() == reflect.Ptr {
t = t.Elem()
}
// Look inside slice types
if t.Kind() == reflect.Slice {
multiple = true
t = t.Ele... | go | {
"resource": ""
} |
q179448 | isBoolean | test | func isBoolean(t reflect.Type) bool {
switch {
case t.Implements(textUnmarshalerType):
return false
case t.Kind() == reflect.Bool:
return true
case t.Kind() == reflect.Ptr && t.Elem().Kind() == reflect.Bool:
return true
default:
return false
}
} | go | {
"resource": ""
} |
q179449 | NewFromMap | test | func NewFromMap(m map[string]interface{}) *Tree {
t := &Tree{root: &node{}}
for k, v := range m {
t.Insert(k, v)
}
return t
} | go | {
"resource": ""
} |
q179450 | Insert | test | func (t *Tree) Insert(s string, v interface{}) (interface{}, bool) {
var parent *node
n := t.root
search := s
for {
// Handle key exhaution
if len(search) == 0 {
if n.isLeaf() {
old := n.leaf.val
n.leaf.val = v
return old, true
}
n.leaf = &leafNode{
key: s,
val: v,
}
t.size++... | go | {
"resource": ""
} |
q179451 | Delete | test | func (t *Tree) Delete(s string) (interface{}, bool) {
var parent *node
var label byte
n := t.root
search := s
for {
// Check for key exhaution
if len(search) == 0 {
if !n.isLeaf() {
break
}
goto DELETE
}
// Look for an edge
parent = n
label = search[0]
n = n.getEdge(label)
if n == nil... | go | {
"resource": ""
} |
q179452 | DeletePrefix | test | func (t *Tree) DeletePrefix(s string) int {
return t.deletePrefix(nil, t.root, s)
} | go | {
"resource": ""
} |
q179453 | deletePrefix | test | func (t *Tree) deletePrefix(parent, n *node, prefix string) int {
// Check for key exhaustion
if len(prefix) == 0 {
// Remove the leaf node
subTreeSize := 0
//recursively walk from all edges of the node to be deleted
recursiveWalk(n, func(s string, v interface{}) bool {
subTreeSize++
return false
})
... | go | {
"resource": ""
} |
q179454 | Get | test | func (t *Tree) Get(s string) (interface{}, bool) {
n := t.root
search := s
for {
// Check for key exhaution
if len(search) == 0 {
if n.isLeaf() {
return n.leaf.val, true
}
break
}
// Look for an edge
n = n.getEdge(search[0])
if n == nil {
break
}
// Consume the search prefix
if st... | go | {
"resource": ""
} |
q179455 | LongestPrefix | test | func (t *Tree) LongestPrefix(s string) (string, interface{}, bool) {
var last *leafNode
n := t.root
search := s
for {
// Look for a leaf node
if n.isLeaf() {
last = n.leaf
}
// Check for key exhaution
if len(search) == 0 {
break
}
// Look for an edge
n = n.getEdge(search[0])
if n == nil {
... | go | {
"resource": ""
} |
q179456 | Minimum | test | func (t *Tree) Minimum() (string, interface{}, bool) {
n := t.root
for {
if n.isLeaf() {
return n.leaf.key, n.leaf.val, true
}
if len(n.edges) > 0 {
n = n.edges[0].node
} else {
break
}
}
return "", nil, false
} | go | {
"resource": ""
} |
q179457 | WalkPrefix | test | func (t *Tree) WalkPrefix(prefix string, fn WalkFn) {
n := t.root
search := prefix
for {
// Check for key exhaution
if len(search) == 0 {
recursiveWalk(n, fn)
return
}
// Look for an edge
n = n.getEdge(search[0])
if n == nil {
break
}
// Consume the search prefix
if strings.HasPrefix(sea... | go | {
"resource": ""
} |
q179458 | recursiveWalk | test | func recursiveWalk(n *node, fn WalkFn) bool {
// Visit the leaf values if any
if n.leaf != nil && fn(n.leaf.key, n.leaf.val) {
return true
}
// Recurse on the children
for _, e := range n.edges {
if recursiveWalk(e.node, fn) {
return true
}
}
return false
} | go | {
"resource": ""
} |
q179459 | ToMap | test | func (t *Tree) ToMap() map[string]interface{} {
out := make(map[string]interface{}, t.size)
t.Walk(func(k string, v interface{}) bool {
out[k] = v
return false
})
return out
} | go | {
"resource": ""
} |
q179460 | checkip | test | func checkip(ip string) (iptype uint32, ipnum *big.Int, ipindex uint32) {
iptype = 0
ipnum = big.NewInt(0)
ipnumtmp := big.NewInt(0)
ipindex = 0
ipaddress := net.ParseIP(ip)
if ipaddress != nil {
v4 := ipaddress.To4()
if v4 != nil {
iptype = 4
ipnum.SetBytes(v4)
} else {
v6 := ipaddress.To16()... | go | {
"resource": ""
} |
q179461 | readuint32 | test | func readuint32(pos uint32) uint32 {
pos2 := int64(pos)
var retval uint32
data := make([]byte, 4)
_, err := f.ReadAt(data, pos2 - 1)
if err != nil {
fmt.Println("File read failed:", err)
}
buf := bytes.NewReader(data)
err = binary.Read(buf, binary.LittleEndian, &retval)
if err != nil {
fmt.Println("Binary ... | go | {
"resource": ""
} |
q179462 | readuint128 | test | func readuint128(pos uint32) *big.Int {
pos2 := int64(pos)
retval := big.NewInt(0)
data := make([]byte, 16)
_, err := f.ReadAt(data, pos2 - 1)
if err != nil {
fmt.Println("File read failed:", err)
}
// little endian to big endian
for i, j := 0, len(data)-1; i < j; i, j = i+1, j-1 {
data[i], data[j] = data... | go | {
"resource": ""
} |
q179463 | loadmessage | test | func loadmessage (mesg string) IP2Locationrecord {
var x IP2Locationrecord
x.Country_short = mesg
x.Country_long = mesg
x.Region = mesg
x.City = mesg
x.Isp = mesg
x.Domain = mesg
x.Zipcode = mesg
x.Timezone = mesg
x.Netspeed = mesg
x.Iddcode = mesg
x.Areacode = mesg
x.Weatherstationcode = mesg
x.Weather... | go | {
"resource": ""
} |
q179464 | Printrecord | test | func Printrecord(x IP2Locationrecord) {
fmt.Printf("country_short: %s\n", x.Country_short)
fmt.Printf("country_long: %s\n", x.Country_long)
fmt.Printf("region: %s\n", x.Region)
fmt.Printf("city: %s\n", x.City)
fmt.Printf("isp: %s\n", x.Isp)
fmt.Printf("latitude: %f\n", x.Latitude)
fmt.Printf("longitude: %f\n", x... | go | {
"resource": ""
} |
q179465 | Main | test | func Main(gc draw2d.GraphicContext, ext string) (string, error) {
gc.Save()
gc.Scale(0.5, 0.5)
// Draw a (partial) gopher
Draw(gc)
gc.Restore()
// Return the output filename
return samples.Output("gopher", ext), nil
} | go | {
"resource": ""
} |
q179466 | SaveToPdfFile | test | func SaveToPdfFile(filePath string, pdf *gofpdf.Fpdf) error {
return pdf.OutputFileAndClose(filePath)
} | go | {
"resource": ""
} |
q179467 | CubicCurveTo | test | func (p *Path) CubicCurveTo(cx1, cy1, cx2, cy2, x, y float64) {
if len(p.Components) == 0 { //special case when no move has been done
p.MoveTo(x, y)
} else {
p.appendToPath(CubicCurveToCmp, cx1, cy1, cx2, cy2, x, y)
}
p.x = x
p.y = y
} | go | {
"resource": ""
} |
q179468 | ArcTo | test | func (p *Path) ArcTo(cx, cy, rx, ry, startAngle, angle float64) {
endAngle := startAngle + angle
clockWise := true
if angle < 0 {
clockWise = false
}
// normalize
if clockWise {
for endAngle < startAngle {
endAngle += math.Pi * 2.0
}
} else {
for startAngle < endAngle {
startAngle += math.Pi * 2.0
... | go | {
"resource": ""
} |
q179469 | String | test | func (p *Path) String() string {
s := ""
j := 0
for _, cmd := range p.Components {
switch cmd {
case MoveToCmp:
s += fmt.Sprintf("MoveTo: %f, %f\n", p.Points[j], p.Points[j+1])
j = j + 2
case LineToCmp:
s += fmt.Sprintf("LineTo: %f, %f\n", p.Points[j], p.Points[j+1])
j = j + 2
case QuadCurveToCmp... | go | {
"resource": ""
} |
q179470 | VerticalFlip | test | func (path *Path) VerticalFlip() *Path {
p := path.Copy()
j := 0
for _, cmd := range p.Components {
switch cmd {
case MoveToCmp, LineToCmp:
p.Points[j+1] = -p.Points[j+1]
j = j + 2
case QuadCurveToCmp:
p.Points[j+1] = -p.Points[j+1]
p.Points[j+3] = -p.Points[j+3]
j = j + 4
case CubicCurveToCmp... | go | {
"resource": ""
} |
q179471 | NewGlyphCache | test | func NewGlyphCache() *GlyphCacheImp {
glyphs := make(map[string]map[rune]*Glyph)
return &GlyphCacheImp {
glyphs: glyphs,
}
} | go | {
"resource": ""
} |
q179472 | Fetch | test | func (glyphCache *GlyphCacheImp) Fetch(gc draw2d.GraphicContext, fontName string, chr rune) *Glyph {
if glyphCache.glyphs[fontName] == nil {
glyphCache.glyphs[fontName] = make(map[rune]*Glyph, 60)
}
if glyphCache.glyphs[fontName][chr] == nil {
glyphCache.glyphs[fontName][chr] = renderGlyph(gc, fontName, chr)
}
... | go | {
"resource": ""
} |
q179473 | renderGlyph | test | func renderGlyph(gc draw2d.GraphicContext, fontName string, chr rune) *Glyph {
gc.Save()
defer gc.Restore()
gc.BeginPath()
width := gc.CreateStringPath(string(chr), 0, 0)
path := gc.GetPath()
return &Glyph{
Path: &path,
Width: width,
}
} | go | {
"resource": ""
} |
q179474 | Copy | test | func (g *Glyph) Copy() *Glyph {
return &Glyph{
Path: g.Path.Copy(),
Width: g.Width,
}
} | go | {
"resource": ""
} |
q179475 | Fill | test | func (g *Glyph) Fill(gc draw2d.GraphicContext, x, y float64) float64 {
gc.Save()
gc.BeginPath()
gc.Translate(x, y)
gc.Fill(g.Path)
gc.Restore()
return g.Width
} | go | {
"resource": ""
} |
q179476 | Main | test | func Main(gc draw2d.GraphicContext, ext string) (string, error) {
gc.SetFillRule(draw2d.FillRuleWinding)
gc.Clear()
// Draw the line
for x := 5.0; x < 297; x += 10 {
Draw(gc, x, 0, x, 210)
}
gc.ClearRect(100, 75, 197, 135)
draw2dkit.Ellipse(gc, 148.5, 105, 35, 25)
gc.SetFillColor(color.RGBA{0xff, 0xff, 0x44, ... | go | {
"resource": ""
} |
q179477 | Draw | test | func Draw(gc draw2d.GraphicContext, x0, y0, x1, y1 float64) {
// Draw a line
gc.MoveTo(x0, y0)
gc.LineTo(x1, y1)
gc.Stroke()
} | go | {
"resource": ""
} |
q179478 | Paint | test | func (p *Painter) Paint(ss []raster.Span, done bool) {
//gl.Begin(gl.LINES)
sslen := len(ss)
clenrequired := sslen * 8
vlenrequired := sslen * 4
if clenrequired >= (cap(p.colors) - len(p.colors)) {
p.Flush()
if clenrequired >= cap(p.colors) {
p.vertices = make([]int32, 0, vlenrequired+(vlenrequired/2))
... | go | {
"resource": ""
} |
q179479 | SetColor | test | func (p *Painter) SetColor(c color.Color) {
r, g, b, a := c.RGBA()
if a == 0 {
p.cr = 0
p.cg = 0
p.cb = 0
p.ca = a
} else {
p.cr = uint8((r * M16 / a) >> 8)
p.cg = uint8((g * M16 / a) >> 8)
p.cb = uint8((b * M16 / a) >> 8)
p.ca = a
}
} | go | {
"resource": ""
} |
q179480 | NewPainter | test | func NewPainter() *Painter {
p := new(Painter)
p.vertices = make([]int32, 0, 1024)
p.colors = make([]uint8, 0, 1024)
return p
} | go | {
"resource": ""
} |
q179481 | GetStringBounds | test | func (gc *GraphicContext) GetStringBounds(s string) (left, top, right, bottom float64) {
f, err := gc.loadCurrentFont()
if err != nil {
log.Println(err)
return 0, 0, 0, 0
}
top, left, bottom, right = 10e6, 10e6, -10e6, -10e6
cursor := 0.0
prev, hasPrev := truetype.Index(0), false
for _, rune := range s {
i... | go | {
"resource": ""
} |
q179482 | recalc | test | func (gc *GraphicContext) recalc() {
gc.Current.Scale = gc.Current.FontSize * float64(gc.DPI) * (64.0 / 72.0)
} | go | {
"resource": ""
} |
q179483 | SetFont | test | func (gc *GraphicContext) SetFont(font *truetype.Font) {
gc.Current.Font = font
} | go | {
"resource": ""
} |
q179484 | ClearRect | test | func (gc *GraphicContext) ClearRect(x1, y1, x2, y2 int) {
mask := gc.newMask(x1, y1, x2-x1, y2-y1)
newGroup := &Group{
Groups: gc.svg.Groups,
Mask: "url(#" + mask.Id + ")",
}
// replace groups with new masked group
gc.svg.Groups = []*Group{newGroup}
} | go | {
"resource": ""
} |
q179485 | drawString | test | func (gc *GraphicContext) drawString(text string, drawType drawType, x, y float64) float64 {
switch gc.svg.FontMode {
case PathFontMode:
w := gc.CreateStringPath(text, x, y)
gc.drawPaths(drawType)
gc.Current.Path.Clear()
return w
case SvgFontMode:
gc.embedSvgFont(text)
}
// create elements
svgText := T... | go | {
"resource": ""
} |
q179486 | newGroup | test | func (gc *GraphicContext) newGroup(drawType drawType) *Group {
group := Group{}
// set attrs to group
if drawType&stroked == stroked {
group.Stroke = toSvgRGBA(gc.Current.StrokeColor)
group.StrokeWidth = toSvgLength(gc.Current.LineWidth)
group.StrokeLinecap = gc.Current.Cap.String()
group.StrokeLinejoin = gc... | go | {
"resource": ""
} |
q179487 | newMask | test | func (gc *GraphicContext) newMask(x, y, width, height int) *Mask {
mask := &Mask{}
mask.X = float64(x)
mask.Y = float64(y)
mask.Width = toSvgLength(float64(width))
mask.Height = toSvgLength(float64(height))
// attach mask
gc.svg.Masks = append(gc.svg.Masks, mask)
mask.Id = "mask-" + strconv.Itoa(len(gc.svg.Mas... | go | {
"resource": ""
} |
q179488 | embedSvgFont | test | func (gc *GraphicContext) embedSvgFont(text string) *Font {
fontName := gc.Current.FontData.Name
gc.loadCurrentFont()
// find or create font Element
svgFont := (*Font)(nil)
for _, font := range gc.svg.Fonts {
if font.Name == fontName {
svgFont = font
break
}
}
if svgFont == nil {
// create new
svg... | go | {
"resource": ""
} |
q179489 | TraceQuad | test | func TraceQuad(t Liner, quad []float64, flatteningThreshold float64) error {
if len(quad) < 6 {
return errors.New("quad length must be >= 6")
}
// Allocates curves stack
var curves [CurveRecursionLimit * 6]float64
copy(curves[0:6], quad[0:6])
i := 0
// current curve
var c []float64
var dx, dy, d float64
fo... | go | {
"resource": ""
} |
q179490 | GetFontName | test | func (cs *ContextStack) GetFontName() string {
fontData := cs.FontData
return fmt.Sprintf("%s:%d:%d:%9.2f", fontData.Name, fontData.Family, fontData.Style, cs.FontSize)
} | go | {
"resource": ""
} |
q179491 | NewStackGraphicContext | test | func NewStackGraphicContext() *StackGraphicContext {
gc := &StackGraphicContext{}
gc.Current = new(ContextStack)
gc.Current.Tr = draw2d.NewIdentityMatrix()
gc.Current.Path = new(draw2d.Path)
gc.Current.LineWidth = 1.0
gc.Current.StrokeColor = image.Black
gc.Current.FillColor = image.White
gc.Current.Cap = draw2... | go | {
"resource": ""
} |
q179492 | NewFolderFontCache | test | func NewFolderFontCache(folder string) *FolderFontCache {
return &FolderFontCache{
fonts: make(map[string]*truetype.Font),
folder: folder,
namer: FontFileName,
}
} | go | {
"resource": ""
} |
q179493 | NewSyncFolderFontCache | test | func NewSyncFolderFontCache(folder string) *SyncFolderFontCache {
return &SyncFolderFontCache{
fonts: make(map[string]*truetype.Font),
folder: folder,
namer: FontFileName,
}
} | go | {
"resource": ""
} |
q179494 | Main | test | func Main(gc draw2d.GraphicContext, ext string) (string, error) {
gc.SetStrokeColor(image.Black)
gc.SetFillColor(image.White)
gc.Save()
// Draw a (partial) gopher
gc.Translate(-60, 65)
gc.Rotate(-30 * (math.Pi / 180.0))
Draw(gc, 48, 48, 240, 72)
gc.Restore()
// Return the output filename
return samples.Outpu... | go | {
"resource": ""
} |
q179495 | NewPdf | test | func NewPdf(orientationStr, unitStr, sizeStr string) *gofpdf.Fpdf {
pdf := gofpdf.New(orientationStr, unitStr, sizeStr, draw2d.GetFontFolder())
// to be compatible with draw2d
pdf.SetMargins(0, 0, 0)
pdf.SetDrawColor(0, 0, 0)
pdf.SetFillColor(255, 255, 255)
pdf.SetLineCapStyle("round")
pdf.SetLineJoinStyle("roun... | go | {
"resource": ""
} |
q179496 | clearRect | test | func clearRect(gc *GraphicContext, x1, y1, x2, y2 float64) {
// save state
f := gc.Current.FillColor
x, y := gc.pdf.GetXY()
// cover page with white rectangle
gc.SetFillColor(white)
draw2dkit.Rectangle(gc, x1, y1, x2, y2)
gc.Fill()
// restore state
gc.SetFillColor(f)
gc.pdf.MoveTo(x, y)
} | go | {
"resource": ""
} |
q179497 | NewGraphicContext | test | func NewGraphicContext(pdf *gofpdf.Fpdf) *GraphicContext {
gc := &GraphicContext{draw2dbase.NewStackGraphicContext(), pdf, DPI}
gc.SetDPI(DPI)
return gc
} | go | {
"resource": ""
} |
q179498 | Clear | test | func (gc *GraphicContext) Clear() {
width, height := gc.pdf.GetPageSize()
clearRect(gc, 0, 0, width, height)
} | go | {
"resource": ""
} |
q179499 | GetStringBounds | test | func (gc *GraphicContext) GetStringBounds(s string) (left, top, right, bottom float64) {
_, h := gc.pdf.GetFontSize()
d := gc.pdf.GetFontDesc("", "")
if d.Ascent == 0 {
// not defined (standard font?), use average of 81%
top = 0.81 * h
} else {
top = -float64(d.Ascent) * h / float64(d.Ascent-d.Descent)
}
re... | go | {
"resource": ""
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.