_id stringlengths 2 7 | title stringlengths 1 118 | partition stringclasses 3
values | text stringlengths 52 85.5k | language stringclasses 1
value | meta_information dict |
|---|---|---|---|---|---|
q178000 | StringWithinTransport | test | func (s storageReference) StringWithinTransport() string {
optionsList := ""
options := s.transport.store.GraphOptions()
if len(options) > 0 {
optionsList = ":" + strings.Join(options, ",")
}
res := "[" + s.transport.store.GraphDriverName() + "@" + s.transport.store.GraphRoot() + "+" + s.transport.store.RunRoot(... | go | {
"resource": ""
} |
q178001 | PolicyConfigurationNamespaces | test | func (s storageReference) PolicyConfigurationNamespaces() []string {
storeSpec := "[" + s.transport.store.GraphDriverName() + "@" + s.transport.store.GraphRoot() + "]"
driverlessStoreSpec := "[" + s.transport.store.GraphRoot() + "]"
namespaces := []string{}
if s.named != nil {
if s.id != "" {
// The reference ... | go | {
"resource": ""
} |
q178002 | GzipDecompressor | test | func GzipDecompressor(r io.Reader) (io.ReadCloser, error) {
return pgzip.NewReader(r)
} | go | {
"resource": ""
} |
q178003 | Bzip2Decompressor | test | func Bzip2Decompressor(r io.Reader) (io.ReadCloser, error) {
return ioutil.NopCloser(bzip2.NewReader(r)), nil
} | go | {
"resource": ""
} |
q178004 | XzDecompressor | test | func XzDecompressor(r io.Reader) (io.ReadCloser, error) {
r, err := xz.NewReader(r)
if err != nil {
return nil, err
}
return ioutil.NopCloser(r), nil
} | go | {
"resource": ""
} |
q178005 | DetectCompression | test | func DetectCompression(input io.Reader) (DecompressorFunc, io.Reader, error) {
buffer := [8]byte{}
n, err := io.ReadAtLeast(input, buffer[:], len(buffer))
if err != nil && err != io.EOF && err != io.ErrUnexpectedEOF {
// This is a “real” error. We could just ignore it this time, process the data we have, and hope... | go | {
"resource": ""
} |
q178006 | newImageDestination | test | func newImageDestination(sys *types.SystemContext, ref dockerReference) (types.ImageDestination, error) {
c, err := newDockerClientFromRef(sys, ref, true, "pull,push")
if err != nil {
return nil, err
}
return &dockerImageDestination{
ref: ref,
c: c,
}, nil
} | go | {
"resource": ""
} |
q178007 | mountBlob | test | func (d *dockerImageDestination) mountBlob(ctx context.Context, srcRepo reference.Named, srcDigest digest.Digest, extraScope *authScope) error {
u := url.URL{
Path: fmt.Sprintf(blobUploadPath, reference.Path(d.ref.ref)),
RawQuery: url.Values{
"mount": {srcDigest.String()},
"from": {reference.Path(srcRepo)},... | go | {
"resource": ""
} |
q178008 | bicTransportScope | test | func bicTransportScope(ref dockerReference) types.BICTransportScope {
// Blobs can be reused across the whole registry.
return types.BICTransportScope{Opaque: reference.Domain(ref.ref)}
} | go | {
"resource": ""
} |
q178009 | newBICLocationReference | test | func newBICLocationReference(ref dockerReference) types.BICLocationReference {
// Blobs are scoped to repositories (the tag/digest are not necessary to reuse a blob).
return types.BICLocationReference{Opaque: ref.ref.Name()}
} | go | {
"resource": ""
} |
q178010 | parseBICLocationReference | test | func parseBICLocationReference(lr types.BICLocationReference) (reference.Named, error) {
return reference.ParseNormalizedNamed(lr.Opaque)
} | go | {
"resource": ""
} |
q178011 | NewSourceFromStream | test | func NewSourceFromStream(inputStream io.Reader) (*Source, error) {
// FIXME: use SystemContext here.
// Save inputStream to a temporary file
tarCopyFile, err := ioutil.TempFile(tmpdir.TemporaryDirectoryForBigFiles(), "docker-tar")
if err != nil {
return nil, errors.Wrap(err, "error creating temporary file")
}
d... | go | {
"resource": ""
} |
q178012 | readTarComponent | test | func (s *Source) readTarComponent(path string) ([]byte, error) {
file, err := s.openTarComponent(path)
if err != nil {
return nil, errors.Wrapf(err, "Error loading tar component %s", path)
}
defer file.Close()
bytes, err := ioutil.ReadAll(file)
if err != nil {
return nil, err
}
return bytes, nil
} | go | {
"resource": ""
} |
q178013 | ensureCachedDataIsPresent | test | func (s *Source) ensureCachedDataIsPresent() error {
s.cacheDataLock.Do(func() {
// Read and parse manifest.json
tarManifest, err := s.loadTarManifest()
if err != nil {
s.cacheDataResult = err
return
}
// Check to make sure length is 1
if len(tarManifest) != 1 {
s.cacheDataResult = errors.Errorf(... | go | {
"resource": ""
} |
q178014 | loadTarManifest | test | func (s *Source) loadTarManifest() ([]ManifestItem, error) {
// FIXME? Do we need to deal with the legacy format?
bytes, err := s.readTarComponent(manifestFileName)
if err != nil {
return nil, err
}
var items []ManifestItem
if err := json.Unmarshal(bytes, &items); err != nil {
return nil, errors.Wrap(err, "Er... | go | {
"resource": ""
} |
q178015 | Close | test | func (s *Source) Close() error {
if s.removeTarPathOnClose {
return os.Remove(s.tarPath)
}
return nil
} | go | {
"resource": ""
} |
q178016 | newImageDestination | test | func newImageDestination(ctx context.Context, sys *types.SystemContext, ref daemonReference) (types.ImageDestination, error) {
if ref.ref == nil {
return nil, errors.Errorf("Invalid destination docker-daemon:%s: a destination must be a name:tag", ref.StringWithinTransport())
}
namedTaggedRef, ok := ref.ref.(refere... | go | {
"resource": ""
} |
q178017 | imageLoadGoroutine | test | func imageLoadGoroutine(ctx context.Context, c *client.Client, reader *io.PipeReader, statusChannel chan<- error) {
err := errors.New("Internal error: unexpected panic in imageLoadGoroutine")
defer func() {
logrus.Debugf("docker-daemon: sending done, status %v", err)
statusChannel <- err
}()
defer func() {
if... | go | {
"resource": ""
} |
q178018 | NewReference | test | func NewReference(file, image string) (types.ImageReference, error) {
resolved, err := explicitfilepath.ResolvePathToFullyExplicit(file)
if err != nil {
return nil, err
}
if err := internal.ValidateOCIPath(file); err != nil {
return nil, err
}
if err := internal.ValidateImageName(image); err != nil {
retu... | go | {
"resource": ""
} |
q178019 | createOCIRef | test | func createOCIRef(image string) (tempDirOCIRef, error) {
dir, err := ioutil.TempDir(tmpdir.TemporaryDirectoryForBigFiles(), "oci")
if err != nil {
return tempDirOCIRef{}, errors.Wrapf(err, "error creating temp directory")
}
ociRef, err := ocilayout.NewReference(dir, image)
if err != nil {
return tempDirOCIRef{... | go | {
"resource": ""
} |
q178020 | createUntarTempDir | test | func createUntarTempDir(ref ociArchiveReference) (tempDirOCIRef, error) {
tempDirRef, err := createOCIRef(ref.image)
if err != nil {
return tempDirOCIRef{}, errors.Wrap(err, "error creating oci reference")
}
src := ref.resolvedFile
dst := tempDirRef.tempDirectory
// TODO: This can take quite some time, and shou... | go | {
"resource": ""
} |
q178021 | destructivelyPrioritizeReplacementCandidatesWithMax | test | func destructivelyPrioritizeReplacementCandidatesWithMax(cs []CandidateWithTime, primaryDigest, uncompressedDigest digest.Digest, maxCandidates int) []types.BICReplacementCandidate {
// We don't need to use sort.Stable() because nanosecond timestamps are (presumably?) unique, so no two elements should
// compare equa... | go | {
"resource": ""
} |
q178022 | newImageDestination | test | func newImageDestination(ref ostreeReference, tmpDirPath string) (types.ImageDestination, error) {
tmpDirPath = filepath.Join(tmpDirPath, ref.branchName)
if err := ensureDirectoryExists(tmpDirPath); err != nil {
return nil, err
}
return &ostreeImageDestination{ref, "", manifestSchema{}, tmpDirPath, map[string]*bl... | go | {
"resource": ""
} |
q178023 | resolveExistingPathToFullyExplicit | test | func resolveExistingPathToFullyExplicit(path string) (string, error) {
resolved, err := filepath.Abs(path)
if err != nil {
return "", err // Coverage: This can fail only if os.Getwd() fails.
}
resolved, err = filepath.EvalSymlinks(resolved)
if err != nil {
return "", err
}
return filepath.Clean(resolved), ni... | go | {
"resource": ""
} |
q178024 | newImageDestination | test | func newImageDestination(ref dirReference, compress bool) (types.ImageDestination, error) {
d := &dirImageDestination{ref: ref, compress: compress}
// If directory exists check if it is empty
// if not empty, check whether the contents match that of a container image directory and overwrite the contents
// if the ... | go | {
"resource": ""
} |
q178025 | isDirEmpty | test | func isDirEmpty(path string) (bool, error) {
files, err := ioutil.ReadDir(path)
if err != nil {
return false, err
}
return len(files) == 0, nil
} | go | {
"resource": ""
} |
q178026 | removeDirContents | test | func removeDirContents(path string) error {
files, err := ioutil.ReadDir(path)
if err != nil {
return err
}
for _, file := range files {
if err := os.RemoveAll(filepath.Join(path, file.Name())); err != nil {
return err
}
}
return nil
} | go | {
"resource": ""
} |
q178027 | GetRepositoryTags | test | func GetRepositoryTags(ctx context.Context, sys *types.SystemContext, ref types.ImageReference) ([]string, error) {
dr, ok := ref.(dockerReference)
if !ok {
return nil, errors.Errorf("ref must be a dockerReference")
}
path := fmt.Sprintf(tagsPath, reference.Path(dr.ref))
client, err := newDockerClientFromRef(sy... | go | {
"resource": ""
} |
q178028 | DefaultCache | test | func DefaultCache(sys *types.SystemContext) types.BlobInfoCache {
dir, err := blobInfoCacheDir(sys, getRootlessUID())
if err != nil {
logrus.Debugf("Error determining a location for %s, using a memory-only cache", blobInfoCacheFilename)
return memory.New()
}
path := filepath.Join(dir, blobInfoCacheFilename)
if... | go | {
"resource": ""
} |
q178029 | uncompressedDigestLocked | test | func (mem *cache) uncompressedDigestLocked(anyDigest digest.Digest) digest.Digest {
if d, ok := mem.uncompressedDigests[anyDigest]; ok {
return d
}
// Presence in digestsByUncompressed implies that anyDigest must already refer to an uncompressed digest.
// This way we don't have to waste storage space with trivia... | go | {
"resource": ""
} |
q178030 | Close | test | func (d *ociArchiveImageDestination) Close() error {
defer d.tempDirRef.deleteTempDir()
return d.unpackedDest.Close()
} | go | {
"resource": ""
} |
q178031 | PutManifest | test | func (d *ociArchiveImageDestination) PutManifest(ctx context.Context, m []byte) error {
return d.unpackedDest.PutManifest(ctx, m)
} | go | {
"resource": ""
} |
q178032 | Commit | test | func (d *ociArchiveImageDestination) Commit(ctx context.Context) error {
if err := d.unpackedDest.Commit(ctx); err != nil {
return errors.Wrapf(err, "error storing image %q", d.ref.image)
}
// path of directory to tar up
src := d.tempDirRef.tempDirectory
// path to save tarred up file
dst := d.ref.resolvedFile... | go | {
"resource": ""
} |
q178033 | tarDirectory | test | func tarDirectory(src, dst string) error {
// input is a stream of bytes from the archive of the directory at path
input, err := archive.Tar(src, archive.Uncompressed)
if err != nil {
return errors.Wrapf(err, "error retrieving stream of bytes from %q", src)
}
// creates the tar file
outFile, err := os.Create(d... | go | {
"resource": ""
} |
q178034 | ParseStoreReference | test | func (s storageTransport) ParseStoreReference(store storage.Store, ref string) (*storageReference, error) {
if ref == "" {
return nil, errors.Wrapf(ErrInvalidReference, "%q is an empty reference", ref)
}
if ref[0] == '[' {
// Ignore the store specifier.
closeIndex := strings.IndexRune(ref, ']')
if closeIndex... | go | {
"resource": ""
} |
q178035 | chooseDigestFromManifestList | test | func chooseDigestFromManifestList(sys *types.SystemContext, blob []byte) (digest.Digest, error) {
wantedArch := runtime.GOARCH
if sys != nil && sys.ArchitectureChoice != "" {
wantedArch = sys.ArchitectureChoice
}
wantedOS := runtime.GOOS
if sys != nil && sys.OSChoice != "" {
wantedOS = sys.OSChoice
}
list :... | go | {
"resource": ""
} |
q178036 | ChooseManifestInstanceFromManifestList | test | func ChooseManifestInstanceFromManifestList(ctx context.Context, sys *types.SystemContext, src types.UnparsedImage) (digest.Digest, error) {
// For now this only handles manifest.DockerV2ListMediaType; we can generalize it later,
// probably along with manifest list editing.
blob, mt, err := src.Manifest(ctx)
if er... | go | {
"resource": ""
} |
q178037 | manifestSchema1FromComponents | test | func manifestSchema1FromComponents(ref reference.Named, fsLayers []manifest.Schema1FSLayers, history []manifest.Schema1History, architecture string) (genericManifest, error) {
m, err := manifest.Schema1FromComponents(ref, fsLayers, history, architecture)
if err != nil {
return nil, err
}
return &manifestSchema1{m... | go | {
"resource": ""
} |
q178038 | manifestDigest | test | func (s *dockerImageSource) manifestDigest(ctx context.Context, instanceDigest *digest.Digest) (digest.Digest, error) {
if instanceDigest != nil {
return *instanceDigest, nil
}
if digested, ok := s.ref.ref.(reference.Digested); ok {
d := digested.Digest()
if d.Algorithm() == digest.Canonical {
return d, nil... | go | {
"resource": ""
} |
q178039 | deleteImage | test | func deleteImage(ctx context.Context, sys *types.SystemContext, ref dockerReference) error {
// docker/distribution does not document what action should be used for deleting images.
//
// Current docker/distribution requires "pull" for reading the manifest and "delete" for deleting it.
// quay.io requires "push" (a... | go | {
"resource": ""
} |
q178040 | Schema1FromComponents | test | func Schema1FromComponents(ref reference.Named, fsLayers []Schema1FSLayers, history []Schema1History, architecture string) (*Schema1, error) {
var name, tag string
if ref != nil { // Well, what to do if it _is_ nil? Most consumers actually don't use these fields nowadays, so we might as well try not supplying them.
... | go | {
"resource": ""
} |
q178041 | initialize | test | func (m *Schema1) initialize() error {
if len(m.FSLayers) != len(m.History) {
return errors.New("length of history not equal to number of layers")
}
if len(m.FSLayers) == 0 {
return errors.New("no FSLayers in manifest")
}
m.ExtractedV1Compatibility = make([]Schema1V1Compatibility, len(m.History))
for i, h := ... | go | {
"resource": ""
} |
q178042 | ToSchema2Config | test | func (m *Schema1) ToSchema2Config(diffIDs []digest.Digest) ([]byte, error) {
// Convert the schema 1 compat info into a schema 2 config, constructing some of the fields
// that aren't directly comparable using info from the manifest.
if len(m.History) == 0 {
return nil, errors.New("image has no layers")
}
s1 := ... | go | {
"resource": ""
} |
q178043 | Digest | test | func Digest(manifest []byte) (digest.Digest, error) {
if GuessMIMEType(manifest) == DockerV2Schema1SignedMediaType {
sig, err := libtrust.ParsePrettySignature(manifest, "signatures")
if err != nil {
return "", err
}
manifest, err = sig.Payload()
if err != nil {
// Coverage: This should never happen, li... | go | {
"resource": ""
} |
q178044 | MatchesDigest | test | func MatchesDigest(manifest []byte, expectedDigest digest.Digest) (bool, error) {
// This should eventually support various digest types.
actualDigest, err := Digest(manifest)
if err != nil {
return false, err
}
return expectedDigest == actualDigest, nil
} | go | {
"resource": ""
} |
q178045 | NormalizedMIMEType | test | func NormalizedMIMEType(input string) string {
switch input {
// "application/json" is a valid v2s1 value per https://github.com/docker/distribution/blob/master/docs/spec/manifest-v2-1.md .
// This works for now, when nothing else seems to return "application/json"; if that were not true, the mapping/detection might... | go | {
"resource": ""
} |
q178046 | FromBlob | test | func FromBlob(manblob []byte, mt string) (Manifest, error) {
switch NormalizedMIMEType(mt) {
case DockerV2Schema1MediaType, DockerV2Schema1SignedMediaType:
return Schema1FromManifest(manblob)
case imgspecv1.MediaTypeImageManifest:
return OCI1FromManifest(manblob)
case DockerV2Schema2MediaType:
return Schema2F... | go | {
"resource": ""
} |
q178047 | NewReference | test | func NewReference(path string) (types.ImageReference, error) {
resolved, err := explicitfilepath.ResolvePathToFullyExplicit(path)
if err != nil {
return nil, err
}
return dirReference{path: path, resolvedPath: resolved}, nil
} | go | {
"resource": ""
} |
q178048 | layerPath | test | func (ref dirReference) layerPath(digest digest.Digest) string {
// FIXME: Should we keep the digest identification?
return filepath.Join(ref.path, digest.Hex())
} | go | {
"resource": ""
} |
q178049 | signaturePath | test | func (ref dirReference) signaturePath(index int) string {
return filepath.Join(ref.path, fmt.Sprintf("signature-%d", index+1))
} | go | {
"resource": ""
} |
q178050 | New | test | func New(n int, ctor func() Worker) *Pool {
p := &Pool{
ctor: ctor,
reqChan: make(chan workRequest),
}
p.SetSize(n)
return p
} | go | {
"resource": ""
} |
q178051 | NewFunc | test | func NewFunc(n int, f func(interface{}) interface{}) *Pool {
return New(n, func() Worker {
return &closureWorker{
processor: f,
}
})
} | go | {
"resource": ""
} |
q178052 | ProcessTimed | test | func (p *Pool) ProcessTimed(
payload interface{},
timeout time.Duration,
) (interface{}, error) {
atomic.AddInt64(&p.queuedJobs, 1)
defer atomic.AddInt64(&p.queuedJobs, -1)
tout := time.NewTimer(timeout)
var request workRequest
var open bool
select {
case request, open = <-p.reqChan:
if !open {
return ... | go | {
"resource": ""
} |
q178053 | SetSize | test | func (p *Pool) SetSize(n int) {
p.workerMut.Lock()
defer p.workerMut.Unlock()
lWorkers := len(p.workers)
if lWorkers == n {
return
}
// Add extra workers if N > len(workers)
for i := lWorkers; i < n; i++ {
p.workers = append(p.workers, newWorkerWrapper(p.reqChan, p.ctor()))
}
// Asynchronously stop all ... | go | {
"resource": ""
} |
q178054 | GetSize | test | func (p *Pool) GetSize() int {
p.workerMut.Lock()
defer p.workerMut.Unlock()
return len(p.workers)
} | go | {
"resource": ""
} |
q178055 | TL | test | func (r *Rect) TL() Point {
return Point{int(r.x), int(r.y)}
} | go | {
"resource": ""
} |
q178056 | BR | test | func (r *Rect) BR() Point {
return Point{int(r.x) + int(r.width), int(r.y) + int(r.height)}
} | go | {
"resource": ""
} |
q178057 | CVBox | test | func (box *Box2D) CVBox() C.CvBox2D {
var cvBox C.CvBox2D
cvBox.angle = C.float(box.angle)
cvBox.center.x = C.float(box.center.X)
cvBox.center.y = C.float(box.center.Y)
cvBox.size.width = C.float(box.size.Width)
cvBox.size.height = C.float(box.size.Height)
return cvBox
} | go | {
"resource": ""
} |
q178058 | Points | test | func (box *Box2D) Points() []Point2D32f {
var pts [4]C.CvPoint2D32f
C.cvBoxPoints(
box.CVBox(),
(*C.CvPoint2D32f)(unsafe.Pointer(&pts[0])),
)
outPts := make([]Point2D32f, 4)
for i, p := range pts {
outPts[i].X = float32(p.x)
outPts[i].Y = float32(p.y)
}
return outPts
} | go | {
"resource": ""
} |
q178059 | FOURCC | test | func FOURCC(c1, c2, c3, c4 int8) uint32 {
rv := C.GoOpenCV_FOURCC_(C.int(c1), C.int(c2), C.int(c3), C.int(c4))
return uint32(rv)
} | go | {
"resource": ""
} |
q178060 | Merge | test | func Merge(imgBlue, imgGreen, imgRed, imgAlpha, dst *IplImage) {
C.cvMerge(
unsafe.Pointer(imgBlue),
unsafe.Pointer(imgGreen),
unsafe.Pointer(imgRed),
unsafe.Pointer(imgAlpha),
unsafe.Pointer(dst),
)
} | go | {
"resource": ""
} |
q178061 | Split | test | func Split(src, imgBlue, imgGreen, imgRed, imgAlpha *IplImage) {
C.cvSplit(
unsafe.Pointer(src),
unsafe.Pointer(imgBlue),
unsafe.Pointer(imgGreen),
unsafe.Pointer(imgRed),
unsafe.Pointer(imgAlpha),
)
} | go | {
"resource": ""
} |
q178062 | AddWeighted | test | func AddWeighted(src1 *IplImage, alpha float64, src2 *IplImage, beta float64, gamma float64, dst *IplImage) {
C.cvAddWeighted(
unsafe.Pointer(src1),
C.double(alpha),
unsafe.Pointer(src2),
C.double(beta),
C.double(gamma),
unsafe.Pointer(dst),
)
} | go | {
"resource": ""
} |
q178063 | And | test | func And(src1, src2, dst *IplImage) {
AndWithMask(src1, src2, dst, nil)
} | go | {
"resource": ""
} |
q178064 | AndWithMask | test | func AndWithMask(src1, src2, dst, mask *IplImage) {
C.cvAnd(
unsafe.Pointer(src1),
unsafe.Pointer(src2),
unsafe.Pointer(dst),
unsafe.Pointer(mask),
)
} | go | {
"resource": ""
} |
q178065 | AndScalar | test | func AndScalar(src *IplImage, value Scalar, dst *IplImage) {
AndScalarWithMask(src, value, dst, nil)
} | go | {
"resource": ""
} |
q178066 | AndScalarWithMask | test | func AndScalarWithMask(src *IplImage, value Scalar, dst, mask *IplImage) {
C.cvAndS(
unsafe.Pointer(src),
(C.CvScalar)(value),
unsafe.Pointer(dst),
unsafe.Pointer(mask),
)
} | go | {
"resource": ""
} |
q178067 | Or | test | func Or(src1, src2, dst *IplImage) {
OrWithMask(src1, src2, dst, nil)
} | go | {
"resource": ""
} |
q178068 | OrWithMask | test | func OrWithMask(src1, src2, dst, mask *IplImage) {
C.cvOr(
unsafe.Pointer(src1),
unsafe.Pointer(src2),
unsafe.Pointer(dst),
unsafe.Pointer(mask),
)
} | go | {
"resource": ""
} |
q178069 | OrScalar | test | func OrScalar(src *IplImage, value Scalar, dst *IplImage) {
OrScalarWithMask(src, value, dst, nil)
} | go | {
"resource": ""
} |
q178070 | OrScalarWithMask | test | func OrScalarWithMask(src *IplImage, value Scalar, dst, mask *IplImage) {
C.cvOrS(
unsafe.Pointer(src),
(C.CvScalar)(value),
unsafe.Pointer(dst),
unsafe.Pointer(mask),
)
} | go | {
"resource": ""
} |
q178071 | AddWithMask | test | func AddWithMask(src1, src2, dst, mask *IplImage) {
C.cvAdd(
unsafe.Pointer(src1),
unsafe.Pointer(src2),
unsafe.Pointer(dst),
unsafe.Pointer(mask),
)
} | go | {
"resource": ""
} |
q178072 | AddScalar | test | func AddScalar(src *IplImage, value Scalar, dst *IplImage) {
AddScalarWithMask(src, value, dst, nil)
} | go | {
"resource": ""
} |
q178073 | AddScalarWithMask | test | func AddScalarWithMask(src *IplImage, value Scalar, dst, mask *IplImage) {
C.cvAddS(
unsafe.Pointer(src),
(C.CvScalar)(value),
unsafe.Pointer(dst),
unsafe.Pointer(mask),
)
} | go | {
"resource": ""
} |
q178074 | Subtract | test | func Subtract(src1, src2, dst *IplImage) {
SubtractWithMask(src1, src2, dst, nil)
} | go | {
"resource": ""
} |
q178075 | SubtractWithMask | test | func SubtractWithMask(src1, src2, dst, mask *IplImage) {
C.cvSub(
unsafe.Pointer(src1),
unsafe.Pointer(src2),
unsafe.Pointer(dst),
unsafe.Pointer(mask),
)
} | go | {
"resource": ""
} |
q178076 | SubScalar | test | func SubScalar(src *IplImage, value Scalar, dst *IplImage) {
SubScalarWithMask(src, value, dst, nil)
} | go | {
"resource": ""
} |
q178077 | SubScalarWithMask | test | func SubScalarWithMask(src *IplImage, value Scalar, dst, mask *IplImage) {
C.cvSubS(
unsafe.Pointer(src),
(C.CvScalar)(value),
unsafe.Pointer(dst),
unsafe.Pointer(mask),
)
} | go | {
"resource": ""
} |
q178078 | SubScalarRev | test | func SubScalarRev(value Scalar, src, dst *IplImage) {
SubScalarWithMaskRev(value, src, dst, nil)
} | go | {
"resource": ""
} |
q178079 | SubScalarWithMaskRev | test | func SubScalarWithMaskRev(value Scalar, src, dst, mask *IplImage) {
C.cvSubRS(
unsafe.Pointer(src),
(C.CvScalar)(value),
unsafe.Pointer(dst),
unsafe.Pointer(mask),
)
} | go | {
"resource": ""
} |
q178080 | AbsDiff | test | func AbsDiff(src1, src2, dst *IplImage) {
C.cvAbsDiff(
unsafe.Pointer(src1),
unsafe.Pointer(src2),
unsafe.Pointer(dst),
)
} | go | {
"resource": ""
} |
q178081 | AbsDiffScalar | test | func AbsDiffScalar(src *IplImage, value Scalar, dst *IplImage) {
C.cvAbsDiffS(
unsafe.Pointer(src),
unsafe.Pointer(dst),
(C.CvScalar)(value),
)
} | go | {
"resource": ""
} |
q178082 | MeanStdDevWithMask | test | func MeanStdDevWithMask(src, mask *IplImage) (Scalar, Scalar) {
var mean, stdDev Scalar
C.cvAvgSdv(
unsafe.Pointer(src),
(*C.CvScalar)(&mean),
(*C.CvScalar)(&stdDev),
unsafe.Pointer(mask),
)
return mean, stdDev
} | go | {
"resource": ""
} |
q178083 | CreateSeq | test | func CreateSeq(seq_flags, elem_size int) *Seq {
return (*Seq)(C.cvCreateSeq(
C.int(seq_flags),
C.size_t(unsafe.Sizeof(Seq{})),
C.size_t(elem_size),
C.cvCreateMemStorage(C.int(0)),
))
} | go | {
"resource": ""
} |
q178084 | Push | test | func (seq *Seq) Push(element unsafe.Pointer) unsafe.Pointer {
return unsafe.Pointer(C.cvSeqPush((*C.struct_CvSeq)(seq), element))
} | go | {
"resource": ""
} |
q178085 | Pop | test | func (seq *Seq) Pop(element unsafe.Pointer) {
C.cvSeqPop((*C.struct_CvSeq)(seq), element)
} | go | {
"resource": ""
} |
q178086 | PushFront | test | func (seq *Seq) PushFront(element unsafe.Pointer) unsafe.Pointer {
return unsafe.Pointer((C.cvSeqPushFront((*C.struct_CvSeq)(seq), element)))
} | go | {
"resource": ""
} |
q178087 | PopFront | test | func (seq *Seq) PopFront(element unsafe.Pointer) {
C.cvSeqPopFront((*C.struct_CvSeq)(seq), element)
} | go | {
"resource": ""
} |
q178088 | GetElemAt | test | func (seq *Seq) GetElemAt(index int) unsafe.Pointer {
return (unsafe.Pointer)(C.cvGetSeqElem(
(*C.struct_CvSeq)(seq),
C.int(index),
))
} | go | {
"resource": ""
} |
q178089 | RemoveAt | test | func (seq *Seq) RemoveAt(index int) {
C.cvSeqRemove((*C.struct_CvSeq)(seq), C.int(index))
} | go | {
"resource": ""
} |
q178090 | Delay | test | func Delay(delay time.Duration) Option {
return func(c *Config) {
c.delay = delay
}
} | go | {
"resource": ""
} |
q178091 | BackOffDelay | test | func BackOffDelay(n uint, config *Config) time.Duration {
return config.delay * (1 << (n - 1))
} | go | {
"resource": ""
} |
q178092 | Error | test | func (e Error) Error() string {
logWithNumber := make([]string, lenWithoutNil(e))
for i, l := range e {
if l != nil {
logWithNumber[i] = fmt.Sprintf("#%d: %s", i+1, l.Error())
}
}
return fmt.Sprintf("All attempts fail:\n%s", strings.Join(logWithNumber, "\n"))
} | go | {
"resource": ""
} |
q178093 | Arguments | test | func (r *RequestBuilder) Arguments(args ...string) *RequestBuilder {
r.args = append(r.args, args...)
return r
} | go | {
"resource": ""
} |
q178094 | BodyString | test | func (r *RequestBuilder) BodyString(body string) *RequestBuilder {
return r.Body(strings.NewReader(body))
} | go | {
"resource": ""
} |
q178095 | BodyBytes | test | func (r *RequestBuilder) BodyBytes(body []byte) *RequestBuilder {
return r.Body(bytes.NewReader(body))
} | go | {
"resource": ""
} |
q178096 | Body | test | func (r *RequestBuilder) Body(body io.Reader) *RequestBuilder {
r.body = body
return r
} | go | {
"resource": ""
} |
q178097 | Option | test | func (r *RequestBuilder) Option(key string, value interface{}) *RequestBuilder {
var s string
switch v := value.(type) {
case bool:
s = strconv.FormatBool(v)
case string:
s = v
case []byte:
s = string(v)
default:
// slow case.
s = fmt.Sprint(value)
}
if r.opts == nil {
r.opts = make(map[string]strin... | go | {
"resource": ""
} |
q178098 | Header | test | func (r *RequestBuilder) Header(name, value string) *RequestBuilder {
if r.headers == nil {
r.headers = make(map[string]string, 1)
}
r.headers[name] = value
return r
} | go | {
"resource": ""
} |
q178099 | Send | test | func (r *RequestBuilder) Send(ctx context.Context) (*Response, error) {
req := NewRequest(ctx, r.shell.url, r.command, r.args...)
req.Opts = r.opts
req.Headers = r.headers
req.Body = r.body
return req.Send(&r.shell.httpcli)
} | go | {
"resource": ""
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.