id
int32 0
167k
| repo
stringlengths 5
54
| path
stringlengths 4
155
| func_name
stringlengths 1
118
| original_string
stringlengths 52
85.5k
| language
stringclasses 1
value | code
stringlengths 52
85.5k
| code_tokens
listlengths 21
1.41k
| docstring
stringlengths 6
2.61k
| docstring_tokens
listlengths 3
215
| sha
stringlengths 40
40
| url
stringlengths 85
252
|
|---|---|---|---|---|---|---|---|---|---|---|---|
151,100 |
paulmach/orb
|
maptile/tilecover/helpers.go
|
Point
|
func Point(ll orb.Point, z maptile.Zoom) maptile.Set {
return maptile.Set{
maptile.At(ll, z): true,
}
}
|
go
|
func Point(ll orb.Point, z maptile.Zoom) maptile.Set {
return maptile.Set{
maptile.At(ll, z): true,
}
}
|
[
"func",
"Point",
"(",
"ll",
"orb",
".",
"Point",
",",
"z",
"maptile",
".",
"Zoom",
")",
"maptile",
".",
"Set",
"{",
"return",
"maptile",
".",
"Set",
"{",
"maptile",
".",
"At",
"(",
"ll",
",",
"z",
")",
":",
"true",
",",
"}",
"\n",
"}"
] |
// Point creates a tile cover for the point, i.e. just the tile
// containing the point.
|
[
"Point",
"creates",
"a",
"tile",
"cover",
"for",
"the",
"point",
"i",
".",
"e",
".",
"just",
"the",
"tile",
"containing",
"the",
"point",
"."
] |
c6e407b203494d3b1edb9fd5cae4cf34a4ae0f29
|
https://github.com/paulmach/orb/blob/c6e407b203494d3b1edb9fd5cae4cf34a4ae0f29/maptile/tilecover/helpers.go#L43-L47
|
151,101 |
paulmach/orb
|
maptile/tilecover/helpers.go
|
MultiPoint
|
func MultiPoint(mp orb.MultiPoint, z maptile.Zoom) maptile.Set {
set := make(maptile.Set)
for _, p := range mp {
set[maptile.At(p, z)] = true
}
return set
}
|
go
|
func MultiPoint(mp orb.MultiPoint, z maptile.Zoom) maptile.Set {
set := make(maptile.Set)
for _, p := range mp {
set[maptile.At(p, z)] = true
}
return set
}
|
[
"func",
"MultiPoint",
"(",
"mp",
"orb",
".",
"MultiPoint",
",",
"z",
"maptile",
".",
"Zoom",
")",
"maptile",
".",
"Set",
"{",
"set",
":=",
"make",
"(",
"maptile",
".",
"Set",
")",
"\n",
"for",
"_",
",",
"p",
":=",
"range",
"mp",
"{",
"set",
"[",
"maptile",
".",
"At",
"(",
"p",
",",
"z",
")",
"]",
"=",
"true",
"\n",
"}",
"\n\n",
"return",
"set",
"\n",
"}"
] |
// MultiPoint creates a tile cover for the set of points,
|
[
"MultiPoint",
"creates",
"a",
"tile",
"cover",
"for",
"the",
"set",
"of",
"points"
] |
c6e407b203494d3b1edb9fd5cae4cf34a4ae0f29
|
https://github.com/paulmach/orb/blob/c6e407b203494d3b1edb9fd5cae4cf34a4ae0f29/maptile/tilecover/helpers.go#L50-L57
|
151,102 |
paulmach/orb
|
maptile/tilecover/helpers.go
|
Bound
|
func Bound(b orb.Bound, z maptile.Zoom) maptile.Set {
lo := maptile.At(b.Min, z)
hi := maptile.At(b.Max, z)
result := make(maptile.Set, (hi.X-lo.X+1)*(lo.Y-hi.Y+1))
for x := lo.X; x <= hi.X; x++ {
for y := hi.Y; y <= lo.Y; y++ {
result[maptile.Tile{X: x, Y: y, Z: z}] = true
}
}
return result
}
|
go
|
func Bound(b orb.Bound, z maptile.Zoom) maptile.Set {
lo := maptile.At(b.Min, z)
hi := maptile.At(b.Max, z)
result := make(maptile.Set, (hi.X-lo.X+1)*(lo.Y-hi.Y+1))
for x := lo.X; x <= hi.X; x++ {
for y := hi.Y; y <= lo.Y; y++ {
result[maptile.Tile{X: x, Y: y, Z: z}] = true
}
}
return result
}
|
[
"func",
"Bound",
"(",
"b",
"orb",
".",
"Bound",
",",
"z",
"maptile",
".",
"Zoom",
")",
"maptile",
".",
"Set",
"{",
"lo",
":=",
"maptile",
".",
"At",
"(",
"b",
".",
"Min",
",",
"z",
")",
"\n",
"hi",
":=",
"maptile",
".",
"At",
"(",
"b",
".",
"Max",
",",
"z",
")",
"\n\n",
"result",
":=",
"make",
"(",
"maptile",
".",
"Set",
",",
"(",
"hi",
".",
"X",
"-",
"lo",
".",
"X",
"+",
"1",
")",
"*",
"(",
"lo",
".",
"Y",
"-",
"hi",
".",
"Y",
"+",
"1",
")",
")",
"\n\n",
"for",
"x",
":=",
"lo",
".",
"X",
";",
"x",
"<=",
"hi",
".",
"X",
";",
"x",
"++",
"{",
"for",
"y",
":=",
"hi",
".",
"Y",
";",
"y",
"<=",
"lo",
".",
"Y",
";",
"y",
"++",
"{",
"result",
"[",
"maptile",
".",
"Tile",
"{",
"X",
":",
"x",
",",
"Y",
":",
"y",
",",
"Z",
":",
"z",
"}",
"]",
"=",
"true",
"\n",
"}",
"\n",
"}",
"\n\n",
"return",
"result",
"\n",
"}"
] |
// Bound creates a tile cover for the bound. i.e. all the tiles
// that intersect the bound.
|
[
"Bound",
"creates",
"a",
"tile",
"cover",
"for",
"the",
"bound",
".",
"i",
".",
"e",
".",
"all",
"the",
"tiles",
"that",
"intersect",
"the",
"bound",
"."
] |
c6e407b203494d3b1edb9fd5cae4cf34a4ae0f29
|
https://github.com/paulmach/orb/blob/c6e407b203494d3b1edb9fd5cae4cf34a4ae0f29/maptile/tilecover/helpers.go#L61-L74
|
151,103 |
paulmach/orb
|
maptile/tilecover/helpers.go
|
Collection
|
func Collection(c orb.Collection, z maptile.Zoom) maptile.Set {
set := make(maptile.Set)
for _, g := range c {
set.Merge(Geometry(g, z))
}
return set
}
|
go
|
func Collection(c orb.Collection, z maptile.Zoom) maptile.Set {
set := make(maptile.Set)
for _, g := range c {
set.Merge(Geometry(g, z))
}
return set
}
|
[
"func",
"Collection",
"(",
"c",
"orb",
".",
"Collection",
",",
"z",
"maptile",
".",
"Zoom",
")",
"maptile",
".",
"Set",
"{",
"set",
":=",
"make",
"(",
"maptile",
".",
"Set",
")",
"\n",
"for",
"_",
",",
"g",
":=",
"range",
"c",
"{",
"set",
".",
"Merge",
"(",
"Geometry",
"(",
"g",
",",
"z",
")",
")",
"\n",
"}",
"\n\n",
"return",
"set",
"\n",
"}"
] |
// Collection returns the covering set of tiles for the
// geoemtry collection.
|
[
"Collection",
"returns",
"the",
"covering",
"set",
"of",
"tiles",
"for",
"the",
"geoemtry",
"collection",
"."
] |
c6e407b203494d3b1edb9fd5cae4cf34a4ae0f29
|
https://github.com/paulmach/orb/blob/c6e407b203494d3b1edb9fd5cae4cf34a4ae0f29/maptile/tilecover/helpers.go#L78-L85
|
151,104 |
paulmach/orb
|
polygon.go
|
Equal
|
func (p Polygon) Equal(polygon Polygon) bool {
if len(p) != len(polygon) {
return false
}
for i := range p {
if !p[i].Equal(polygon[i]) {
return false
}
}
return true
}
|
go
|
func (p Polygon) Equal(polygon Polygon) bool {
if len(p) != len(polygon) {
return false
}
for i := range p {
if !p[i].Equal(polygon[i]) {
return false
}
}
return true
}
|
[
"func",
"(",
"p",
"Polygon",
")",
"Equal",
"(",
"polygon",
"Polygon",
")",
"bool",
"{",
"if",
"len",
"(",
"p",
")",
"!=",
"len",
"(",
"polygon",
")",
"{",
"return",
"false",
"\n",
"}",
"\n\n",
"for",
"i",
":=",
"range",
"p",
"{",
"if",
"!",
"p",
"[",
"i",
"]",
".",
"Equal",
"(",
"polygon",
"[",
"i",
"]",
")",
"{",
"return",
"false",
"\n",
"}",
"\n",
"}",
"\n\n",
"return",
"true",
"\n",
"}"
] |
// Equal compares two polygons. Returns true if lengths are the same
// and all points are Equal.
|
[
"Equal",
"compares",
"two",
"polygons",
".",
"Returns",
"true",
"if",
"lengths",
"are",
"the",
"same",
"and",
"all",
"points",
"are",
"Equal",
"."
] |
c6e407b203494d3b1edb9fd5cae4cf34a4ae0f29
|
https://github.com/paulmach/orb/blob/c6e407b203494d3b1edb9fd5cae4cf34a4ae0f29/polygon.go#L28-L40
|
151,105 |
paulmach/orb
|
polygon.go
|
Clone
|
func (p Polygon) Clone() Polygon {
if p == nil {
return p
}
np := make(Polygon, 0, len(p))
for _, r := range p {
np = append(np, r.Clone())
}
return np
}
|
go
|
func (p Polygon) Clone() Polygon {
if p == nil {
return p
}
np := make(Polygon, 0, len(p))
for _, r := range p {
np = append(np, r.Clone())
}
return np
}
|
[
"func",
"(",
"p",
"Polygon",
")",
"Clone",
"(",
")",
"Polygon",
"{",
"if",
"p",
"==",
"nil",
"{",
"return",
"p",
"\n",
"}",
"\n\n",
"np",
":=",
"make",
"(",
"Polygon",
",",
"0",
",",
"len",
"(",
"p",
")",
")",
"\n",
"for",
"_",
",",
"r",
":=",
"range",
"p",
"{",
"np",
"=",
"append",
"(",
"np",
",",
"r",
".",
"Clone",
"(",
")",
")",
"\n",
"}",
"\n\n",
"return",
"np",
"\n",
"}"
] |
// Clone returns a new deep copy of the polygon.
// All of the rings are also cloned.
|
[
"Clone",
"returns",
"a",
"new",
"deep",
"copy",
"of",
"the",
"polygon",
".",
"All",
"of",
"the",
"rings",
"are",
"also",
"cloned",
"."
] |
c6e407b203494d3b1edb9fd5cae4cf34a4ae0f29
|
https://github.com/paulmach/orb/blob/c6e407b203494d3b1edb9fd5cae4cf34a4ae0f29/polygon.go#L44-L55
|
151,106 |
paulmach/orb
|
multi_polygon.go
|
Bound
|
func (mp MultiPolygon) Bound() Bound {
if len(mp) == 0 {
return emptyBound
}
bound := mp[0].Bound()
for i := 1; i < len(mp); i++ {
bound = bound.Union(mp[i].Bound())
}
return bound
}
|
go
|
func (mp MultiPolygon) Bound() Bound {
if len(mp) == 0 {
return emptyBound
}
bound := mp[0].Bound()
for i := 1; i < len(mp); i++ {
bound = bound.Union(mp[i].Bound())
}
return bound
}
|
[
"func",
"(",
"mp",
"MultiPolygon",
")",
"Bound",
"(",
")",
"Bound",
"{",
"if",
"len",
"(",
"mp",
")",
"==",
"0",
"{",
"return",
"emptyBound",
"\n",
"}",
"\n",
"bound",
":=",
"mp",
"[",
"0",
"]",
".",
"Bound",
"(",
")",
"\n",
"for",
"i",
":=",
"1",
";",
"i",
"<",
"len",
"(",
"mp",
")",
";",
"i",
"++",
"{",
"bound",
"=",
"bound",
".",
"Union",
"(",
"mp",
"[",
"i",
"]",
".",
"Bound",
"(",
")",
")",
"\n",
"}",
"\n\n",
"return",
"bound",
"\n",
"}"
] |
// Bound returns a bound around the multi-polygon.
|
[
"Bound",
"returns",
"a",
"bound",
"around",
"the",
"multi",
"-",
"polygon",
"."
] |
c6e407b203494d3b1edb9fd5cae4cf34a4ae0f29
|
https://github.com/paulmach/orb/blob/c6e407b203494d3b1edb9fd5cae4cf34a4ae0f29/multi_polygon.go#L17-L27
|
151,107 |
paulmach/orb
|
multi_polygon.go
|
Equal
|
func (mp MultiPolygon) Equal(multiPolygon MultiPolygon) bool {
if len(mp) != len(multiPolygon) {
return false
}
for i, p := range mp {
if !p.Equal(multiPolygon[i]) {
return false
}
}
return true
}
|
go
|
func (mp MultiPolygon) Equal(multiPolygon MultiPolygon) bool {
if len(mp) != len(multiPolygon) {
return false
}
for i, p := range mp {
if !p.Equal(multiPolygon[i]) {
return false
}
}
return true
}
|
[
"func",
"(",
"mp",
"MultiPolygon",
")",
"Equal",
"(",
"multiPolygon",
"MultiPolygon",
")",
"bool",
"{",
"if",
"len",
"(",
"mp",
")",
"!=",
"len",
"(",
"multiPolygon",
")",
"{",
"return",
"false",
"\n",
"}",
"\n\n",
"for",
"i",
",",
"p",
":=",
"range",
"mp",
"{",
"if",
"!",
"p",
".",
"Equal",
"(",
"multiPolygon",
"[",
"i",
"]",
")",
"{",
"return",
"false",
"\n",
"}",
"\n",
"}",
"\n\n",
"return",
"true",
"\n",
"}"
] |
// Equal compares two multi-polygons.
|
[
"Equal",
"compares",
"two",
"multi",
"-",
"polygons",
"."
] |
c6e407b203494d3b1edb9fd5cae4cf34a4ae0f29
|
https://github.com/paulmach/orb/blob/c6e407b203494d3b1edb9fd5cae4cf34a4ae0f29/multi_polygon.go#L30-L42
|
151,108 |
paulmach/orb
|
multi_polygon.go
|
Clone
|
func (mp MultiPolygon) Clone() MultiPolygon {
if mp == nil {
return nil
}
nmp := make(MultiPolygon, 0, len(mp))
for _, p := range mp {
nmp = append(nmp, p.Clone())
}
return nmp
}
|
go
|
func (mp MultiPolygon) Clone() MultiPolygon {
if mp == nil {
return nil
}
nmp := make(MultiPolygon, 0, len(mp))
for _, p := range mp {
nmp = append(nmp, p.Clone())
}
return nmp
}
|
[
"func",
"(",
"mp",
"MultiPolygon",
")",
"Clone",
"(",
")",
"MultiPolygon",
"{",
"if",
"mp",
"==",
"nil",
"{",
"return",
"nil",
"\n",
"}",
"\n\n",
"nmp",
":=",
"make",
"(",
"MultiPolygon",
",",
"0",
",",
"len",
"(",
"mp",
")",
")",
"\n",
"for",
"_",
",",
"p",
":=",
"range",
"mp",
"{",
"nmp",
"=",
"append",
"(",
"nmp",
",",
"p",
".",
"Clone",
"(",
")",
")",
"\n",
"}",
"\n\n",
"return",
"nmp",
"\n",
"}"
] |
// Clone returns a new deep copy of the multi-polygon.
|
[
"Clone",
"returns",
"a",
"new",
"deep",
"copy",
"of",
"the",
"multi",
"-",
"polygon",
"."
] |
c6e407b203494d3b1edb9fd5cae4cf34a4ae0f29
|
https://github.com/paulmach/orb/blob/c6e407b203494d3b1edb9fd5cae4cf34a4ae0f29/multi_polygon.go#L45-L56
|
151,109 |
paulmach/orb
|
internal/length/length.go
|
Length
|
func Length(g orb.Geometry, df orb.DistanceFunc) float64 {
if g == nil {
return 0
}
switch g := g.(type) {
case orb.Point:
return 0
case orb.MultiPoint:
return 0
case orb.LineString:
return lineStringLength(g, df)
case orb.MultiLineString:
sum := 0.0
for _, ls := range g {
sum += lineStringLength(ls, df)
}
return sum
case orb.Ring:
return lineStringLength(orb.LineString(g), df)
case orb.Polygon:
return polygonLength(g, df)
case orb.MultiPolygon:
sum := 0.0
for _, p := range g {
sum += polygonLength(p, df)
}
return sum
case orb.Collection:
sum := 0.0
for _, c := range g {
sum += Length(c, df)
}
return sum
case orb.Bound:
return Length(g.ToRing(), df)
}
panic(fmt.Sprintf("geometry type not supported: %T", g))
}
|
go
|
func Length(g orb.Geometry, df orb.DistanceFunc) float64 {
if g == nil {
return 0
}
switch g := g.(type) {
case orb.Point:
return 0
case orb.MultiPoint:
return 0
case orb.LineString:
return lineStringLength(g, df)
case orb.MultiLineString:
sum := 0.0
for _, ls := range g {
sum += lineStringLength(ls, df)
}
return sum
case orb.Ring:
return lineStringLength(orb.LineString(g), df)
case orb.Polygon:
return polygonLength(g, df)
case orb.MultiPolygon:
sum := 0.0
for _, p := range g {
sum += polygonLength(p, df)
}
return sum
case orb.Collection:
sum := 0.0
for _, c := range g {
sum += Length(c, df)
}
return sum
case orb.Bound:
return Length(g.ToRing(), df)
}
panic(fmt.Sprintf("geometry type not supported: %T", g))
}
|
[
"func",
"Length",
"(",
"g",
"orb",
".",
"Geometry",
",",
"df",
"orb",
".",
"DistanceFunc",
")",
"float64",
"{",
"if",
"g",
"==",
"nil",
"{",
"return",
"0",
"\n",
"}",
"\n\n",
"switch",
"g",
":=",
"g",
".",
"(",
"type",
")",
"{",
"case",
"orb",
".",
"Point",
":",
"return",
"0",
"\n",
"case",
"orb",
".",
"MultiPoint",
":",
"return",
"0",
"\n",
"case",
"orb",
".",
"LineString",
":",
"return",
"lineStringLength",
"(",
"g",
",",
"df",
")",
"\n",
"case",
"orb",
".",
"MultiLineString",
":",
"sum",
":=",
"0.0",
"\n",
"for",
"_",
",",
"ls",
":=",
"range",
"g",
"{",
"sum",
"+=",
"lineStringLength",
"(",
"ls",
",",
"df",
")",
"\n",
"}",
"\n\n",
"return",
"sum",
"\n",
"case",
"orb",
".",
"Ring",
":",
"return",
"lineStringLength",
"(",
"orb",
".",
"LineString",
"(",
"g",
")",
",",
"df",
")",
"\n",
"case",
"orb",
".",
"Polygon",
":",
"return",
"polygonLength",
"(",
"g",
",",
"df",
")",
"\n",
"case",
"orb",
".",
"MultiPolygon",
":",
"sum",
":=",
"0.0",
"\n",
"for",
"_",
",",
"p",
":=",
"range",
"g",
"{",
"sum",
"+=",
"polygonLength",
"(",
"p",
",",
"df",
")",
"\n",
"}",
"\n\n",
"return",
"sum",
"\n",
"case",
"orb",
".",
"Collection",
":",
"sum",
":=",
"0.0",
"\n",
"for",
"_",
",",
"c",
":=",
"range",
"g",
"{",
"sum",
"+=",
"Length",
"(",
"c",
",",
"df",
")",
"\n",
"}",
"\n\n",
"return",
"sum",
"\n",
"case",
"orb",
".",
"Bound",
":",
"return",
"Length",
"(",
"g",
".",
"ToRing",
"(",
")",
",",
"df",
")",
"\n",
"}",
"\n\n",
"panic",
"(",
"fmt",
".",
"Sprintf",
"(",
"\"",
"\"",
",",
"g",
")",
")",
"\n",
"}"
] |
// Length returns the length of the boundary of the geometry
// using 2d euclidean geometry.
|
[
"Length",
"returns",
"the",
"length",
"of",
"the",
"boundary",
"of",
"the",
"geometry",
"using",
"2d",
"euclidean",
"geometry",
"."
] |
c6e407b203494d3b1edb9fd5cae4cf34a4ae0f29
|
https://github.com/paulmach/orb/blob/c6e407b203494d3b1edb9fd5cae4cf34a4ae0f29/internal/length/length.go#L11-L53
|
151,110 |
paulmach/orb
|
encoding/mvt/layer.go
|
NewLayer
|
func NewLayer(name string, fc *geojson.FeatureCollection) *Layer {
return &Layer{
Name: name,
Version: 1,
Extent: DefaultExtent,
Features: fc.Features,
}
}
|
go
|
func NewLayer(name string, fc *geojson.FeatureCollection) *Layer {
return &Layer{
Name: name,
Version: 1,
Extent: DefaultExtent,
Features: fc.Features,
}
}
|
[
"func",
"NewLayer",
"(",
"name",
"string",
",",
"fc",
"*",
"geojson",
".",
"FeatureCollection",
")",
"*",
"Layer",
"{",
"return",
"&",
"Layer",
"{",
"Name",
":",
"name",
",",
"Version",
":",
"1",
",",
"Extent",
":",
"DefaultExtent",
",",
"Features",
":",
"fc",
".",
"Features",
",",
"}",
"\n",
"}"
] |
// NewLayer is a helper to create a Layer from a feature collection
// and a name, it sets the default extent and version to 1.
|
[
"NewLayer",
"is",
"a",
"helper",
"to",
"create",
"a",
"Layer",
"from",
"a",
"feature",
"collection",
"and",
"a",
"name",
"it",
"sets",
"the",
"default",
"extent",
"and",
"version",
"to",
"1",
"."
] |
c6e407b203494d3b1edb9fd5cae4cf34a4ae0f29
|
https://github.com/paulmach/orb/blob/c6e407b203494d3b1edb9fd5cae4cf34a4ae0f29/encoding/mvt/layer.go#L24-L31
|
151,111 |
paulmach/orb
|
encoding/mvt/layer.go
|
ProjectToTile
|
func (l *Layer) ProjectToTile(tile maptile.Tile) {
p := newProjection(tile, l.Extent)
for _, f := range l.Features {
f.Geometry = project.Geometry(f.Geometry, p.ToTile)
}
}
|
go
|
func (l *Layer) ProjectToTile(tile maptile.Tile) {
p := newProjection(tile, l.Extent)
for _, f := range l.Features {
f.Geometry = project.Geometry(f.Geometry, p.ToTile)
}
}
|
[
"func",
"(",
"l",
"*",
"Layer",
")",
"ProjectToTile",
"(",
"tile",
"maptile",
".",
"Tile",
")",
"{",
"p",
":=",
"newProjection",
"(",
"tile",
",",
"l",
".",
"Extent",
")",
"\n",
"for",
"_",
",",
"f",
":=",
"range",
"l",
".",
"Features",
"{",
"f",
".",
"Geometry",
"=",
"project",
".",
"Geometry",
"(",
"f",
".",
"Geometry",
",",
"p",
".",
"ToTile",
")",
"\n",
"}",
"\n",
"}"
] |
// ProjectToTile will project all the geometries in the layer
// to tile coordinates based on the extent and the mercator projection.
|
[
"ProjectToTile",
"will",
"project",
"all",
"the",
"geometries",
"in",
"the",
"layer",
"to",
"tile",
"coordinates",
"based",
"on",
"the",
"extent",
"and",
"the",
"mercator",
"projection",
"."
] |
c6e407b203494d3b1edb9fd5cae4cf34a4ae0f29
|
https://github.com/paulmach/orb/blob/c6e407b203494d3b1edb9fd5cae4cf34a4ae0f29/encoding/mvt/layer.go#L35-L40
|
151,112 |
paulmach/orb
|
encoding/mvt/layer.go
|
ProjectToWGS84
|
func (l *Layer) ProjectToWGS84(tile maptile.Tile) {
p := newProjection(tile, l.Extent)
for _, f := range l.Features {
f.Geometry = project.Geometry(f.Geometry, p.ToWGS84)
}
}
|
go
|
func (l *Layer) ProjectToWGS84(tile maptile.Tile) {
p := newProjection(tile, l.Extent)
for _, f := range l.Features {
f.Geometry = project.Geometry(f.Geometry, p.ToWGS84)
}
}
|
[
"func",
"(",
"l",
"*",
"Layer",
")",
"ProjectToWGS84",
"(",
"tile",
"maptile",
".",
"Tile",
")",
"{",
"p",
":=",
"newProjection",
"(",
"tile",
",",
"l",
".",
"Extent",
")",
"\n",
"for",
"_",
",",
"f",
":=",
"range",
"l",
".",
"Features",
"{",
"f",
".",
"Geometry",
"=",
"project",
".",
"Geometry",
"(",
"f",
".",
"Geometry",
",",
"p",
".",
"ToWGS84",
")",
"\n",
"}",
"\n",
"}"
] |
// ProjectToWGS84 will project all the geometries backed to WGS84 from
// the extent and mercator projection.
|
[
"ProjectToWGS84",
"will",
"project",
"all",
"the",
"geometries",
"backed",
"to",
"WGS84",
"from",
"the",
"extent",
"and",
"mercator",
"projection",
"."
] |
c6e407b203494d3b1edb9fd5cae4cf34a4ae0f29
|
https://github.com/paulmach/orb/blob/c6e407b203494d3b1edb9fd5cae4cf34a4ae0f29/encoding/mvt/layer.go#L44-L49
|
151,113 |
paulmach/orb
|
encoding/mvt/layer.go
|
NewLayers
|
func NewLayers(layers map[string]*geojson.FeatureCollection) Layers {
result := make(Layers, 0, len(layers))
for name, fc := range layers {
result = append(result, NewLayer(name, fc))
}
return result
}
|
go
|
func NewLayers(layers map[string]*geojson.FeatureCollection) Layers {
result := make(Layers, 0, len(layers))
for name, fc := range layers {
result = append(result, NewLayer(name, fc))
}
return result
}
|
[
"func",
"NewLayers",
"(",
"layers",
"map",
"[",
"string",
"]",
"*",
"geojson",
".",
"FeatureCollection",
")",
"Layers",
"{",
"result",
":=",
"make",
"(",
"Layers",
",",
"0",
",",
"len",
"(",
"layers",
")",
")",
"\n",
"for",
"name",
",",
"fc",
":=",
"range",
"layers",
"{",
"result",
"=",
"append",
"(",
"result",
",",
"NewLayer",
"(",
"name",
",",
"fc",
")",
")",
"\n",
"}",
"\n\n",
"return",
"result",
"\n",
"}"
] |
// NewLayers creates a set of layers given a set of feature collections.
|
[
"NewLayers",
"creates",
"a",
"set",
"of",
"layers",
"given",
"a",
"set",
"of",
"feature",
"collections",
"."
] |
c6e407b203494d3b1edb9fd5cae4cf34a4ae0f29
|
https://github.com/paulmach/orb/blob/c6e407b203494d3b1edb9fd5cae4cf34a4ae0f29/encoding/mvt/layer.go#L55-L62
|
151,114 |
paulmach/orb
|
encoding/mvt/layer.go
|
ToFeatureCollections
|
func (ls Layers) ToFeatureCollections() map[string]*geojson.FeatureCollection {
result := make(map[string]*geojson.FeatureCollection, len(ls))
for _, l := range ls {
result[l.Name] = &geojson.FeatureCollection{
Features: l.Features,
}
}
return result
}
|
go
|
func (ls Layers) ToFeatureCollections() map[string]*geojson.FeatureCollection {
result := make(map[string]*geojson.FeatureCollection, len(ls))
for _, l := range ls {
result[l.Name] = &geojson.FeatureCollection{
Features: l.Features,
}
}
return result
}
|
[
"func",
"(",
"ls",
"Layers",
")",
"ToFeatureCollections",
"(",
")",
"map",
"[",
"string",
"]",
"*",
"geojson",
".",
"FeatureCollection",
"{",
"result",
":=",
"make",
"(",
"map",
"[",
"string",
"]",
"*",
"geojson",
".",
"FeatureCollection",
",",
"len",
"(",
"ls",
")",
")",
"\n",
"for",
"_",
",",
"l",
":=",
"range",
"ls",
"{",
"result",
"[",
"l",
".",
"Name",
"]",
"=",
"&",
"geojson",
".",
"FeatureCollection",
"{",
"Features",
":",
"l",
".",
"Features",
",",
"}",
"\n",
"}",
"\n\n",
"return",
"result",
"\n",
"}"
] |
// ToFeatureCollections converts the layers to sets of geojson
// feature collections.
|
[
"ToFeatureCollections",
"converts",
"the",
"layers",
"to",
"sets",
"of",
"geojson",
"feature",
"collections",
"."
] |
c6e407b203494d3b1edb9fd5cae4cf34a4ae0f29
|
https://github.com/paulmach/orb/blob/c6e407b203494d3b1edb9fd5cae4cf34a4ae0f29/encoding/mvt/layer.go#L66-L75
|
151,115 |
paulmach/orb
|
encoding/mvt/layer.go
|
ProjectToTile
|
func (ls Layers) ProjectToTile(tile maptile.Tile) {
for _, l := range ls {
l.ProjectToTile(tile)
}
}
|
go
|
func (ls Layers) ProjectToTile(tile maptile.Tile) {
for _, l := range ls {
l.ProjectToTile(tile)
}
}
|
[
"func",
"(",
"ls",
"Layers",
")",
"ProjectToTile",
"(",
"tile",
"maptile",
".",
"Tile",
")",
"{",
"for",
"_",
",",
"l",
":=",
"range",
"ls",
"{",
"l",
".",
"ProjectToTile",
"(",
"tile",
")",
"\n",
"}",
"\n",
"}"
] |
// ProjectToTile will project all the geometries in all layers
// to tile coordinates based on the extent and the mercator projection.
|
[
"ProjectToTile",
"will",
"project",
"all",
"the",
"geometries",
"in",
"all",
"layers",
"to",
"tile",
"coordinates",
"based",
"on",
"the",
"extent",
"and",
"the",
"mercator",
"projection",
"."
] |
c6e407b203494d3b1edb9fd5cae4cf34a4ae0f29
|
https://github.com/paulmach/orb/blob/c6e407b203494d3b1edb9fd5cae4cf34a4ae0f29/encoding/mvt/layer.go#L79-L83
|
151,116 |
paulmach/orb
|
encoding/mvt/layer.go
|
ProjectToWGS84
|
func (ls Layers) ProjectToWGS84(tile maptile.Tile) {
for _, l := range ls {
l.ProjectToWGS84(tile)
}
}
|
go
|
func (ls Layers) ProjectToWGS84(tile maptile.Tile) {
for _, l := range ls {
l.ProjectToWGS84(tile)
}
}
|
[
"func",
"(",
"ls",
"Layers",
")",
"ProjectToWGS84",
"(",
"tile",
"maptile",
".",
"Tile",
")",
"{",
"for",
"_",
",",
"l",
":=",
"range",
"ls",
"{",
"l",
".",
"ProjectToWGS84",
"(",
"tile",
")",
"\n",
"}",
"\n",
"}"
] |
// ProjectToWGS84 will project all the geometries in all the layers backed
// to WGS84 from the extent and mercator projection.
|
[
"ProjectToWGS84",
"will",
"project",
"all",
"the",
"geometries",
"in",
"all",
"the",
"layers",
"backed",
"to",
"WGS84",
"from",
"the",
"extent",
"and",
"mercator",
"projection",
"."
] |
c6e407b203494d3b1edb9fd5cae4cf34a4ae0f29
|
https://github.com/paulmach/orb/blob/c6e407b203494d3b1edb9fd5cae4cf34a4ae0f29/encoding/mvt/layer.go#L87-L91
|
151,117 |
libgit2/git2go
|
config.go
|
NewConfig
|
func NewConfig() (*Config, error) {
config := new(Config)
runtime.LockOSThread()
defer runtime.UnlockOSThread()
if ret := C.git_config_new(&config.ptr); ret < 0 {
return nil, MakeGitError(ret)
}
return config, nil
}
|
go
|
func NewConfig() (*Config, error) {
config := new(Config)
runtime.LockOSThread()
defer runtime.UnlockOSThread()
if ret := C.git_config_new(&config.ptr); ret < 0 {
return nil, MakeGitError(ret)
}
return config, nil
}
|
[
"func",
"NewConfig",
"(",
")",
"(",
"*",
"Config",
",",
"error",
")",
"{",
"config",
":=",
"new",
"(",
"Config",
")",
"\n\n",
"runtime",
".",
"LockOSThread",
"(",
")",
"\n",
"defer",
"runtime",
".",
"UnlockOSThread",
"(",
")",
"\n\n",
"if",
"ret",
":=",
"C",
".",
"git_config_new",
"(",
"&",
"config",
".",
"ptr",
")",
";",
"ret",
"<",
"0",
"{",
"return",
"nil",
",",
"MakeGitError",
"(",
"ret",
")",
"\n",
"}",
"\n\n",
"return",
"config",
",",
"nil",
"\n",
"}"
] |
// NewConfig creates a new empty configuration object
|
[
"NewConfig",
"creates",
"a",
"new",
"empty",
"configuration",
"object"
] |
bf1e8a4338822ad2539a3876f58b15b590eb9e1f
|
https://github.com/libgit2/git2go/blob/bf1e8a4338822ad2539a3876f58b15b590eb9e1f/config.go#L59-L70
|
151,118 |
libgit2/git2go
|
config.go
|
AddFile
|
func (c *Config) AddFile(path string, level ConfigLevel, force bool) error {
cpath := C.CString(path)
defer C.free(unsafe.Pointer(cpath))
runtime.LockOSThread()
defer runtime.UnlockOSThread()
ret := C.git_config_add_file_ondisk(c.ptr, cpath, C.git_config_level_t(level), nil, cbool(force))
runtime.KeepAlive(c)
if ret < 0 {
return MakeGitError(ret)
}
return nil
}
|
go
|
func (c *Config) AddFile(path string, level ConfigLevel, force bool) error {
cpath := C.CString(path)
defer C.free(unsafe.Pointer(cpath))
runtime.LockOSThread()
defer runtime.UnlockOSThread()
ret := C.git_config_add_file_ondisk(c.ptr, cpath, C.git_config_level_t(level), nil, cbool(force))
runtime.KeepAlive(c)
if ret < 0 {
return MakeGitError(ret)
}
return nil
}
|
[
"func",
"(",
"c",
"*",
"Config",
")",
"AddFile",
"(",
"path",
"string",
",",
"level",
"ConfigLevel",
",",
"force",
"bool",
")",
"error",
"{",
"cpath",
":=",
"C",
".",
"CString",
"(",
"path",
")",
"\n",
"defer",
"C",
".",
"free",
"(",
"unsafe",
".",
"Pointer",
"(",
"cpath",
")",
")",
"\n\n",
"runtime",
".",
"LockOSThread",
"(",
")",
"\n",
"defer",
"runtime",
".",
"UnlockOSThread",
"(",
")",
"\n\n",
"ret",
":=",
"C",
".",
"git_config_add_file_ondisk",
"(",
"c",
".",
"ptr",
",",
"cpath",
",",
"C",
".",
"git_config_level_t",
"(",
"level",
")",
",",
"nil",
",",
"cbool",
"(",
"force",
")",
")",
"\n",
"runtime",
".",
"KeepAlive",
"(",
"c",
")",
"\n",
"if",
"ret",
"<",
"0",
"{",
"return",
"MakeGitError",
"(",
"ret",
")",
"\n",
"}",
"\n\n",
"return",
"nil",
"\n",
"}"
] |
// AddFile adds a file-backed backend to the config object at the specified level.
|
[
"AddFile",
"adds",
"a",
"file",
"-",
"backed",
"backend",
"to",
"the",
"config",
"object",
"at",
"the",
"specified",
"level",
"."
] |
bf1e8a4338822ad2539a3876f58b15b590eb9e1f
|
https://github.com/libgit2/git2go/blob/bf1e8a4338822ad2539a3876f58b15b590eb9e1f/config.go#L73-L87
|
151,119 |
libgit2/git2go
|
config.go
|
NewIterator
|
func (c *Config) NewIterator() (*ConfigIterator, error) {
iter := &ConfigIterator{cfg: c}
runtime.LockOSThread()
defer runtime.UnlockOSThread()
ret := C.git_config_iterator_new(&iter.ptr, c.ptr)
if ret < 0 {
return nil, MakeGitError(ret)
}
return iter, nil
}
|
go
|
func (c *Config) NewIterator() (*ConfigIterator, error) {
iter := &ConfigIterator{cfg: c}
runtime.LockOSThread()
defer runtime.UnlockOSThread()
ret := C.git_config_iterator_new(&iter.ptr, c.ptr)
if ret < 0 {
return nil, MakeGitError(ret)
}
return iter, nil
}
|
[
"func",
"(",
"c",
"*",
"Config",
")",
"NewIterator",
"(",
")",
"(",
"*",
"ConfigIterator",
",",
"error",
")",
"{",
"iter",
":=",
"&",
"ConfigIterator",
"{",
"cfg",
":",
"c",
"}",
"\n\n",
"runtime",
".",
"LockOSThread",
"(",
")",
"\n",
"defer",
"runtime",
".",
"UnlockOSThread",
"(",
")",
"\n\n",
"ret",
":=",
"C",
".",
"git_config_iterator_new",
"(",
"&",
"iter",
".",
"ptr",
",",
"c",
".",
"ptr",
")",
"\n",
"if",
"ret",
"<",
"0",
"{",
"return",
"nil",
",",
"MakeGitError",
"(",
"ret",
")",
"\n",
"}",
"\n\n",
"return",
"iter",
",",
"nil",
"\n",
"}"
] |
// NewIterator creates an iterator over each entry in the
// configuration
|
[
"NewIterator",
"creates",
"an",
"iterator",
"over",
"each",
"entry",
"in",
"the",
"configuration"
] |
bf1e8a4338822ad2539a3876f58b15b590eb9e1f
|
https://github.com/libgit2/git2go/blob/bf1e8a4338822ad2539a3876f58b15b590eb9e1f/config.go#L187-L199
|
151,120 |
libgit2/git2go
|
config.go
|
NewIteratorGlob
|
func (c *Config) NewIteratorGlob(regexp string) (*ConfigIterator, error) {
iter := &ConfigIterator{cfg: c}
cregexp := C.CString(regexp)
defer C.free(unsafe.Pointer(cregexp))
runtime.LockOSThread()
defer runtime.UnlockOSThread()
ret := C.git_config_iterator_glob_new(&iter.ptr, c.ptr, cregexp)
if ret < 0 {
return nil, MakeGitError(ret)
}
return iter, nil
}
|
go
|
func (c *Config) NewIteratorGlob(regexp string) (*ConfigIterator, error) {
iter := &ConfigIterator{cfg: c}
cregexp := C.CString(regexp)
defer C.free(unsafe.Pointer(cregexp))
runtime.LockOSThread()
defer runtime.UnlockOSThread()
ret := C.git_config_iterator_glob_new(&iter.ptr, c.ptr, cregexp)
if ret < 0 {
return nil, MakeGitError(ret)
}
return iter, nil
}
|
[
"func",
"(",
"c",
"*",
"Config",
")",
"NewIteratorGlob",
"(",
"regexp",
"string",
")",
"(",
"*",
"ConfigIterator",
",",
"error",
")",
"{",
"iter",
":=",
"&",
"ConfigIterator",
"{",
"cfg",
":",
"c",
"}",
"\n",
"cregexp",
":=",
"C",
".",
"CString",
"(",
"regexp",
")",
"\n",
"defer",
"C",
".",
"free",
"(",
"unsafe",
".",
"Pointer",
"(",
"cregexp",
")",
")",
"\n\n",
"runtime",
".",
"LockOSThread",
"(",
")",
"\n",
"defer",
"runtime",
".",
"UnlockOSThread",
"(",
")",
"\n\n",
"ret",
":=",
"C",
".",
"git_config_iterator_glob_new",
"(",
"&",
"iter",
".",
"ptr",
",",
"c",
".",
"ptr",
",",
"cregexp",
")",
"\n",
"if",
"ret",
"<",
"0",
"{",
"return",
"nil",
",",
"MakeGitError",
"(",
"ret",
")",
"\n",
"}",
"\n\n",
"return",
"iter",
",",
"nil",
"\n",
"}"
] |
// NewIteratorGlob creates an iterator over each entry in the
// configuration whose name matches the given regular expression
|
[
"NewIteratorGlob",
"creates",
"an",
"iterator",
"over",
"each",
"entry",
"in",
"the",
"configuration",
"whose",
"name",
"matches",
"the",
"given",
"regular",
"expression"
] |
bf1e8a4338822ad2539a3876f58b15b590eb9e1f
|
https://github.com/libgit2/git2go/blob/bf1e8a4338822ad2539a3876f58b15b590eb9e1f/config.go#L203-L217
|
151,121 |
libgit2/git2go
|
config.go
|
OpenLevel
|
func (c *Config) OpenLevel(parent *Config, level ConfigLevel) (*Config, error) {
config := new(Config)
runtime.LockOSThread()
defer runtime.UnlockOSThread()
ret := C.git_config_open_level(&config.ptr, parent.ptr, C.git_config_level_t(level))
runtime.KeepAlive(c)
runtime.KeepAlive(parent)
if ret < 0 {
return nil, MakeGitError(ret)
}
return config, nil
}
|
go
|
func (c *Config) OpenLevel(parent *Config, level ConfigLevel) (*Config, error) {
config := new(Config)
runtime.LockOSThread()
defer runtime.UnlockOSThread()
ret := C.git_config_open_level(&config.ptr, parent.ptr, C.git_config_level_t(level))
runtime.KeepAlive(c)
runtime.KeepAlive(parent)
if ret < 0 {
return nil, MakeGitError(ret)
}
return config, nil
}
|
[
"func",
"(",
"c",
"*",
"Config",
")",
"OpenLevel",
"(",
"parent",
"*",
"Config",
",",
"level",
"ConfigLevel",
")",
"(",
"*",
"Config",
",",
"error",
")",
"{",
"config",
":=",
"new",
"(",
"Config",
")",
"\n\n",
"runtime",
".",
"LockOSThread",
"(",
")",
"\n",
"defer",
"runtime",
".",
"UnlockOSThread",
"(",
")",
"\n\n",
"ret",
":=",
"C",
".",
"git_config_open_level",
"(",
"&",
"config",
".",
"ptr",
",",
"parent",
".",
"ptr",
",",
"C",
".",
"git_config_level_t",
"(",
"level",
")",
")",
"\n",
"runtime",
".",
"KeepAlive",
"(",
"c",
")",
"\n",
"runtime",
".",
"KeepAlive",
"(",
"parent",
")",
"\n",
"if",
"ret",
"<",
"0",
"{",
"return",
"nil",
",",
"MakeGitError",
"(",
"ret",
")",
"\n",
"}",
"\n\n",
"return",
"config",
",",
"nil",
"\n",
"}"
] |
// OpenLevel creates a single-level focused config object from a multi-level one
|
[
"OpenLevel",
"creates",
"a",
"single",
"-",
"level",
"focused",
"config",
"object",
"from",
"a",
"multi",
"-",
"level",
"one"
] |
bf1e8a4338822ad2539a3876f58b15b590eb9e1f
|
https://github.com/libgit2/git2go/blob/bf1e8a4338822ad2539a3876f58b15b590eb9e1f/config.go#L330-L344
|
151,122 |
libgit2/git2go
|
config.go
|
OpenOndisk
|
func OpenOndisk(path string) (*Config, error) {
cpath := C.CString(path)
defer C.free(unsafe.Pointer(cpath))
config := new(Config)
runtime.LockOSThread()
defer runtime.UnlockOSThread()
if ret := C.git_config_open_ondisk(&config.ptr, cpath); ret < 0 {
return nil, MakeGitError(ret)
}
return config, nil
}
|
go
|
func OpenOndisk(path string) (*Config, error) {
cpath := C.CString(path)
defer C.free(unsafe.Pointer(cpath))
config := new(Config)
runtime.LockOSThread()
defer runtime.UnlockOSThread()
if ret := C.git_config_open_ondisk(&config.ptr, cpath); ret < 0 {
return nil, MakeGitError(ret)
}
return config, nil
}
|
[
"func",
"OpenOndisk",
"(",
"path",
"string",
")",
"(",
"*",
"Config",
",",
"error",
")",
"{",
"cpath",
":=",
"C",
".",
"CString",
"(",
"path",
")",
"\n",
"defer",
"C",
".",
"free",
"(",
"unsafe",
".",
"Pointer",
"(",
"cpath",
")",
")",
"\n\n",
"config",
":=",
"new",
"(",
"Config",
")",
"\n\n",
"runtime",
".",
"LockOSThread",
"(",
")",
"\n",
"defer",
"runtime",
".",
"UnlockOSThread",
"(",
")",
"\n\n",
"if",
"ret",
":=",
"C",
".",
"git_config_open_ondisk",
"(",
"&",
"config",
".",
"ptr",
",",
"cpath",
")",
";",
"ret",
"<",
"0",
"{",
"return",
"nil",
",",
"MakeGitError",
"(",
"ret",
")",
"\n",
"}",
"\n\n",
"return",
"config",
",",
"nil",
"\n",
"}"
] |
// OpenOndisk creates a new config instance containing a single on-disk file
|
[
"OpenOndisk",
"creates",
"a",
"new",
"config",
"instance",
"containing",
"a",
"single",
"on",
"-",
"disk",
"file"
] |
bf1e8a4338822ad2539a3876f58b15b590eb9e1f
|
https://github.com/libgit2/git2go/blob/bf1e8a4338822ad2539a3876f58b15b590eb9e1f/config.go#L347-L361
|
151,123 |
libgit2/git2go
|
config.go
|
Next
|
func (iter *ConfigIterator) Next() (*ConfigEntry, error) {
var centry *C.git_config_entry
runtime.LockOSThread()
defer runtime.UnlockOSThread()
ret := C.git_config_next(¢ry, iter.ptr)
if ret < 0 {
return nil, MakeGitError(ret)
}
entry := newConfigEntryFromC(centry)
runtime.KeepAlive(iter)
return entry, nil
}
|
go
|
func (iter *ConfigIterator) Next() (*ConfigEntry, error) {
var centry *C.git_config_entry
runtime.LockOSThread()
defer runtime.UnlockOSThread()
ret := C.git_config_next(¢ry, iter.ptr)
if ret < 0 {
return nil, MakeGitError(ret)
}
entry := newConfigEntryFromC(centry)
runtime.KeepAlive(iter)
return entry, nil
}
|
[
"func",
"(",
"iter",
"*",
"ConfigIterator",
")",
"Next",
"(",
")",
"(",
"*",
"ConfigEntry",
",",
"error",
")",
"{",
"var",
"centry",
"*",
"C",
".",
"git_config_entry",
"\n\n",
"runtime",
".",
"LockOSThread",
"(",
")",
"\n",
"defer",
"runtime",
".",
"UnlockOSThread",
"(",
")",
"\n\n",
"ret",
":=",
"C",
".",
"git_config_next",
"(",
"&",
"centry",
",",
"iter",
".",
"ptr",
")",
"\n",
"if",
"ret",
"<",
"0",
"{",
"return",
"nil",
",",
"MakeGitError",
"(",
"ret",
")",
"\n",
"}",
"\n\n",
"entry",
":=",
"newConfigEntryFromC",
"(",
"centry",
")",
"\n",
"runtime",
".",
"KeepAlive",
"(",
"iter",
")",
"\n\n",
"return",
"entry",
",",
"nil",
"\n",
"}"
] |
// Next returns the next entry for this iterator
|
[
"Next",
"returns",
"the",
"next",
"entry",
"for",
"this",
"iterator"
] |
bf1e8a4338822ad2539a3876f58b15b590eb9e1f
|
https://github.com/libgit2/git2go/blob/bf1e8a4338822ad2539a3876f58b15b590eb9e1f/config.go#L369-L384
|
151,124 |
libgit2/git2go
|
config.go
|
ConfigFindProgramdata
|
func ConfigFindProgramdata() (string, error) {
var buf C.git_buf
defer C.git_buf_dispose(&buf)
runtime.LockOSThread()
defer runtime.UnlockOSThread()
ret := C.git_config_find_programdata(&buf)
if ret < 0 {
return "", MakeGitError(ret)
}
return C.GoString(buf.ptr), nil
}
|
go
|
func ConfigFindProgramdata() (string, error) {
var buf C.git_buf
defer C.git_buf_dispose(&buf)
runtime.LockOSThread()
defer runtime.UnlockOSThread()
ret := C.git_config_find_programdata(&buf)
if ret < 0 {
return "", MakeGitError(ret)
}
return C.GoString(buf.ptr), nil
}
|
[
"func",
"ConfigFindProgramdata",
"(",
")",
"(",
"string",
",",
"error",
")",
"{",
"var",
"buf",
"C",
".",
"git_buf",
"\n",
"defer",
"C",
".",
"git_buf_dispose",
"(",
"&",
"buf",
")",
"\n\n",
"runtime",
".",
"LockOSThread",
"(",
")",
"\n",
"defer",
"runtime",
".",
"UnlockOSThread",
"(",
")",
"\n\n",
"ret",
":=",
"C",
".",
"git_config_find_programdata",
"(",
"&",
"buf",
")",
"\n",
"if",
"ret",
"<",
"0",
"{",
"return",
"\"",
"\"",
",",
"MakeGitError",
"(",
"ret",
")",
"\n",
"}",
"\n\n",
"return",
"C",
".",
"GoString",
"(",
"buf",
".",
"ptr",
")",
",",
"nil",
"\n",
"}"
] |
// ConfigFindProgramdata locate the path to the configuration file in ProgramData.
//
// Look for the file in %PROGRAMDATA%\Git\config used by portable git.
|
[
"ConfigFindProgramdata",
"locate",
"the",
"path",
"to",
"the",
"configuration",
"file",
"in",
"ProgramData",
".",
"Look",
"for",
"the",
"file",
"in",
"%PROGRAMDATA%",
"\\",
"Git",
"\\",
"config",
"used",
"by",
"portable",
"git",
"."
] |
bf1e8a4338822ad2539a3876f58b15b590eb9e1f
|
https://github.com/libgit2/git2go/blob/bf1e8a4338822ad2539a3876f58b15b590eb9e1f/config.go#L439-L452
|
151,125 |
libgit2/git2go
|
merge.go
|
MergeAnalysis
|
func (r *Repository) MergeAnalysis(theirHeads []*AnnotatedCommit) (MergeAnalysis, MergePreference, error) {
runtime.LockOSThread()
defer runtime.UnlockOSThread()
gmerge_head_array := make([]*C.git_annotated_commit, len(theirHeads))
for i := 0; i < len(theirHeads); i++ {
gmerge_head_array[i] = theirHeads[i].ptr
}
ptr := unsafe.Pointer(&gmerge_head_array[0])
var analysis C.git_merge_analysis_t
var preference C.git_merge_preference_t
err := C.git_merge_analysis(&analysis, &preference, r.ptr, (**C.git_annotated_commit)(ptr), C.size_t(len(theirHeads)))
runtime.KeepAlive(theirHeads)
if err < 0 {
return MergeAnalysisNone, MergePreferenceNone, MakeGitError(err)
}
return MergeAnalysis(analysis), MergePreference(preference), nil
}
|
go
|
func (r *Repository) MergeAnalysis(theirHeads []*AnnotatedCommit) (MergeAnalysis, MergePreference, error) {
runtime.LockOSThread()
defer runtime.UnlockOSThread()
gmerge_head_array := make([]*C.git_annotated_commit, len(theirHeads))
for i := 0; i < len(theirHeads); i++ {
gmerge_head_array[i] = theirHeads[i].ptr
}
ptr := unsafe.Pointer(&gmerge_head_array[0])
var analysis C.git_merge_analysis_t
var preference C.git_merge_preference_t
err := C.git_merge_analysis(&analysis, &preference, r.ptr, (**C.git_annotated_commit)(ptr), C.size_t(len(theirHeads)))
runtime.KeepAlive(theirHeads)
if err < 0 {
return MergeAnalysisNone, MergePreferenceNone, MakeGitError(err)
}
return MergeAnalysis(analysis), MergePreference(preference), nil
}
|
[
"func",
"(",
"r",
"*",
"Repository",
")",
"MergeAnalysis",
"(",
"theirHeads",
"[",
"]",
"*",
"AnnotatedCommit",
")",
"(",
"MergeAnalysis",
",",
"MergePreference",
",",
"error",
")",
"{",
"runtime",
".",
"LockOSThread",
"(",
")",
"\n",
"defer",
"runtime",
".",
"UnlockOSThread",
"(",
")",
"\n\n",
"gmerge_head_array",
":=",
"make",
"(",
"[",
"]",
"*",
"C",
".",
"git_annotated_commit",
",",
"len",
"(",
"theirHeads",
")",
")",
"\n",
"for",
"i",
":=",
"0",
";",
"i",
"<",
"len",
"(",
"theirHeads",
")",
";",
"i",
"++",
"{",
"gmerge_head_array",
"[",
"i",
"]",
"=",
"theirHeads",
"[",
"i",
"]",
".",
"ptr",
"\n",
"}",
"\n",
"ptr",
":=",
"unsafe",
".",
"Pointer",
"(",
"&",
"gmerge_head_array",
"[",
"0",
"]",
")",
"\n",
"var",
"analysis",
"C",
".",
"git_merge_analysis_t",
"\n",
"var",
"preference",
"C",
".",
"git_merge_preference_t",
"\n",
"err",
":=",
"C",
".",
"git_merge_analysis",
"(",
"&",
"analysis",
",",
"&",
"preference",
",",
"r",
".",
"ptr",
",",
"(",
"*",
"*",
"C",
".",
"git_annotated_commit",
")",
"(",
"ptr",
")",
",",
"C",
".",
"size_t",
"(",
"len",
"(",
"theirHeads",
")",
")",
")",
"\n",
"runtime",
".",
"KeepAlive",
"(",
"theirHeads",
")",
"\n",
"if",
"err",
"<",
"0",
"{",
"return",
"MergeAnalysisNone",
",",
"MergePreferenceNone",
",",
"MakeGitError",
"(",
"err",
")",
"\n",
"}",
"\n",
"return",
"MergeAnalysis",
"(",
"analysis",
")",
",",
"MergePreference",
"(",
"preference",
")",
",",
"nil",
"\n\n",
"}"
] |
// MergeAnalysis returns the possible actions which could be taken by
// a 'git-merge' command. There may be multiple answers, so the first
// return value is a bitmask of MergeAnalysis values.
|
[
"MergeAnalysis",
"returns",
"the",
"possible",
"actions",
"which",
"could",
"be",
"taken",
"by",
"a",
"git",
"-",
"merge",
"command",
".",
"There",
"may",
"be",
"multiple",
"answers",
"so",
"the",
"first",
"return",
"value",
"is",
"a",
"bitmask",
"of",
"MergeAnalysis",
"values",
"."
] |
bf1e8a4338822ad2539a3876f58b15b590eb9e1f
|
https://github.com/libgit2/git2go/blob/bf1e8a4338822ad2539a3876f58b15b590eb9e1f/merge.go#L193-L211
|
151,126 |
libgit2/git2go
|
merge.go
|
MergeBases
|
func (r *Repository) MergeBases(one, two *Oid) ([]*Oid, error) {
runtime.LockOSThread()
defer runtime.UnlockOSThread()
var coids C.git_oidarray
ret := C.git_merge_bases(&coids, r.ptr, one.toC(), two.toC())
runtime.KeepAlive(one)
runtime.KeepAlive(two)
if ret < 0 {
return make([]*Oid, 0), MakeGitError(ret)
}
oids := make([]*Oid, coids.count)
hdr := reflect.SliceHeader{
Data: uintptr(unsafe.Pointer(coids.ids)),
Len: int(coids.count),
Cap: int(coids.count),
}
goSlice := *(*[]C.git_oid)(unsafe.Pointer(&hdr))
for i, cid := range goSlice {
oids[i] = newOidFromC(&cid)
}
return oids, nil
}
|
go
|
func (r *Repository) MergeBases(one, two *Oid) ([]*Oid, error) {
runtime.LockOSThread()
defer runtime.UnlockOSThread()
var coids C.git_oidarray
ret := C.git_merge_bases(&coids, r.ptr, one.toC(), two.toC())
runtime.KeepAlive(one)
runtime.KeepAlive(two)
if ret < 0 {
return make([]*Oid, 0), MakeGitError(ret)
}
oids := make([]*Oid, coids.count)
hdr := reflect.SliceHeader{
Data: uintptr(unsafe.Pointer(coids.ids)),
Len: int(coids.count),
Cap: int(coids.count),
}
goSlice := *(*[]C.git_oid)(unsafe.Pointer(&hdr))
for i, cid := range goSlice {
oids[i] = newOidFromC(&cid)
}
return oids, nil
}
|
[
"func",
"(",
"r",
"*",
"Repository",
")",
"MergeBases",
"(",
"one",
",",
"two",
"*",
"Oid",
")",
"(",
"[",
"]",
"*",
"Oid",
",",
"error",
")",
"{",
"runtime",
".",
"LockOSThread",
"(",
")",
"\n",
"defer",
"runtime",
".",
"UnlockOSThread",
"(",
")",
"\n\n",
"var",
"coids",
"C",
".",
"git_oidarray",
"\n",
"ret",
":=",
"C",
".",
"git_merge_bases",
"(",
"&",
"coids",
",",
"r",
".",
"ptr",
",",
"one",
".",
"toC",
"(",
")",
",",
"two",
".",
"toC",
"(",
")",
")",
"\n",
"runtime",
".",
"KeepAlive",
"(",
"one",
")",
"\n",
"runtime",
".",
"KeepAlive",
"(",
"two",
")",
"\n",
"if",
"ret",
"<",
"0",
"{",
"return",
"make",
"(",
"[",
"]",
"*",
"Oid",
",",
"0",
")",
",",
"MakeGitError",
"(",
"ret",
")",
"\n",
"}",
"\n\n",
"oids",
":=",
"make",
"(",
"[",
"]",
"*",
"Oid",
",",
"coids",
".",
"count",
")",
"\n",
"hdr",
":=",
"reflect",
".",
"SliceHeader",
"{",
"Data",
":",
"uintptr",
"(",
"unsafe",
".",
"Pointer",
"(",
"coids",
".",
"ids",
")",
")",
",",
"Len",
":",
"int",
"(",
"coids",
".",
"count",
")",
",",
"Cap",
":",
"int",
"(",
"coids",
".",
"count",
")",
",",
"}",
"\n\n",
"goSlice",
":=",
"*",
"(",
"*",
"[",
"]",
"C",
".",
"git_oid",
")",
"(",
"unsafe",
".",
"Pointer",
"(",
"&",
"hdr",
")",
")",
"\n\n",
"for",
"i",
",",
"cid",
":=",
"range",
"goSlice",
"{",
"oids",
"[",
"i",
"]",
"=",
"newOidFromC",
"(",
"&",
"cid",
")",
"\n",
"}",
"\n\n",
"return",
"oids",
",",
"nil",
"\n",
"}"
] |
// MergeBases retrieves the list of merge bases between two commits.
//
// If none are found, an empty slice is returned and the error is set
// approprately
|
[
"MergeBases",
"retrieves",
"the",
"list",
"of",
"merge",
"bases",
"between",
"two",
"commits",
".",
"If",
"none",
"are",
"found",
"an",
"empty",
"slice",
"is",
"returned",
"and",
"the",
"error",
"is",
"set",
"approprately"
] |
bf1e8a4338822ad2539a3876f58b15b590eb9e1f
|
https://github.com/libgit2/git2go/blob/bf1e8a4338822ad2539a3876f58b15b590eb9e1f/merge.go#L271-L297
|
151,127 |
libgit2/git2go
|
note.go
|
Create
|
func (c *NoteCollection) Create(
ref string, author, committer *Signature, id *Oid,
note string, force bool) (*Oid, error) {
oid := new(Oid)
var cref *C.char
if ref == "" {
cref = nil
} else {
cref = C.CString(ref)
defer C.free(unsafe.Pointer(cref))
}
authorSig, err := author.toC()
if err != nil {
return nil, err
}
defer C.git_signature_free(authorSig)
committerSig, err := committer.toC()
if err != nil {
return nil, err
}
defer C.git_signature_free(committerSig)
cnote := C.CString(note)
defer C.free(unsafe.Pointer(cnote))
runtime.LockOSThread()
defer runtime.UnlockOSThread()
ret := C.git_note_create(
oid.toC(), c.repo.ptr, cref, authorSig,
committerSig, id.toC(), cnote, cbool(force))
runtime.KeepAlive(c)
runtime.KeepAlive(id)
if ret < 0 {
return nil, MakeGitError(ret)
}
return oid, nil
}
|
go
|
func (c *NoteCollection) Create(
ref string, author, committer *Signature, id *Oid,
note string, force bool) (*Oid, error) {
oid := new(Oid)
var cref *C.char
if ref == "" {
cref = nil
} else {
cref = C.CString(ref)
defer C.free(unsafe.Pointer(cref))
}
authorSig, err := author.toC()
if err != nil {
return nil, err
}
defer C.git_signature_free(authorSig)
committerSig, err := committer.toC()
if err != nil {
return nil, err
}
defer C.git_signature_free(committerSig)
cnote := C.CString(note)
defer C.free(unsafe.Pointer(cnote))
runtime.LockOSThread()
defer runtime.UnlockOSThread()
ret := C.git_note_create(
oid.toC(), c.repo.ptr, cref, authorSig,
committerSig, id.toC(), cnote, cbool(force))
runtime.KeepAlive(c)
runtime.KeepAlive(id)
if ret < 0 {
return nil, MakeGitError(ret)
}
return oid, nil
}
|
[
"func",
"(",
"c",
"*",
"NoteCollection",
")",
"Create",
"(",
"ref",
"string",
",",
"author",
",",
"committer",
"*",
"Signature",
",",
"id",
"*",
"Oid",
",",
"note",
"string",
",",
"force",
"bool",
")",
"(",
"*",
"Oid",
",",
"error",
")",
"{",
"oid",
":=",
"new",
"(",
"Oid",
")",
"\n\n",
"var",
"cref",
"*",
"C",
".",
"char",
"\n",
"if",
"ref",
"==",
"\"",
"\"",
"{",
"cref",
"=",
"nil",
"\n",
"}",
"else",
"{",
"cref",
"=",
"C",
".",
"CString",
"(",
"ref",
")",
"\n",
"defer",
"C",
".",
"free",
"(",
"unsafe",
".",
"Pointer",
"(",
"cref",
")",
")",
"\n",
"}",
"\n\n",
"authorSig",
",",
"err",
":=",
"author",
".",
"toC",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"defer",
"C",
".",
"git_signature_free",
"(",
"authorSig",
")",
"\n\n",
"committerSig",
",",
"err",
":=",
"committer",
".",
"toC",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"defer",
"C",
".",
"git_signature_free",
"(",
"committerSig",
")",
"\n\n",
"cnote",
":=",
"C",
".",
"CString",
"(",
"note",
")",
"\n",
"defer",
"C",
".",
"free",
"(",
"unsafe",
".",
"Pointer",
"(",
"cnote",
")",
")",
"\n\n",
"runtime",
".",
"LockOSThread",
"(",
")",
"\n",
"defer",
"runtime",
".",
"UnlockOSThread",
"(",
")",
"\n\n",
"ret",
":=",
"C",
".",
"git_note_create",
"(",
"oid",
".",
"toC",
"(",
")",
",",
"c",
".",
"repo",
".",
"ptr",
",",
"cref",
",",
"authorSig",
",",
"committerSig",
",",
"id",
".",
"toC",
"(",
")",
",",
"cnote",
",",
"cbool",
"(",
"force",
")",
")",
"\n",
"runtime",
".",
"KeepAlive",
"(",
"c",
")",
"\n",
"runtime",
".",
"KeepAlive",
"(",
"id",
")",
"\n",
"if",
"ret",
"<",
"0",
"{",
"return",
"nil",
",",
"MakeGitError",
"(",
"ret",
")",
"\n",
"}",
"\n",
"return",
"oid",
",",
"nil",
"\n",
"}"
] |
// Create adds a note for an object
|
[
"Create",
"adds",
"a",
"note",
"for",
"an",
"object"
] |
bf1e8a4338822ad2539a3876f58b15b590eb9e1f
|
https://github.com/libgit2/git2go/blob/bf1e8a4338822ad2539a3876f58b15b590eb9e1f/note.go#L20-L61
|
151,128 |
libgit2/git2go
|
note.go
|
Read
|
func (c *NoteCollection) Read(ref string, id *Oid) (*Note, error) {
var cref *C.char
if ref == "" {
cref = nil
} else {
cref = C.CString(ref)
defer C.free(unsafe.Pointer(cref))
}
runtime.LockOSThread()
defer runtime.UnlockOSThread()
var ptr *C.git_note
ret := C.git_note_read(&ptr, c.repo.ptr, cref, id.toC())
runtime.KeepAlive(c)
runtime.KeepAlive(id)
if ret < 0 {
return nil, MakeGitError(ret)
}
return newNoteFromC(ptr, c.repo), nil
}
|
go
|
func (c *NoteCollection) Read(ref string, id *Oid) (*Note, error) {
var cref *C.char
if ref == "" {
cref = nil
} else {
cref = C.CString(ref)
defer C.free(unsafe.Pointer(cref))
}
runtime.LockOSThread()
defer runtime.UnlockOSThread()
var ptr *C.git_note
ret := C.git_note_read(&ptr, c.repo.ptr, cref, id.toC())
runtime.KeepAlive(c)
runtime.KeepAlive(id)
if ret < 0 {
return nil, MakeGitError(ret)
}
return newNoteFromC(ptr, c.repo), nil
}
|
[
"func",
"(",
"c",
"*",
"NoteCollection",
")",
"Read",
"(",
"ref",
"string",
",",
"id",
"*",
"Oid",
")",
"(",
"*",
"Note",
",",
"error",
")",
"{",
"var",
"cref",
"*",
"C",
".",
"char",
"\n",
"if",
"ref",
"==",
"\"",
"\"",
"{",
"cref",
"=",
"nil",
"\n",
"}",
"else",
"{",
"cref",
"=",
"C",
".",
"CString",
"(",
"ref",
")",
"\n",
"defer",
"C",
".",
"free",
"(",
"unsafe",
".",
"Pointer",
"(",
"cref",
")",
")",
"\n",
"}",
"\n\n",
"runtime",
".",
"LockOSThread",
"(",
")",
"\n",
"defer",
"runtime",
".",
"UnlockOSThread",
"(",
")",
"\n\n",
"var",
"ptr",
"*",
"C",
".",
"git_note",
"\n",
"ret",
":=",
"C",
".",
"git_note_read",
"(",
"&",
"ptr",
",",
"c",
".",
"repo",
".",
"ptr",
",",
"cref",
",",
"id",
".",
"toC",
"(",
")",
")",
"\n",
"runtime",
".",
"KeepAlive",
"(",
"c",
")",
"\n",
"runtime",
".",
"KeepAlive",
"(",
"id",
")",
"\n",
"if",
"ret",
"<",
"0",
"{",
"return",
"nil",
",",
"MakeGitError",
"(",
"ret",
")",
"\n",
"}",
"\n\n",
"return",
"newNoteFromC",
"(",
"ptr",
",",
"c",
".",
"repo",
")",
",",
"nil",
"\n",
"}"
] |
// Read reads the note for an object
|
[
"Read",
"reads",
"the",
"note",
"for",
"an",
"object"
] |
bf1e8a4338822ad2539a3876f58b15b590eb9e1f
|
https://github.com/libgit2/git2go/blob/bf1e8a4338822ad2539a3876f58b15b590eb9e1f/note.go#L64-L85
|
151,129 |
libgit2/git2go
|
note.go
|
Remove
|
func (c *NoteCollection) Remove(ref string, author, committer *Signature, id *Oid) error {
var cref *C.char
if ref == "" {
cref = nil
} else {
cref = C.CString(ref)
defer C.free(unsafe.Pointer(cref))
}
authorSig, err := author.toC()
if err != nil {
return err
}
defer C.git_signature_free(authorSig)
committerSig, err := committer.toC()
if err != nil {
return err
}
defer C.git_signature_free(committerSig)
runtime.LockOSThread()
defer runtime.UnlockOSThread()
ret := C.git_note_remove(c.repo.ptr, cref, authorSig, committerSig, id.toC())
runtime.KeepAlive(c)
runtime.KeepAlive(id)
if ret < 0 {
return MakeGitError(ret)
}
return nil
}
|
go
|
func (c *NoteCollection) Remove(ref string, author, committer *Signature, id *Oid) error {
var cref *C.char
if ref == "" {
cref = nil
} else {
cref = C.CString(ref)
defer C.free(unsafe.Pointer(cref))
}
authorSig, err := author.toC()
if err != nil {
return err
}
defer C.git_signature_free(authorSig)
committerSig, err := committer.toC()
if err != nil {
return err
}
defer C.git_signature_free(committerSig)
runtime.LockOSThread()
defer runtime.UnlockOSThread()
ret := C.git_note_remove(c.repo.ptr, cref, authorSig, committerSig, id.toC())
runtime.KeepAlive(c)
runtime.KeepAlive(id)
if ret < 0 {
return MakeGitError(ret)
}
return nil
}
|
[
"func",
"(",
"c",
"*",
"NoteCollection",
")",
"Remove",
"(",
"ref",
"string",
",",
"author",
",",
"committer",
"*",
"Signature",
",",
"id",
"*",
"Oid",
")",
"error",
"{",
"var",
"cref",
"*",
"C",
".",
"char",
"\n",
"if",
"ref",
"==",
"\"",
"\"",
"{",
"cref",
"=",
"nil",
"\n",
"}",
"else",
"{",
"cref",
"=",
"C",
".",
"CString",
"(",
"ref",
")",
"\n",
"defer",
"C",
".",
"free",
"(",
"unsafe",
".",
"Pointer",
"(",
"cref",
")",
")",
"\n",
"}",
"\n\n",
"authorSig",
",",
"err",
":=",
"author",
".",
"toC",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"defer",
"C",
".",
"git_signature_free",
"(",
"authorSig",
")",
"\n\n",
"committerSig",
",",
"err",
":=",
"committer",
".",
"toC",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"defer",
"C",
".",
"git_signature_free",
"(",
"committerSig",
")",
"\n\n",
"runtime",
".",
"LockOSThread",
"(",
")",
"\n",
"defer",
"runtime",
".",
"UnlockOSThread",
"(",
")",
"\n\n",
"ret",
":=",
"C",
".",
"git_note_remove",
"(",
"c",
".",
"repo",
".",
"ptr",
",",
"cref",
",",
"authorSig",
",",
"committerSig",
",",
"id",
".",
"toC",
"(",
")",
")",
"\n",
"runtime",
".",
"KeepAlive",
"(",
"c",
")",
"\n",
"runtime",
".",
"KeepAlive",
"(",
"id",
")",
"\n",
"if",
"ret",
"<",
"0",
"{",
"return",
"MakeGitError",
"(",
"ret",
")",
"\n",
"}",
"\n",
"return",
"nil",
"\n",
"}"
] |
// Remove removes the note for an object
|
[
"Remove",
"removes",
"the",
"note",
"for",
"an",
"object"
] |
bf1e8a4338822ad2539a3876f58b15b590eb9e1f
|
https://github.com/libgit2/git2go/blob/bf1e8a4338822ad2539a3876f58b15b590eb9e1f/note.go#L88-L119
|
151,130 |
libgit2/git2go
|
note.go
|
DefaultRef
|
func (c *NoteCollection) DefaultRef() (string, error) {
buf := C.git_buf{}
runtime.LockOSThread()
defer runtime.UnlockOSThread()
ecode := C.git_note_default_ref(&buf, c.repo.ptr)
runtime.KeepAlive(c)
if ecode < 0 {
return "", MakeGitError(ecode)
}
ret := C.GoString(buf.ptr)
C.git_buf_dispose(&buf)
return ret, nil
}
|
go
|
func (c *NoteCollection) DefaultRef() (string, error) {
buf := C.git_buf{}
runtime.LockOSThread()
defer runtime.UnlockOSThread()
ecode := C.git_note_default_ref(&buf, c.repo.ptr)
runtime.KeepAlive(c)
if ecode < 0 {
return "", MakeGitError(ecode)
}
ret := C.GoString(buf.ptr)
C.git_buf_dispose(&buf)
return ret, nil
}
|
[
"func",
"(",
"c",
"*",
"NoteCollection",
")",
"DefaultRef",
"(",
")",
"(",
"string",
",",
"error",
")",
"{",
"buf",
":=",
"C",
".",
"git_buf",
"{",
"}",
"\n\n",
"runtime",
".",
"LockOSThread",
"(",
")",
"\n",
"defer",
"runtime",
".",
"UnlockOSThread",
"(",
")",
"\n\n",
"ecode",
":=",
"C",
".",
"git_note_default_ref",
"(",
"&",
"buf",
",",
"c",
".",
"repo",
".",
"ptr",
")",
"\n",
"runtime",
".",
"KeepAlive",
"(",
"c",
")",
"\n",
"if",
"ecode",
"<",
"0",
"{",
"return",
"\"",
"\"",
",",
"MakeGitError",
"(",
"ecode",
")",
"\n",
"}",
"\n\n",
"ret",
":=",
"C",
".",
"GoString",
"(",
"buf",
".",
"ptr",
")",
"\n",
"C",
".",
"git_buf_dispose",
"(",
"&",
"buf",
")",
"\n\n",
"return",
"ret",
",",
"nil",
"\n",
"}"
] |
// DefaultRef returns the default notes reference for a repository
|
[
"DefaultRef",
"returns",
"the",
"default",
"notes",
"reference",
"for",
"a",
"repository"
] |
bf1e8a4338822ad2539a3876f58b15b590eb9e1f
|
https://github.com/libgit2/git2go/blob/bf1e8a4338822ad2539a3876f58b15b590eb9e1f/note.go#L122-L138
|
151,131 |
libgit2/git2go
|
note.go
|
Free
|
func (n *Note) Free() error {
if n.ptr == nil {
return ErrInvalid
}
runtime.SetFinalizer(n, nil)
C.git_note_free(n.ptr)
n.ptr = nil
return nil
}
|
go
|
func (n *Note) Free() error {
if n.ptr == nil {
return ErrInvalid
}
runtime.SetFinalizer(n, nil)
C.git_note_free(n.ptr)
n.ptr = nil
return nil
}
|
[
"func",
"(",
"n",
"*",
"Note",
")",
"Free",
"(",
")",
"error",
"{",
"if",
"n",
".",
"ptr",
"==",
"nil",
"{",
"return",
"ErrInvalid",
"\n",
"}",
"\n",
"runtime",
".",
"SetFinalizer",
"(",
"n",
",",
"nil",
")",
"\n",
"C",
".",
"git_note_free",
"(",
"n",
".",
"ptr",
")",
"\n",
"n",
".",
"ptr",
"=",
"nil",
"\n",
"return",
"nil",
"\n",
"}"
] |
// Free frees a git_note object
|
[
"Free",
"frees",
"a",
"git_note",
"object"
] |
bf1e8a4338822ad2539a3876f58b15b590eb9e1f
|
https://github.com/libgit2/git2go/blob/bf1e8a4338822ad2539a3876f58b15b590eb9e1f/note.go#L153-L161
|
151,132 |
libgit2/git2go
|
note.go
|
Author
|
func (n *Note) Author() *Signature {
ptr := C.git_note_author(n.ptr)
return newSignatureFromC(ptr)
}
|
go
|
func (n *Note) Author() *Signature {
ptr := C.git_note_author(n.ptr)
return newSignatureFromC(ptr)
}
|
[
"func",
"(",
"n",
"*",
"Note",
")",
"Author",
"(",
")",
"*",
"Signature",
"{",
"ptr",
":=",
"C",
".",
"git_note_author",
"(",
"n",
".",
"ptr",
")",
"\n",
"return",
"newSignatureFromC",
"(",
"ptr",
")",
"\n",
"}"
] |
// Author returns the signature of the note author
|
[
"Author",
"returns",
"the",
"signature",
"of",
"the",
"note",
"author"
] |
bf1e8a4338822ad2539a3876f58b15b590eb9e1f
|
https://github.com/libgit2/git2go/blob/bf1e8a4338822ad2539a3876f58b15b590eb9e1f/note.go#L164-L167
|
151,133 |
libgit2/git2go
|
note.go
|
Id
|
func (n *Note) Id() *Oid {
ptr := C.git_note_id(n.ptr)
runtime.KeepAlive(n)
return newOidFromC(ptr)
}
|
go
|
func (n *Note) Id() *Oid {
ptr := C.git_note_id(n.ptr)
runtime.KeepAlive(n)
return newOidFromC(ptr)
}
|
[
"func",
"(",
"n",
"*",
"Note",
")",
"Id",
"(",
")",
"*",
"Oid",
"{",
"ptr",
":=",
"C",
".",
"git_note_id",
"(",
"n",
".",
"ptr",
")",
"\n",
"runtime",
".",
"KeepAlive",
"(",
"n",
")",
"\n",
"return",
"newOidFromC",
"(",
"ptr",
")",
"\n",
"}"
] |
// Id returns the note object's id
|
[
"Id",
"returns",
"the",
"note",
"object",
"s",
"id"
] |
bf1e8a4338822ad2539a3876f58b15b590eb9e1f
|
https://github.com/libgit2/git2go/blob/bf1e8a4338822ad2539a3876f58b15b590eb9e1f/note.go#L170-L174
|
151,134 |
libgit2/git2go
|
note.go
|
Committer
|
func (n *Note) Committer() *Signature {
ptr := C.git_note_committer(n.ptr)
runtime.KeepAlive(n)
return newSignatureFromC(ptr)
}
|
go
|
func (n *Note) Committer() *Signature {
ptr := C.git_note_committer(n.ptr)
runtime.KeepAlive(n)
return newSignatureFromC(ptr)
}
|
[
"func",
"(",
"n",
"*",
"Note",
")",
"Committer",
"(",
")",
"*",
"Signature",
"{",
"ptr",
":=",
"C",
".",
"git_note_committer",
"(",
"n",
".",
"ptr",
")",
"\n",
"runtime",
".",
"KeepAlive",
"(",
"n",
")",
"\n",
"return",
"newSignatureFromC",
"(",
"ptr",
")",
"\n",
"}"
] |
// Committer returns the signature of the note committer
|
[
"Committer",
"returns",
"the",
"signature",
"of",
"the",
"note",
"committer"
] |
bf1e8a4338822ad2539a3876f58b15b590eb9e1f
|
https://github.com/libgit2/git2go/blob/bf1e8a4338822ad2539a3876f58b15b590eb9e1f/note.go#L177-L181
|
151,135 |
libgit2/git2go
|
note.go
|
Message
|
func (n *Note) Message() string {
ret := C.GoString(C.git_note_message(n.ptr))
runtime.KeepAlive(n)
return ret
}
|
go
|
func (n *Note) Message() string {
ret := C.GoString(C.git_note_message(n.ptr))
runtime.KeepAlive(n)
return ret
}
|
[
"func",
"(",
"n",
"*",
"Note",
")",
"Message",
"(",
")",
"string",
"{",
"ret",
":=",
"C",
".",
"GoString",
"(",
"C",
".",
"git_note_message",
"(",
"n",
".",
"ptr",
")",
")",
"\n",
"runtime",
".",
"KeepAlive",
"(",
"n",
")",
"\n",
"return",
"ret",
"\n",
"}"
] |
// Message returns the note message
|
[
"Message",
"returns",
"the",
"note",
"message"
] |
bf1e8a4338822ad2539a3876f58b15b590eb9e1f
|
https://github.com/libgit2/git2go/blob/bf1e8a4338822ad2539a3876f58b15b590eb9e1f/note.go#L184-L188
|
151,136 |
libgit2/git2go
|
note.go
|
NewNoteIterator
|
func (repo *Repository) NewNoteIterator(ref string) (*NoteIterator, error) {
var cref *C.char
if ref == "" {
cref = nil
} else {
cref = C.CString(ref)
defer C.free(unsafe.Pointer(cref))
}
var ptr *C.git_note_iterator
runtime.LockOSThread()
defer runtime.UnlockOSThread()
ret := C.git_note_iterator_new(&ptr, repo.ptr, cref)
runtime.KeepAlive(repo)
if ret < 0 {
return nil, MakeGitError(ret)
}
iter := &NoteIterator{ptr: ptr, r: repo}
runtime.SetFinalizer(iter, (*NoteIterator).Free)
return iter, nil
}
|
go
|
func (repo *Repository) NewNoteIterator(ref string) (*NoteIterator, error) {
var cref *C.char
if ref == "" {
cref = nil
} else {
cref = C.CString(ref)
defer C.free(unsafe.Pointer(cref))
}
var ptr *C.git_note_iterator
runtime.LockOSThread()
defer runtime.UnlockOSThread()
ret := C.git_note_iterator_new(&ptr, repo.ptr, cref)
runtime.KeepAlive(repo)
if ret < 0 {
return nil, MakeGitError(ret)
}
iter := &NoteIterator{ptr: ptr, r: repo}
runtime.SetFinalizer(iter, (*NoteIterator).Free)
return iter, nil
}
|
[
"func",
"(",
"repo",
"*",
"Repository",
")",
"NewNoteIterator",
"(",
"ref",
"string",
")",
"(",
"*",
"NoteIterator",
",",
"error",
")",
"{",
"var",
"cref",
"*",
"C",
".",
"char",
"\n",
"if",
"ref",
"==",
"\"",
"\"",
"{",
"cref",
"=",
"nil",
"\n",
"}",
"else",
"{",
"cref",
"=",
"C",
".",
"CString",
"(",
"ref",
")",
"\n",
"defer",
"C",
".",
"free",
"(",
"unsafe",
".",
"Pointer",
"(",
"cref",
")",
")",
"\n",
"}",
"\n\n",
"var",
"ptr",
"*",
"C",
".",
"git_note_iterator",
"\n\n",
"runtime",
".",
"LockOSThread",
"(",
")",
"\n",
"defer",
"runtime",
".",
"UnlockOSThread",
"(",
")",
"\n\n",
"ret",
":=",
"C",
".",
"git_note_iterator_new",
"(",
"&",
"ptr",
",",
"repo",
".",
"ptr",
",",
"cref",
")",
"\n",
"runtime",
".",
"KeepAlive",
"(",
"repo",
")",
"\n",
"if",
"ret",
"<",
"0",
"{",
"return",
"nil",
",",
"MakeGitError",
"(",
"ret",
")",
"\n",
"}",
"\n\n",
"iter",
":=",
"&",
"NoteIterator",
"{",
"ptr",
":",
"ptr",
",",
"r",
":",
"repo",
"}",
"\n",
"runtime",
".",
"SetFinalizer",
"(",
"iter",
",",
"(",
"*",
"NoteIterator",
")",
".",
"Free",
")",
"\n",
"return",
"iter",
",",
"nil",
"\n",
"}"
] |
// NewNoteIterator creates a new iterator for notes
|
[
"NewNoteIterator",
"creates",
"a",
"new",
"iterator",
"for",
"notes"
] |
bf1e8a4338822ad2539a3876f58b15b590eb9e1f
|
https://github.com/libgit2/git2go/blob/bf1e8a4338822ad2539a3876f58b15b590eb9e1f/note.go#L197-L220
|
151,137 |
libgit2/git2go
|
note.go
|
Free
|
func (v *NoteIterator) Free() {
runtime.SetFinalizer(v, nil)
C.git_note_iterator_free(v.ptr)
}
|
go
|
func (v *NoteIterator) Free() {
runtime.SetFinalizer(v, nil)
C.git_note_iterator_free(v.ptr)
}
|
[
"func",
"(",
"v",
"*",
"NoteIterator",
")",
"Free",
"(",
")",
"{",
"runtime",
".",
"SetFinalizer",
"(",
"v",
",",
"nil",
")",
"\n",
"C",
".",
"git_note_iterator_free",
"(",
"v",
".",
"ptr",
")",
"\n",
"}"
] |
// Free frees the note interator
|
[
"Free",
"frees",
"the",
"note",
"interator"
] |
bf1e8a4338822ad2539a3876f58b15b590eb9e1f
|
https://github.com/libgit2/git2go/blob/bf1e8a4338822ad2539a3876f58b15b590eb9e1f/note.go#L223-L226
|
151,138 |
libgit2/git2go
|
blob.go
|
Write
|
func (stream *BlobWriteStream) Write(p []byte) (int, error) {
header := (*reflect.SliceHeader)(unsafe.Pointer(&p))
ptr := (*C.char)(unsafe.Pointer(header.Data))
size := C.size_t(header.Len)
runtime.LockOSThread()
defer runtime.UnlockOSThread()
ecode := C._go_git_writestream_write(stream.ptr, ptr, size)
runtime.KeepAlive(stream)
if ecode < 0 {
return 0, MakeGitError(ecode)
}
return len(p), nil
}
|
go
|
func (stream *BlobWriteStream) Write(p []byte) (int, error) {
header := (*reflect.SliceHeader)(unsafe.Pointer(&p))
ptr := (*C.char)(unsafe.Pointer(header.Data))
size := C.size_t(header.Len)
runtime.LockOSThread()
defer runtime.UnlockOSThread()
ecode := C._go_git_writestream_write(stream.ptr, ptr, size)
runtime.KeepAlive(stream)
if ecode < 0 {
return 0, MakeGitError(ecode)
}
return len(p), nil
}
|
[
"func",
"(",
"stream",
"*",
"BlobWriteStream",
")",
"Write",
"(",
"p",
"[",
"]",
"byte",
")",
"(",
"int",
",",
"error",
")",
"{",
"header",
":=",
"(",
"*",
"reflect",
".",
"SliceHeader",
")",
"(",
"unsafe",
".",
"Pointer",
"(",
"&",
"p",
")",
")",
"\n",
"ptr",
":=",
"(",
"*",
"C",
".",
"char",
")",
"(",
"unsafe",
".",
"Pointer",
"(",
"header",
".",
"Data",
")",
")",
"\n",
"size",
":=",
"C",
".",
"size_t",
"(",
"header",
".",
"Len",
")",
"\n\n",
"runtime",
".",
"LockOSThread",
"(",
")",
"\n",
"defer",
"runtime",
".",
"UnlockOSThread",
"(",
")",
"\n\n",
"ecode",
":=",
"C",
".",
"_go_git_writestream_write",
"(",
"stream",
".",
"ptr",
",",
"ptr",
",",
"size",
")",
"\n",
"runtime",
".",
"KeepAlive",
"(",
"stream",
")",
"\n",
"if",
"ecode",
"<",
"0",
"{",
"return",
"0",
",",
"MakeGitError",
"(",
"ecode",
")",
"\n",
"}",
"\n\n",
"return",
"len",
"(",
"p",
")",
",",
"nil",
"\n",
"}"
] |
// Implement io.Writer
|
[
"Implement",
"io",
".",
"Writer"
] |
bf1e8a4338822ad2539a3876f58b15b590eb9e1f
|
https://github.com/libgit2/git2go/blob/bf1e8a4338822ad2539a3876f58b15b590eb9e1f/blob.go#L135-L150
|
151,139 |
libgit2/git2go
|
diff.go
|
DiffBlobs
|
func DiffBlobs(oldBlob *Blob, oldAsPath string, newBlob *Blob, newAsPath string, opts *DiffOptions, fileCallback DiffForEachFileCallback, detail DiffDetail) error {
data := &diffForEachData{
FileCallback: fileCallback,
}
intHunks := C.int(0)
if detail >= DiffDetailHunks {
intHunks = C.int(1)
}
intLines := C.int(0)
if detail >= DiffDetailLines {
intLines = C.int(1)
}
handle := pointerHandles.Track(data)
defer pointerHandles.Untrack(handle)
var oldBlobPtr, newBlobPtr *C.git_blob
if oldBlob != nil {
oldBlobPtr = oldBlob.cast_ptr
}
if newBlob != nil {
newBlobPtr = newBlob.cast_ptr
}
oldBlobPath := C.CString(oldAsPath)
defer C.free(unsafe.Pointer(oldBlobPath))
newBlobPath := C.CString(newAsPath)
defer C.free(unsafe.Pointer(newBlobPath))
copts, _ := diffOptionsToC(opts)
defer freeDiffOptions(copts)
runtime.LockOSThread()
defer runtime.UnlockOSThread()
ecode := C._go_git_diff_blobs(oldBlobPtr, oldBlobPath, newBlobPtr, newBlobPath, copts, 1, intHunks, intLines, handle)
runtime.KeepAlive(oldBlob)
runtime.KeepAlive(newBlob)
if ecode < 0 {
return MakeGitError(ecode)
}
return nil
}
|
go
|
func DiffBlobs(oldBlob *Blob, oldAsPath string, newBlob *Blob, newAsPath string, opts *DiffOptions, fileCallback DiffForEachFileCallback, detail DiffDetail) error {
data := &diffForEachData{
FileCallback: fileCallback,
}
intHunks := C.int(0)
if detail >= DiffDetailHunks {
intHunks = C.int(1)
}
intLines := C.int(0)
if detail >= DiffDetailLines {
intLines = C.int(1)
}
handle := pointerHandles.Track(data)
defer pointerHandles.Untrack(handle)
var oldBlobPtr, newBlobPtr *C.git_blob
if oldBlob != nil {
oldBlobPtr = oldBlob.cast_ptr
}
if newBlob != nil {
newBlobPtr = newBlob.cast_ptr
}
oldBlobPath := C.CString(oldAsPath)
defer C.free(unsafe.Pointer(oldBlobPath))
newBlobPath := C.CString(newAsPath)
defer C.free(unsafe.Pointer(newBlobPath))
copts, _ := diffOptionsToC(opts)
defer freeDiffOptions(copts)
runtime.LockOSThread()
defer runtime.UnlockOSThread()
ecode := C._go_git_diff_blobs(oldBlobPtr, oldBlobPath, newBlobPtr, newBlobPath, copts, 1, intHunks, intLines, handle)
runtime.KeepAlive(oldBlob)
runtime.KeepAlive(newBlob)
if ecode < 0 {
return MakeGitError(ecode)
}
return nil
}
|
[
"func",
"DiffBlobs",
"(",
"oldBlob",
"*",
"Blob",
",",
"oldAsPath",
"string",
",",
"newBlob",
"*",
"Blob",
",",
"newAsPath",
"string",
",",
"opts",
"*",
"DiffOptions",
",",
"fileCallback",
"DiffForEachFileCallback",
",",
"detail",
"DiffDetail",
")",
"error",
"{",
"data",
":=",
"&",
"diffForEachData",
"{",
"FileCallback",
":",
"fileCallback",
",",
"}",
"\n\n",
"intHunks",
":=",
"C",
".",
"int",
"(",
"0",
")",
"\n",
"if",
"detail",
">=",
"DiffDetailHunks",
"{",
"intHunks",
"=",
"C",
".",
"int",
"(",
"1",
")",
"\n",
"}",
"\n\n",
"intLines",
":=",
"C",
".",
"int",
"(",
"0",
")",
"\n",
"if",
"detail",
">=",
"DiffDetailLines",
"{",
"intLines",
"=",
"C",
".",
"int",
"(",
"1",
")",
"\n",
"}",
"\n\n",
"handle",
":=",
"pointerHandles",
".",
"Track",
"(",
"data",
")",
"\n",
"defer",
"pointerHandles",
".",
"Untrack",
"(",
"handle",
")",
"\n\n",
"var",
"oldBlobPtr",
",",
"newBlobPtr",
"*",
"C",
".",
"git_blob",
"\n",
"if",
"oldBlob",
"!=",
"nil",
"{",
"oldBlobPtr",
"=",
"oldBlob",
".",
"cast_ptr",
"\n",
"}",
"\n",
"if",
"newBlob",
"!=",
"nil",
"{",
"newBlobPtr",
"=",
"newBlob",
".",
"cast_ptr",
"\n",
"}",
"\n\n",
"oldBlobPath",
":=",
"C",
".",
"CString",
"(",
"oldAsPath",
")",
"\n",
"defer",
"C",
".",
"free",
"(",
"unsafe",
".",
"Pointer",
"(",
"oldBlobPath",
")",
")",
"\n",
"newBlobPath",
":=",
"C",
".",
"CString",
"(",
"newAsPath",
")",
"\n",
"defer",
"C",
".",
"free",
"(",
"unsafe",
".",
"Pointer",
"(",
"newBlobPath",
")",
")",
"\n\n",
"copts",
",",
"_",
":=",
"diffOptionsToC",
"(",
"opts",
")",
"\n",
"defer",
"freeDiffOptions",
"(",
"copts",
")",
"\n\n",
"runtime",
".",
"LockOSThread",
"(",
")",
"\n",
"defer",
"runtime",
".",
"UnlockOSThread",
"(",
")",
"\n\n",
"ecode",
":=",
"C",
".",
"_go_git_diff_blobs",
"(",
"oldBlobPtr",
",",
"oldBlobPath",
",",
"newBlobPtr",
",",
"newBlobPath",
",",
"copts",
",",
"1",
",",
"intHunks",
",",
"intLines",
",",
"handle",
")",
"\n",
"runtime",
".",
"KeepAlive",
"(",
"oldBlob",
")",
"\n",
"runtime",
".",
"KeepAlive",
"(",
"newBlob",
")",
"\n",
"if",
"ecode",
"<",
"0",
"{",
"return",
"MakeGitError",
"(",
"ecode",
")",
"\n",
"}",
"\n\n",
"return",
"nil",
"\n",
"}"
] |
// DiffBlobs performs a diff between two arbitrary blobs. You can pass
// whatever file names you'd like for them to appear as in the diff.
|
[
"DiffBlobs",
"performs",
"a",
"diff",
"between",
"two",
"arbitrary",
"blobs",
".",
"You",
"can",
"pass",
"whatever",
"file",
"names",
"you",
"d",
"like",
"for",
"them",
"to",
"appear",
"as",
"in",
"the",
"diff",
"."
] |
bf1e8a4338822ad2539a3876f58b15b590eb9e1f
|
https://github.com/libgit2/git2go/blob/bf1e8a4338822ad2539a3876f58b15b590eb9e1f/diff.go#L765-L810
|
151,140 |
libgit2/git2go
|
rebase.go
|
DefaultRebaseOptions
|
func DefaultRebaseOptions() (RebaseOptions, error) {
opts := C.git_rebase_options{}
runtime.LockOSThread()
defer runtime.UnlockOSThread()
ecode := C.git_rebase_init_options(&opts, C.GIT_REBASE_OPTIONS_VERSION)
if ecode < 0 {
return RebaseOptions{}, MakeGitError(ecode)
}
return rebaseOptionsFromC(&opts), nil
}
|
go
|
func DefaultRebaseOptions() (RebaseOptions, error) {
opts := C.git_rebase_options{}
runtime.LockOSThread()
defer runtime.UnlockOSThread()
ecode := C.git_rebase_init_options(&opts, C.GIT_REBASE_OPTIONS_VERSION)
if ecode < 0 {
return RebaseOptions{}, MakeGitError(ecode)
}
return rebaseOptionsFromC(&opts), nil
}
|
[
"func",
"DefaultRebaseOptions",
"(",
")",
"(",
"RebaseOptions",
",",
"error",
")",
"{",
"opts",
":=",
"C",
".",
"git_rebase_options",
"{",
"}",
"\n\n",
"runtime",
".",
"LockOSThread",
"(",
")",
"\n",
"defer",
"runtime",
".",
"UnlockOSThread",
"(",
")",
"\n\n",
"ecode",
":=",
"C",
".",
"git_rebase_init_options",
"(",
"&",
"opts",
",",
"C",
".",
"GIT_REBASE_OPTIONS_VERSION",
")",
"\n",
"if",
"ecode",
"<",
"0",
"{",
"return",
"RebaseOptions",
"{",
"}",
",",
"MakeGitError",
"(",
"ecode",
")",
"\n",
"}",
"\n",
"return",
"rebaseOptionsFromC",
"(",
"&",
"opts",
")",
",",
"nil",
"\n",
"}"
] |
// DefaultRebaseOptions returns a RebaseOptions with default values.
|
[
"DefaultRebaseOptions",
"returns",
"a",
"RebaseOptions",
"with",
"default",
"values",
"."
] |
bf1e8a4338822ad2539a3876f58b15b590eb9e1f
|
https://github.com/libgit2/git2go/blob/bf1e8a4338822ad2539a3876f58b15b590eb9e1f/rebase.go#L83-L94
|
151,141 |
libgit2/git2go
|
rebase.go
|
InitRebase
|
func (r *Repository) InitRebase(branch *AnnotatedCommit, upstream *AnnotatedCommit, onto *AnnotatedCommit, opts *RebaseOptions) (*Rebase, error) {
runtime.LockOSThread()
defer runtime.UnlockOSThread()
if branch == nil {
branch = &AnnotatedCommit{ptr: nil}
}
if upstream == nil {
upstream = &AnnotatedCommit{ptr: nil}
}
if onto == nil {
onto = &AnnotatedCommit{ptr: nil}
}
var ptr *C.git_rebase
err := C.git_rebase_init(&ptr, r.ptr, branch.ptr, upstream.ptr, onto.ptr, opts.toC())
runtime.KeepAlive(branch)
runtime.KeepAlive(upstream)
runtime.KeepAlive(onto)
if err < 0 {
return nil, MakeGitError(err)
}
return newRebaseFromC(ptr), nil
}
|
go
|
func (r *Repository) InitRebase(branch *AnnotatedCommit, upstream *AnnotatedCommit, onto *AnnotatedCommit, opts *RebaseOptions) (*Rebase, error) {
runtime.LockOSThread()
defer runtime.UnlockOSThread()
if branch == nil {
branch = &AnnotatedCommit{ptr: nil}
}
if upstream == nil {
upstream = &AnnotatedCommit{ptr: nil}
}
if onto == nil {
onto = &AnnotatedCommit{ptr: nil}
}
var ptr *C.git_rebase
err := C.git_rebase_init(&ptr, r.ptr, branch.ptr, upstream.ptr, onto.ptr, opts.toC())
runtime.KeepAlive(branch)
runtime.KeepAlive(upstream)
runtime.KeepAlive(onto)
if err < 0 {
return nil, MakeGitError(err)
}
return newRebaseFromC(ptr), nil
}
|
[
"func",
"(",
"r",
"*",
"Repository",
")",
"InitRebase",
"(",
"branch",
"*",
"AnnotatedCommit",
",",
"upstream",
"*",
"AnnotatedCommit",
",",
"onto",
"*",
"AnnotatedCommit",
",",
"opts",
"*",
"RebaseOptions",
")",
"(",
"*",
"Rebase",
",",
"error",
")",
"{",
"runtime",
".",
"LockOSThread",
"(",
")",
"\n",
"defer",
"runtime",
".",
"UnlockOSThread",
"(",
")",
"\n\n",
"if",
"branch",
"==",
"nil",
"{",
"branch",
"=",
"&",
"AnnotatedCommit",
"{",
"ptr",
":",
"nil",
"}",
"\n",
"}",
"\n\n",
"if",
"upstream",
"==",
"nil",
"{",
"upstream",
"=",
"&",
"AnnotatedCommit",
"{",
"ptr",
":",
"nil",
"}",
"\n",
"}",
"\n\n",
"if",
"onto",
"==",
"nil",
"{",
"onto",
"=",
"&",
"AnnotatedCommit",
"{",
"ptr",
":",
"nil",
"}",
"\n",
"}",
"\n\n",
"var",
"ptr",
"*",
"C",
".",
"git_rebase",
"\n",
"err",
":=",
"C",
".",
"git_rebase_init",
"(",
"&",
"ptr",
",",
"r",
".",
"ptr",
",",
"branch",
".",
"ptr",
",",
"upstream",
".",
"ptr",
",",
"onto",
".",
"ptr",
",",
"opts",
".",
"toC",
"(",
")",
")",
"\n",
"runtime",
".",
"KeepAlive",
"(",
"branch",
")",
"\n",
"runtime",
".",
"KeepAlive",
"(",
"upstream",
")",
"\n",
"runtime",
".",
"KeepAlive",
"(",
"onto",
")",
"\n",
"if",
"err",
"<",
"0",
"{",
"return",
"nil",
",",
"MakeGitError",
"(",
"err",
")",
"\n",
"}",
"\n\n",
"return",
"newRebaseFromC",
"(",
"ptr",
")",
",",
"nil",
"\n",
"}"
] |
// InitRebase initializes a rebase operation to rebase the changes in branch relative to upstream onto another branch.
|
[
"InitRebase",
"initializes",
"a",
"rebase",
"operation",
"to",
"rebase",
"the",
"changes",
"in",
"branch",
"relative",
"to",
"upstream",
"onto",
"another",
"branch",
"."
] |
bf1e8a4338822ad2539a3876f58b15b590eb9e1f
|
https://github.com/libgit2/git2go/blob/bf1e8a4338822ad2539a3876f58b15b590eb9e1f/rebase.go#L135-L161
|
151,142 |
libgit2/git2go
|
rebase.go
|
OpenRebase
|
func (r *Repository) OpenRebase(opts *RebaseOptions) (*Rebase, error) {
runtime.LockOSThread()
defer runtime.UnlockOSThread()
var ptr *C.git_rebase
err := C.git_rebase_open(&ptr, r.ptr, opts.toC())
runtime.KeepAlive(r)
if err < 0 {
return nil, MakeGitError(err)
}
return newRebaseFromC(ptr), nil
}
|
go
|
func (r *Repository) OpenRebase(opts *RebaseOptions) (*Rebase, error) {
runtime.LockOSThread()
defer runtime.UnlockOSThread()
var ptr *C.git_rebase
err := C.git_rebase_open(&ptr, r.ptr, opts.toC())
runtime.KeepAlive(r)
if err < 0 {
return nil, MakeGitError(err)
}
return newRebaseFromC(ptr), nil
}
|
[
"func",
"(",
"r",
"*",
"Repository",
")",
"OpenRebase",
"(",
"opts",
"*",
"RebaseOptions",
")",
"(",
"*",
"Rebase",
",",
"error",
")",
"{",
"runtime",
".",
"LockOSThread",
"(",
")",
"\n",
"defer",
"runtime",
".",
"UnlockOSThread",
"(",
")",
"\n\n",
"var",
"ptr",
"*",
"C",
".",
"git_rebase",
"\n",
"err",
":=",
"C",
".",
"git_rebase_open",
"(",
"&",
"ptr",
",",
"r",
".",
"ptr",
",",
"opts",
".",
"toC",
"(",
")",
")",
"\n",
"runtime",
".",
"KeepAlive",
"(",
"r",
")",
"\n",
"if",
"err",
"<",
"0",
"{",
"return",
"nil",
",",
"MakeGitError",
"(",
"err",
")",
"\n",
"}",
"\n\n",
"return",
"newRebaseFromC",
"(",
"ptr",
")",
",",
"nil",
"\n",
"}"
] |
// OpenRebase opens an existing rebase that was previously started by either an invocation of InitRebase or by another client.
|
[
"OpenRebase",
"opens",
"an",
"existing",
"rebase",
"that",
"was",
"previously",
"started",
"by",
"either",
"an",
"invocation",
"of",
"InitRebase",
"or",
"by",
"another",
"client",
"."
] |
bf1e8a4338822ad2539a3876f58b15b590eb9e1f
|
https://github.com/libgit2/git2go/blob/bf1e8a4338822ad2539a3876f58b15b590eb9e1f/rebase.go#L164-L176
|
151,143 |
libgit2/git2go
|
rebase.go
|
OperationAt
|
func (rebase *Rebase) OperationAt(index uint) *RebaseOperation {
operation := C.git_rebase_operation_byindex(rebase.ptr, C.size_t(index))
return newRebaseOperationFromC(operation)
}
|
go
|
func (rebase *Rebase) OperationAt(index uint) *RebaseOperation {
operation := C.git_rebase_operation_byindex(rebase.ptr, C.size_t(index))
return newRebaseOperationFromC(operation)
}
|
[
"func",
"(",
"rebase",
"*",
"Rebase",
")",
"OperationAt",
"(",
"index",
"uint",
")",
"*",
"RebaseOperation",
"{",
"operation",
":=",
"C",
".",
"git_rebase_operation_byindex",
"(",
"rebase",
".",
"ptr",
",",
"C",
".",
"size_t",
"(",
"index",
")",
")",
"\n\n",
"return",
"newRebaseOperationFromC",
"(",
"operation",
")",
"\n",
"}"
] |
// OperationAt gets the rebase operation specified by the given index.
|
[
"OperationAt",
"gets",
"the",
"rebase",
"operation",
"specified",
"by",
"the",
"given",
"index",
"."
] |
bf1e8a4338822ad2539a3876f58b15b590eb9e1f
|
https://github.com/libgit2/git2go/blob/bf1e8a4338822ad2539a3876f58b15b590eb9e1f/rebase.go#L179-L183
|
151,144 |
libgit2/git2go
|
rebase.go
|
CurrentOperationIndex
|
func (rebase *Rebase) CurrentOperationIndex() (uint, error) {
runtime.LockOSThread()
defer runtime.UnlockOSThread()
var err error
operationIndex := uint(C.git_rebase_operation_current(rebase.ptr))
runtime.KeepAlive(rebase)
if operationIndex == RebaseNoOperation {
err = ErrRebaseNoOperation
}
return uint(operationIndex), err
}
|
go
|
func (rebase *Rebase) CurrentOperationIndex() (uint, error) {
runtime.LockOSThread()
defer runtime.UnlockOSThread()
var err error
operationIndex := uint(C.git_rebase_operation_current(rebase.ptr))
runtime.KeepAlive(rebase)
if operationIndex == RebaseNoOperation {
err = ErrRebaseNoOperation
}
return uint(operationIndex), err
}
|
[
"func",
"(",
"rebase",
"*",
"Rebase",
")",
"CurrentOperationIndex",
"(",
")",
"(",
"uint",
",",
"error",
")",
"{",
"runtime",
".",
"LockOSThread",
"(",
")",
"\n",
"defer",
"runtime",
".",
"UnlockOSThread",
"(",
")",
"\n\n",
"var",
"err",
"error",
"\n",
"operationIndex",
":=",
"uint",
"(",
"C",
".",
"git_rebase_operation_current",
"(",
"rebase",
".",
"ptr",
")",
")",
"\n",
"runtime",
".",
"KeepAlive",
"(",
"rebase",
")",
"\n",
"if",
"operationIndex",
"==",
"RebaseNoOperation",
"{",
"err",
"=",
"ErrRebaseNoOperation",
"\n",
"}",
"\n\n",
"return",
"uint",
"(",
"operationIndex",
")",
",",
"err",
"\n",
"}"
] |
// CurrentOperationIndex gets the index of the rebase operation that is
// currently being applied. There is also an error returned for API
// compatibility.
|
[
"CurrentOperationIndex",
"gets",
"the",
"index",
"of",
"the",
"rebase",
"operation",
"that",
"is",
"currently",
"being",
"applied",
".",
"There",
"is",
"also",
"an",
"error",
"returned",
"for",
"API",
"compatibility",
"."
] |
bf1e8a4338822ad2539a3876f58b15b590eb9e1f
|
https://github.com/libgit2/git2go/blob/bf1e8a4338822ad2539a3876f58b15b590eb9e1f/rebase.go#L188-L200
|
151,145 |
libgit2/git2go
|
rebase.go
|
OperationCount
|
func (rebase *Rebase) OperationCount() uint {
ret := uint(C.git_rebase_operation_entrycount(rebase.ptr))
runtime.KeepAlive(rebase)
return ret
}
|
go
|
func (rebase *Rebase) OperationCount() uint {
ret := uint(C.git_rebase_operation_entrycount(rebase.ptr))
runtime.KeepAlive(rebase)
return ret
}
|
[
"func",
"(",
"rebase",
"*",
"Rebase",
")",
"OperationCount",
"(",
")",
"uint",
"{",
"ret",
":=",
"uint",
"(",
"C",
".",
"git_rebase_operation_entrycount",
"(",
"rebase",
".",
"ptr",
")",
")",
"\n",
"runtime",
".",
"KeepAlive",
"(",
"rebase",
")",
"\n",
"return",
"ret",
"\n",
"}"
] |
// OperationCount gets the count of rebase operations that are to be applied.
|
[
"OperationCount",
"gets",
"the",
"count",
"of",
"rebase",
"operations",
"that",
"are",
"to",
"be",
"applied",
"."
] |
bf1e8a4338822ad2539a3876f58b15b590eb9e1f
|
https://github.com/libgit2/git2go/blob/bf1e8a4338822ad2539a3876f58b15b590eb9e1f/rebase.go#L203-L207
|
151,146 |
libgit2/git2go
|
rebase.go
|
Finish
|
func (rebase *Rebase) Finish() error {
runtime.LockOSThread()
defer runtime.UnlockOSThread()
err := C.git_rebase_finish(rebase.ptr, nil)
runtime.KeepAlive(rebase)
if err < 0 {
return MakeGitError(err)
}
return nil
}
|
go
|
func (rebase *Rebase) Finish() error {
runtime.LockOSThread()
defer runtime.UnlockOSThread()
err := C.git_rebase_finish(rebase.ptr, nil)
runtime.KeepAlive(rebase)
if err < 0 {
return MakeGitError(err)
}
return nil
}
|
[
"func",
"(",
"rebase",
"*",
"Rebase",
")",
"Finish",
"(",
")",
"error",
"{",
"runtime",
".",
"LockOSThread",
"(",
")",
"\n",
"defer",
"runtime",
".",
"UnlockOSThread",
"(",
")",
"\n\n",
"err",
":=",
"C",
".",
"git_rebase_finish",
"(",
"rebase",
".",
"ptr",
",",
"nil",
")",
"\n",
"runtime",
".",
"KeepAlive",
"(",
"rebase",
")",
"\n",
"if",
"err",
"<",
"0",
"{",
"return",
"MakeGitError",
"(",
"err",
")",
"\n",
"}",
"\n\n",
"return",
"nil",
"\n",
"}"
] |
// Finish finishes a rebase that is currently in progress once all patches have been applied.
|
[
"Finish",
"finishes",
"a",
"rebase",
"that",
"is",
"currently",
"in",
"progress",
"once",
"all",
"patches",
"have",
"been",
"applied",
"."
] |
bf1e8a4338822ad2539a3876f58b15b590eb9e1f
|
https://github.com/libgit2/git2go/blob/bf1e8a4338822ad2539a3876f58b15b590eb9e1f/rebase.go#L259-L270
|
151,147 |
libgit2/git2go
|
rebase.go
|
Abort
|
func (rebase *Rebase) Abort() error {
runtime.LockOSThread()
defer runtime.UnlockOSThread()
err := C.git_rebase_abort(rebase.ptr)
runtime.KeepAlive(rebase)
if err < 0 {
return MakeGitError(err)
}
return nil
}
|
go
|
func (rebase *Rebase) Abort() error {
runtime.LockOSThread()
defer runtime.UnlockOSThread()
err := C.git_rebase_abort(rebase.ptr)
runtime.KeepAlive(rebase)
if err < 0 {
return MakeGitError(err)
}
return nil
}
|
[
"func",
"(",
"rebase",
"*",
"Rebase",
")",
"Abort",
"(",
")",
"error",
"{",
"runtime",
".",
"LockOSThread",
"(",
")",
"\n",
"defer",
"runtime",
".",
"UnlockOSThread",
"(",
")",
"\n\n",
"err",
":=",
"C",
".",
"git_rebase_abort",
"(",
"rebase",
".",
"ptr",
")",
"\n",
"runtime",
".",
"KeepAlive",
"(",
"rebase",
")",
"\n",
"if",
"err",
"<",
"0",
"{",
"return",
"MakeGitError",
"(",
"err",
")",
"\n",
"}",
"\n",
"return",
"nil",
"\n",
"}"
] |
// Abort aborts a rebase that is currently in progress, resetting the repository and working directory to their state before rebase began.
|
[
"Abort",
"aborts",
"a",
"rebase",
"that",
"is",
"currently",
"in",
"progress",
"resetting",
"the",
"repository",
"and",
"working",
"directory",
"to",
"their",
"state",
"before",
"rebase",
"began",
"."
] |
bf1e8a4338822ad2539a3876f58b15b590eb9e1f
|
https://github.com/libgit2/git2go/blob/bf1e8a4338822ad2539a3876f58b15b590eb9e1f/rebase.go#L273-L283
|
151,148 |
libgit2/git2go
|
rebase.go
|
Free
|
func (rebase *Rebase) Free() {
runtime.SetFinalizer(rebase, nil)
C.git_rebase_free(rebase.ptr)
}
|
go
|
func (rebase *Rebase) Free() {
runtime.SetFinalizer(rebase, nil)
C.git_rebase_free(rebase.ptr)
}
|
[
"func",
"(",
"rebase",
"*",
"Rebase",
")",
"Free",
"(",
")",
"{",
"runtime",
".",
"SetFinalizer",
"(",
"rebase",
",",
"nil",
")",
"\n",
"C",
".",
"git_rebase_free",
"(",
"rebase",
".",
"ptr",
")",
"\n",
"}"
] |
// Free frees the Rebase object.
|
[
"Free",
"frees",
"the",
"Rebase",
"object",
"."
] |
bf1e8a4338822ad2539a3876f58b15b590eb9e1f
|
https://github.com/libgit2/git2go/blob/bf1e8a4338822ad2539a3876f58b15b590eb9e1f/rebase.go#L286-L289
|
151,149 |
libgit2/git2go
|
mempack.go
|
NewMempack
|
func NewMempack(odb *Odb) (mempack *Mempack, err error) {
mempack = new(Mempack)
runtime.LockOSThread()
defer runtime.UnlockOSThread()
ret := C.git_mempack_new(&mempack.ptr)
if ret < 0 {
return nil, MakeGitError(ret)
}
ret = C.git_odb_add_backend(odb.ptr, mempack.ptr, C.int(999))
runtime.KeepAlive(odb)
if ret < 0 {
// Since git_odb_add_alternate() takes ownership of the ODB backend, the
// only case in which we free the mempack's memory is if it fails to be
// added to the ODB.
C._go_git_odb_backend_free(mempack.ptr)
return nil, MakeGitError(ret)
}
return mempack, nil
}
|
go
|
func NewMempack(odb *Odb) (mempack *Mempack, err error) {
mempack = new(Mempack)
runtime.LockOSThread()
defer runtime.UnlockOSThread()
ret := C.git_mempack_new(&mempack.ptr)
if ret < 0 {
return nil, MakeGitError(ret)
}
ret = C.git_odb_add_backend(odb.ptr, mempack.ptr, C.int(999))
runtime.KeepAlive(odb)
if ret < 0 {
// Since git_odb_add_alternate() takes ownership of the ODB backend, the
// only case in which we free the mempack's memory is if it fails to be
// added to the ODB.
C._go_git_odb_backend_free(mempack.ptr)
return nil, MakeGitError(ret)
}
return mempack, nil
}
|
[
"func",
"NewMempack",
"(",
"odb",
"*",
"Odb",
")",
"(",
"mempack",
"*",
"Mempack",
",",
"err",
"error",
")",
"{",
"mempack",
"=",
"new",
"(",
"Mempack",
")",
"\n\n",
"runtime",
".",
"LockOSThread",
"(",
")",
"\n",
"defer",
"runtime",
".",
"UnlockOSThread",
"(",
")",
"\n\n",
"ret",
":=",
"C",
".",
"git_mempack_new",
"(",
"&",
"mempack",
".",
"ptr",
")",
"\n",
"if",
"ret",
"<",
"0",
"{",
"return",
"nil",
",",
"MakeGitError",
"(",
"ret",
")",
"\n",
"}",
"\n\n",
"ret",
"=",
"C",
".",
"git_odb_add_backend",
"(",
"odb",
".",
"ptr",
",",
"mempack",
".",
"ptr",
",",
"C",
".",
"int",
"(",
"999",
")",
")",
"\n",
"runtime",
".",
"KeepAlive",
"(",
"odb",
")",
"\n",
"if",
"ret",
"<",
"0",
"{",
"// Since git_odb_add_alternate() takes ownership of the ODB backend, the",
"// only case in which we free the mempack's memory is if it fails to be",
"// added to the ODB.",
"C",
".",
"_go_git_odb_backend_free",
"(",
"mempack",
".",
"ptr",
")",
"\n",
"return",
"nil",
",",
"MakeGitError",
"(",
"ret",
")",
"\n",
"}",
"\n\n",
"return",
"mempack",
",",
"nil",
"\n",
"}"
] |
// NewMempack creates a new mempack instance and registers it to the ODB.
|
[
"NewMempack",
"creates",
"a",
"new",
"mempack",
"instance",
"and",
"registers",
"it",
"to",
"the",
"ODB",
"."
] |
bf1e8a4338822ad2539a3876f58b15b590eb9e1f
|
https://github.com/libgit2/git2go/blob/bf1e8a4338822ad2539a3876f58b15b590eb9e1f/mempack.go#L25-L47
|
151,150 |
libgit2/git2go
|
remote.go
|
Fetch
|
func (o *Remote) Fetch(refspecs []string, opts *FetchOptions, msg string) error {
var cmsg *C.char = nil
if msg != "" {
cmsg = C.CString(msg)
defer C.free(unsafe.Pointer(cmsg))
}
crefspecs := C.git_strarray{}
crefspecs.count = C.size_t(len(refspecs))
crefspecs.strings = makeCStringsFromStrings(refspecs)
defer freeStrarray(&crefspecs)
coptions := (*C.git_fetch_options)(C.calloc(1, C.size_t(unsafe.Sizeof(C.git_fetch_options{}))))
defer C.free(unsafe.Pointer(coptions))
populateFetchOptions(coptions, opts)
defer untrackCalbacksPayload(&coptions.callbacks)
defer freeStrarray(&coptions.custom_headers)
runtime.LockOSThread()
defer runtime.UnlockOSThread()
ret := C.git_remote_fetch(o.ptr, &crefspecs, coptions, cmsg)
runtime.KeepAlive(o)
if ret < 0 {
return MakeGitError(ret)
}
return nil
}
|
go
|
func (o *Remote) Fetch(refspecs []string, opts *FetchOptions, msg string) error {
var cmsg *C.char = nil
if msg != "" {
cmsg = C.CString(msg)
defer C.free(unsafe.Pointer(cmsg))
}
crefspecs := C.git_strarray{}
crefspecs.count = C.size_t(len(refspecs))
crefspecs.strings = makeCStringsFromStrings(refspecs)
defer freeStrarray(&crefspecs)
coptions := (*C.git_fetch_options)(C.calloc(1, C.size_t(unsafe.Sizeof(C.git_fetch_options{}))))
defer C.free(unsafe.Pointer(coptions))
populateFetchOptions(coptions, opts)
defer untrackCalbacksPayload(&coptions.callbacks)
defer freeStrarray(&coptions.custom_headers)
runtime.LockOSThread()
defer runtime.UnlockOSThread()
ret := C.git_remote_fetch(o.ptr, &crefspecs, coptions, cmsg)
runtime.KeepAlive(o)
if ret < 0 {
return MakeGitError(ret)
}
return nil
}
|
[
"func",
"(",
"o",
"*",
"Remote",
")",
"Fetch",
"(",
"refspecs",
"[",
"]",
"string",
",",
"opts",
"*",
"FetchOptions",
",",
"msg",
"string",
")",
"error",
"{",
"var",
"cmsg",
"*",
"C",
".",
"char",
"=",
"nil",
"\n",
"if",
"msg",
"!=",
"\"",
"\"",
"{",
"cmsg",
"=",
"C",
".",
"CString",
"(",
"msg",
")",
"\n",
"defer",
"C",
".",
"free",
"(",
"unsafe",
".",
"Pointer",
"(",
"cmsg",
")",
")",
"\n",
"}",
"\n\n",
"crefspecs",
":=",
"C",
".",
"git_strarray",
"{",
"}",
"\n",
"crefspecs",
".",
"count",
"=",
"C",
".",
"size_t",
"(",
"len",
"(",
"refspecs",
")",
")",
"\n",
"crefspecs",
".",
"strings",
"=",
"makeCStringsFromStrings",
"(",
"refspecs",
")",
"\n",
"defer",
"freeStrarray",
"(",
"&",
"crefspecs",
")",
"\n\n",
"coptions",
":=",
"(",
"*",
"C",
".",
"git_fetch_options",
")",
"(",
"C",
".",
"calloc",
"(",
"1",
",",
"C",
".",
"size_t",
"(",
"unsafe",
".",
"Sizeof",
"(",
"C",
".",
"git_fetch_options",
"{",
"}",
")",
")",
")",
")",
"\n",
"defer",
"C",
".",
"free",
"(",
"unsafe",
".",
"Pointer",
"(",
"coptions",
")",
")",
"\n\n",
"populateFetchOptions",
"(",
"coptions",
",",
"opts",
")",
"\n",
"defer",
"untrackCalbacksPayload",
"(",
"&",
"coptions",
".",
"callbacks",
")",
"\n",
"defer",
"freeStrarray",
"(",
"&",
"coptions",
".",
"custom_headers",
")",
"\n\n",
"runtime",
".",
"LockOSThread",
"(",
")",
"\n",
"defer",
"runtime",
".",
"UnlockOSThread",
"(",
")",
"\n\n",
"ret",
":=",
"C",
".",
"git_remote_fetch",
"(",
"o",
".",
"ptr",
",",
"&",
"crefspecs",
",",
"coptions",
",",
"cmsg",
")",
"\n",
"runtime",
".",
"KeepAlive",
"(",
"o",
")",
"\n",
"if",
"ret",
"<",
"0",
"{",
"return",
"MakeGitError",
"(",
"ret",
")",
"\n",
"}",
"\n",
"return",
"nil",
"\n",
"}"
] |
// Fetch performs a fetch operation. refspecs specifies which refspecs
// to use for this fetch, use an empty list to use the refspecs from
// the configuration; msg specifies what to use for the reflog
// entries. Leave "" to use defaults.
|
[
"Fetch",
"performs",
"a",
"fetch",
"operation",
".",
"refspecs",
"specifies",
"which",
"refspecs",
"to",
"use",
"for",
"this",
"fetch",
"use",
"an",
"empty",
"list",
"to",
"use",
"the",
"refspecs",
"from",
"the",
"configuration",
";",
"msg",
"specifies",
"what",
"to",
"use",
"for",
"the",
"reflog",
"entries",
".",
"Leave",
"to",
"use",
"defaults",
"."
] |
bf1e8a4338822ad2539a3876f58b15b590eb9e1f
|
https://github.com/libgit2/git2go/blob/bf1e8a4338822ad2539a3876f58b15b590eb9e1f/remote.go#L706-L734
|
151,151 |
libgit2/git2go
|
signature.go
|
Offset
|
func (v *Signature) Offset() int {
_, offset := v.When.Zone()
return offset / 60
}
|
go
|
func (v *Signature) Offset() int {
_, offset := v.When.Zone()
return offset / 60
}
|
[
"func",
"(",
"v",
"*",
"Signature",
")",
"Offset",
"(",
")",
"int",
"{",
"_",
",",
"offset",
":=",
"v",
".",
"When",
".",
"Zone",
"(",
")",
"\n",
"return",
"offset",
"/",
"60",
"\n",
"}"
] |
// Offset returns the time zone offset of v.When in minutes, which is what git wants.
|
[
"Offset",
"returns",
"the",
"time",
"zone",
"offset",
"of",
"v",
".",
"When",
"in",
"minutes",
"which",
"is",
"what",
"git",
"wants",
"."
] |
bf1e8a4338822ad2539a3876f58b15b590eb9e1f
|
https://github.com/libgit2/git2go/blob/bf1e8a4338822ad2539a3876f58b15b590eb9e1f/signature.go#L30-L33
|
151,152 |
libgit2/git2go
|
stash.go
|
Save
|
func (c *StashCollection) Save(
stasher *Signature, message string, flags StashFlag) (*Oid, error) {
oid := new(Oid)
stasherC, err := stasher.toC()
if err != nil {
return nil, err
}
defer C.git_signature_free(stasherC)
messageC := C.CString(message)
defer C.free(unsafe.Pointer(messageC))
runtime.LockOSThread()
defer runtime.UnlockOSThread()
ret := C.git_stash_save(
oid.toC(), c.repo.ptr,
stasherC, messageC, C.uint32_t(flags))
runtime.KeepAlive(c)
if ret < 0 {
return nil, MakeGitError(ret)
}
return oid, nil
}
|
go
|
func (c *StashCollection) Save(
stasher *Signature, message string, flags StashFlag) (*Oid, error) {
oid := new(Oid)
stasherC, err := stasher.toC()
if err != nil {
return nil, err
}
defer C.git_signature_free(stasherC)
messageC := C.CString(message)
defer C.free(unsafe.Pointer(messageC))
runtime.LockOSThread()
defer runtime.UnlockOSThread()
ret := C.git_stash_save(
oid.toC(), c.repo.ptr,
stasherC, messageC, C.uint32_t(flags))
runtime.KeepAlive(c)
if ret < 0 {
return nil, MakeGitError(ret)
}
return oid, nil
}
|
[
"func",
"(",
"c",
"*",
"StashCollection",
")",
"Save",
"(",
"stasher",
"*",
"Signature",
",",
"message",
"string",
",",
"flags",
"StashFlag",
")",
"(",
"*",
"Oid",
",",
"error",
")",
"{",
"oid",
":=",
"new",
"(",
"Oid",
")",
"\n\n",
"stasherC",
",",
"err",
":=",
"stasher",
".",
"toC",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"defer",
"C",
".",
"git_signature_free",
"(",
"stasherC",
")",
"\n\n",
"messageC",
":=",
"C",
".",
"CString",
"(",
"message",
")",
"\n",
"defer",
"C",
".",
"free",
"(",
"unsafe",
".",
"Pointer",
"(",
"messageC",
")",
")",
"\n\n",
"runtime",
".",
"LockOSThread",
"(",
")",
"\n",
"defer",
"runtime",
".",
"UnlockOSThread",
"(",
")",
"\n\n",
"ret",
":=",
"C",
".",
"git_stash_save",
"(",
"oid",
".",
"toC",
"(",
")",
",",
"c",
".",
"repo",
".",
"ptr",
",",
"stasherC",
",",
"messageC",
",",
"C",
".",
"uint32_t",
"(",
"flags",
")",
")",
"\n",
"runtime",
".",
"KeepAlive",
"(",
"c",
")",
"\n",
"if",
"ret",
"<",
"0",
"{",
"return",
"nil",
",",
"MakeGitError",
"(",
"ret",
")",
"\n",
"}",
"\n",
"return",
"oid",
",",
"nil",
"\n",
"}"
] |
// Save saves the local modifications to a new stash.
//
// Stasher is the identity of the person performing the stashing.
// Message is the optional description along with the stashed state.
// Flags control the stashing process and are given as bitwise OR.
|
[
"Save",
"saves",
"the",
"local",
"modifications",
"to",
"a",
"new",
"stash",
".",
"Stasher",
"is",
"the",
"identity",
"of",
"the",
"person",
"performing",
"the",
"stashing",
".",
"Message",
"is",
"the",
"optional",
"description",
"along",
"with",
"the",
"stashed",
"state",
".",
"Flags",
"control",
"the",
"stashing",
"process",
"and",
"are",
"given",
"as",
"bitwise",
"OR",
"."
] |
bf1e8a4338822ad2539a3876f58b15b590eb9e1f
|
https://github.com/libgit2/git2go/blob/bf1e8a4338822ad2539a3876f58b15b590eb9e1f/stash.go#L46-L71
|
151,153 |
libgit2/git2go
|
stash.go
|
DefaultStashApplyOptions
|
func DefaultStashApplyOptions() (StashApplyOptions, error) {
optsC := C.git_stash_apply_options{}
runtime.LockOSThread()
defer runtime.UnlockOSThread()
ecode := C.git_stash_apply_init_options(&optsC, C.GIT_STASH_APPLY_OPTIONS_VERSION)
if ecode < 0 {
return StashApplyOptions{}, MakeGitError(ecode)
}
return StashApplyOptions{
Flags: StashApplyFlag(optsC.flags),
CheckoutOptions: checkoutOptionsFromC(&optsC.checkout_options),
}, nil
}
|
go
|
func DefaultStashApplyOptions() (StashApplyOptions, error) {
optsC := C.git_stash_apply_options{}
runtime.LockOSThread()
defer runtime.UnlockOSThread()
ecode := C.git_stash_apply_init_options(&optsC, C.GIT_STASH_APPLY_OPTIONS_VERSION)
if ecode < 0 {
return StashApplyOptions{}, MakeGitError(ecode)
}
return StashApplyOptions{
Flags: StashApplyFlag(optsC.flags),
CheckoutOptions: checkoutOptionsFromC(&optsC.checkout_options),
}, nil
}
|
[
"func",
"DefaultStashApplyOptions",
"(",
")",
"(",
"StashApplyOptions",
",",
"error",
")",
"{",
"optsC",
":=",
"C",
".",
"git_stash_apply_options",
"{",
"}",
"\n\n",
"runtime",
".",
"LockOSThread",
"(",
")",
"\n",
"defer",
"runtime",
".",
"UnlockOSThread",
"(",
")",
"\n\n",
"ecode",
":=",
"C",
".",
"git_stash_apply_init_options",
"(",
"&",
"optsC",
",",
"C",
".",
"GIT_STASH_APPLY_OPTIONS_VERSION",
")",
"\n",
"if",
"ecode",
"<",
"0",
"{",
"return",
"StashApplyOptions",
"{",
"}",
",",
"MakeGitError",
"(",
"ecode",
")",
"\n",
"}",
"\n",
"return",
"StashApplyOptions",
"{",
"Flags",
":",
"StashApplyFlag",
"(",
"optsC",
".",
"flags",
")",
",",
"CheckoutOptions",
":",
"checkoutOptionsFromC",
"(",
"&",
"optsC",
".",
"checkout_options",
")",
",",
"}",
",",
"nil",
"\n",
"}"
] |
// DefaultStashApplyOptions initializes the structure with default values.
|
[
"DefaultStashApplyOptions",
"initializes",
"the",
"structure",
"with",
"default",
"values",
"."
] |
bf1e8a4338822ad2539a3876f58b15b590eb9e1f
|
https://github.com/libgit2/git2go/blob/bf1e8a4338822ad2539a3876f58b15b590eb9e1f/stash.go#L148-L162
|
151,154 |
libgit2/git2go
|
stash.go
|
Foreach
|
func (c *StashCollection) Foreach(callback StashCallback) error {
data := stashCallbackData{
Callback: callback,
}
handle := pointerHandles.Track(&data)
defer pointerHandles.Untrack(handle)
runtime.LockOSThread()
defer runtime.UnlockOSThread()
ret := C._go_git_stash_foreach(c.repo.ptr, handle)
runtime.KeepAlive(c)
if ret == C.GIT_EUSER {
return data.Error
}
if ret < 0 {
return MakeGitError(ret)
}
return nil
}
|
go
|
func (c *StashCollection) Foreach(callback StashCallback) error {
data := stashCallbackData{
Callback: callback,
}
handle := pointerHandles.Track(&data)
defer pointerHandles.Untrack(handle)
runtime.LockOSThread()
defer runtime.UnlockOSThread()
ret := C._go_git_stash_foreach(c.repo.ptr, handle)
runtime.KeepAlive(c)
if ret == C.GIT_EUSER {
return data.Error
}
if ret < 0 {
return MakeGitError(ret)
}
return nil
}
|
[
"func",
"(",
"c",
"*",
"StashCollection",
")",
"Foreach",
"(",
"callback",
"StashCallback",
")",
"error",
"{",
"data",
":=",
"stashCallbackData",
"{",
"Callback",
":",
"callback",
",",
"}",
"\n\n",
"handle",
":=",
"pointerHandles",
".",
"Track",
"(",
"&",
"data",
")",
"\n",
"defer",
"pointerHandles",
".",
"Untrack",
"(",
"handle",
")",
"\n\n",
"runtime",
".",
"LockOSThread",
"(",
")",
"\n",
"defer",
"runtime",
".",
"UnlockOSThread",
"(",
")",
"\n\n",
"ret",
":=",
"C",
".",
"_go_git_stash_foreach",
"(",
"c",
".",
"repo",
".",
"ptr",
",",
"handle",
")",
"\n",
"runtime",
".",
"KeepAlive",
"(",
"c",
")",
"\n",
"if",
"ret",
"==",
"C",
".",
"GIT_EUSER",
"{",
"return",
"data",
".",
"Error",
"\n",
"}",
"\n",
"if",
"ret",
"<",
"0",
"{",
"return",
"MakeGitError",
"(",
"ret",
")",
"\n",
"}",
"\n",
"return",
"nil",
"\n",
"}"
] |
// Foreach loops over all the stashed states and calls the callback
// for each one.
//
// If callback returns an error, this will stop looping.
|
[
"Foreach",
"loops",
"over",
"all",
"the",
"stashed",
"states",
"and",
"calls",
"the",
"callback",
"for",
"each",
"one",
".",
"If",
"callback",
"returns",
"an",
"error",
"this",
"will",
"stop",
"looping",
"."
] |
bf1e8a4338822ad2539a3876f58b15b590eb9e1f
|
https://github.com/libgit2/git2go/blob/bf1e8a4338822ad2539a3876f58b15b590eb9e1f/stash.go#L274-L294
|
151,155 |
libgit2/git2go
|
stash.go
|
Drop
|
func (c *StashCollection) Drop(index int) error {
runtime.LockOSThread()
defer runtime.UnlockOSThread()
ret := C.git_stash_drop(c.repo.ptr, C.size_t(index))
runtime.KeepAlive(c)
if ret < 0 {
return MakeGitError(ret)
}
return nil
}
|
go
|
func (c *StashCollection) Drop(index int) error {
runtime.LockOSThread()
defer runtime.UnlockOSThread()
ret := C.git_stash_drop(c.repo.ptr, C.size_t(index))
runtime.KeepAlive(c)
if ret < 0 {
return MakeGitError(ret)
}
return nil
}
|
[
"func",
"(",
"c",
"*",
"StashCollection",
")",
"Drop",
"(",
"index",
"int",
")",
"error",
"{",
"runtime",
".",
"LockOSThread",
"(",
")",
"\n",
"defer",
"runtime",
".",
"UnlockOSThread",
"(",
")",
"\n\n",
"ret",
":=",
"C",
".",
"git_stash_drop",
"(",
"c",
".",
"repo",
".",
"ptr",
",",
"C",
".",
"size_t",
"(",
"index",
")",
")",
"\n",
"runtime",
".",
"KeepAlive",
"(",
"c",
")",
"\n",
"if",
"ret",
"<",
"0",
"{",
"return",
"MakeGitError",
"(",
"ret",
")",
"\n",
"}",
"\n",
"return",
"nil",
"\n",
"}"
] |
// Drop removes a single stashed state from the stash list.
//
// 'index' is the position within the stash list. 0 points
// to the most recent stashed state.
//
// Returns error code ErrNotFound if there's no stashed
// state for the given index.
|
[
"Drop",
"removes",
"a",
"single",
"stashed",
"state",
"from",
"the",
"stash",
"list",
".",
"index",
"is",
"the",
"position",
"within",
"the",
"stash",
"list",
".",
"0",
"points",
"to",
"the",
"most",
"recent",
"stashed",
"state",
".",
"Returns",
"error",
"code",
"ErrNotFound",
"if",
"there",
"s",
"no",
"stashed",
"state",
"for",
"the",
"given",
"index",
"."
] |
bf1e8a4338822ad2539a3876f58b15b590eb9e1f
|
https://github.com/libgit2/git2go/blob/bf1e8a4338822ad2539a3876f58b15b590eb9e1f/stash.go#L303-L313
|
151,156 |
libgit2/git2go
|
handles.go
|
Track
|
func (v *HandleList) Track(pointer interface{}) unsafe.Pointer {
handle := C.malloc(1)
v.Lock()
v.handles[handle] = pointer
v.Unlock()
return handle
}
|
go
|
func (v *HandleList) Track(pointer interface{}) unsafe.Pointer {
handle := C.malloc(1)
v.Lock()
v.handles[handle] = pointer
v.Unlock()
return handle
}
|
[
"func",
"(",
"v",
"*",
"HandleList",
")",
"Track",
"(",
"pointer",
"interface",
"{",
"}",
")",
"unsafe",
".",
"Pointer",
"{",
"handle",
":=",
"C",
".",
"malloc",
"(",
"1",
")",
"\n\n",
"v",
".",
"Lock",
"(",
")",
"\n",
"v",
".",
"handles",
"[",
"handle",
"]",
"=",
"pointer",
"\n",
"v",
".",
"Unlock",
"(",
")",
"\n\n",
"return",
"handle",
"\n",
"}"
] |
// Track adds the given pointer to the list of pointers to track and
// returns a pointer value which can be passed to C as an opaque
// pointer.
|
[
"Track",
"adds",
"the",
"given",
"pointer",
"to",
"the",
"list",
"of",
"pointers",
"to",
"track",
"and",
"returns",
"a",
"pointer",
"value",
"which",
"can",
"be",
"passed",
"to",
"C",
"as",
"an",
"opaque",
"pointer",
"."
] |
bf1e8a4338822ad2539a3876f58b15b590eb9e1f
|
https://github.com/libgit2/git2go/blob/bf1e8a4338822ad2539a3876f58b15b590eb9e1f/handles.go#L28-L36
|
151,157 |
libgit2/git2go
|
handles.go
|
Untrack
|
func (v *HandleList) Untrack(handle unsafe.Pointer) {
v.Lock()
delete(v.handles, handle)
C.free(handle)
v.Unlock()
}
|
go
|
func (v *HandleList) Untrack(handle unsafe.Pointer) {
v.Lock()
delete(v.handles, handle)
C.free(handle)
v.Unlock()
}
|
[
"func",
"(",
"v",
"*",
"HandleList",
")",
"Untrack",
"(",
"handle",
"unsafe",
".",
"Pointer",
")",
"{",
"v",
".",
"Lock",
"(",
")",
"\n",
"delete",
"(",
"v",
".",
"handles",
",",
"handle",
")",
"\n",
"C",
".",
"free",
"(",
"handle",
")",
"\n",
"v",
".",
"Unlock",
"(",
")",
"\n",
"}"
] |
// Untrack stops tracking the pointer given by the handle
|
[
"Untrack",
"stops",
"tracking",
"the",
"pointer",
"given",
"by",
"the",
"handle"
] |
bf1e8a4338822ad2539a3876f58b15b590eb9e1f
|
https://github.com/libgit2/git2go/blob/bf1e8a4338822ad2539a3876f58b15b590eb9e1f/handles.go#L39-L44
|
151,158 |
libgit2/git2go
|
handles.go
|
Get
|
func (v *HandleList) Get(handle unsafe.Pointer) interface{} {
v.RLock()
defer v.RUnlock()
ptr, ok := v.handles[handle]
if !ok {
panic(fmt.Sprintf("invalid pointer handle: %p", handle))
}
return ptr
}
|
go
|
func (v *HandleList) Get(handle unsafe.Pointer) interface{} {
v.RLock()
defer v.RUnlock()
ptr, ok := v.handles[handle]
if !ok {
panic(fmt.Sprintf("invalid pointer handle: %p", handle))
}
return ptr
}
|
[
"func",
"(",
"v",
"*",
"HandleList",
")",
"Get",
"(",
"handle",
"unsafe",
".",
"Pointer",
")",
"interface",
"{",
"}",
"{",
"v",
".",
"RLock",
"(",
")",
"\n",
"defer",
"v",
".",
"RUnlock",
"(",
")",
"\n\n",
"ptr",
",",
"ok",
":=",
"v",
".",
"handles",
"[",
"handle",
"]",
"\n",
"if",
"!",
"ok",
"{",
"panic",
"(",
"fmt",
".",
"Sprintf",
"(",
"\"",
"\"",
",",
"handle",
")",
")",
"\n",
"}",
"\n\n",
"return",
"ptr",
"\n",
"}"
] |
// Get retrieves the pointer from the given handle
|
[
"Get",
"retrieves",
"the",
"pointer",
"from",
"the",
"given",
"handle"
] |
bf1e8a4338822ad2539a3876f58b15b590eb9e1f
|
https://github.com/libgit2/git2go/blob/bf1e8a4338822ad2539a3876f58b15b590eb9e1f/handles.go#L47-L57
|
151,159 |
libgit2/git2go
|
index.go
|
NewIndex
|
func NewIndex() (*Index, error) {
var ptr *C.git_index
runtime.LockOSThread()
defer runtime.UnlockOSThread()
if err := C.git_index_new(&ptr); err < 0 {
return nil, MakeGitError(err)
}
return newIndexFromC(ptr, nil), nil
}
|
go
|
func NewIndex() (*Index, error) {
var ptr *C.git_index
runtime.LockOSThread()
defer runtime.UnlockOSThread()
if err := C.git_index_new(&ptr); err < 0 {
return nil, MakeGitError(err)
}
return newIndexFromC(ptr, nil), nil
}
|
[
"func",
"NewIndex",
"(",
")",
"(",
"*",
"Index",
",",
"error",
")",
"{",
"var",
"ptr",
"*",
"C",
".",
"git_index",
"\n\n",
"runtime",
".",
"LockOSThread",
"(",
")",
"\n",
"defer",
"runtime",
".",
"UnlockOSThread",
"(",
")",
"\n\n",
"if",
"err",
":=",
"C",
".",
"git_index_new",
"(",
"&",
"ptr",
")",
";",
"err",
"<",
"0",
"{",
"return",
"nil",
",",
"MakeGitError",
"(",
"err",
")",
"\n",
"}",
"\n\n",
"return",
"newIndexFromC",
"(",
"ptr",
",",
"nil",
")",
",",
"nil",
"\n",
"}"
] |
// NewIndex allocates a new index. It won't be associated with any
// file on the filesystem or repository
|
[
"NewIndex",
"allocates",
"a",
"new",
"index",
".",
"It",
"won",
"t",
"be",
"associated",
"with",
"any",
"file",
"on",
"the",
"filesystem",
"or",
"repository"
] |
bf1e8a4338822ad2539a3876f58b15b590eb9e1f
|
https://github.com/libgit2/git2go/blob/bf1e8a4338822ad2539a3876f58b15b590eb9e1f/index.go#L109-L120
|
151,160 |
libgit2/git2go
|
index.go
|
Path
|
func (v *Index) Path() string {
ret := C.GoString(C.git_index_path(v.ptr))
runtime.KeepAlive(v)
return ret
}
|
go
|
func (v *Index) Path() string {
ret := C.GoString(C.git_index_path(v.ptr))
runtime.KeepAlive(v)
return ret
}
|
[
"func",
"(",
"v",
"*",
"Index",
")",
"Path",
"(",
")",
"string",
"{",
"ret",
":=",
"C",
".",
"GoString",
"(",
"C",
".",
"git_index_path",
"(",
"v",
".",
"ptr",
")",
")",
"\n",
"runtime",
".",
"KeepAlive",
"(",
"v",
")",
"\n",
"return",
"ret",
"\n",
"}"
] |
// Path returns the index' path on disk or an empty string if it
// exists only in memory.
|
[
"Path",
"returns",
"the",
"index",
"path",
"on",
"disk",
"or",
"an",
"empty",
"string",
"if",
"it",
"exists",
"only",
"in",
"memory",
"."
] |
bf1e8a4338822ad2539a3876f58b15b590eb9e1f
|
https://github.com/libgit2/git2go/blob/bf1e8a4338822ad2539a3876f58b15b590eb9e1f/index.go#L142-L146
|
151,161 |
libgit2/git2go
|
index.go
|
Clear
|
func (v *Index) Clear() error {
runtime.LockOSThread()
defer runtime.UnlockOSThread()
err := C.git_index_clear(v.ptr)
runtime.KeepAlive(v)
if err < 0 {
return MakeGitError(err)
}
return nil
}
|
go
|
func (v *Index) Clear() error {
runtime.LockOSThread()
defer runtime.UnlockOSThread()
err := C.git_index_clear(v.ptr)
runtime.KeepAlive(v)
if err < 0 {
return MakeGitError(err)
}
return nil
}
|
[
"func",
"(",
"v",
"*",
"Index",
")",
"Clear",
"(",
")",
"error",
"{",
"runtime",
".",
"LockOSThread",
"(",
")",
"\n",
"defer",
"runtime",
".",
"UnlockOSThread",
"(",
")",
"\n\n",
"err",
":=",
"C",
".",
"git_index_clear",
"(",
"v",
".",
"ptr",
")",
"\n",
"runtime",
".",
"KeepAlive",
"(",
"v",
")",
"\n",
"if",
"err",
"<",
"0",
"{",
"return",
"MakeGitError",
"(",
"err",
")",
"\n",
"}",
"\n",
"return",
"nil",
"\n",
"}"
] |
// Clear clears the index object in memory; changes must be explicitly
// written to disk for them to take effect persistently
|
[
"Clear",
"clears",
"the",
"index",
"object",
"in",
"memory",
";",
"changes",
"must",
"be",
"explicitly",
"written",
"to",
"disk",
"for",
"them",
"to",
"take",
"effect",
"persistently"
] |
bf1e8a4338822ad2539a3876f58b15b590eb9e1f
|
https://github.com/libgit2/git2go/blob/bf1e8a4338822ad2539a3876f58b15b590eb9e1f/index.go#L150-L160
|
151,162 |
libgit2/git2go
|
index.go
|
Add
|
func (v *Index) Add(entry *IndexEntry) error {
var centry C.git_index_entry
populateCIndexEntry(entry, ¢ry)
defer freeCIndexEntry(¢ry)
runtime.LockOSThread()
defer runtime.UnlockOSThread()
err := C.git_index_add(v.ptr, ¢ry)
runtime.KeepAlive(v)
if err < 0 {
return MakeGitError(err)
}
return nil
}
|
go
|
func (v *Index) Add(entry *IndexEntry) error {
var centry C.git_index_entry
populateCIndexEntry(entry, ¢ry)
defer freeCIndexEntry(¢ry)
runtime.LockOSThread()
defer runtime.UnlockOSThread()
err := C.git_index_add(v.ptr, ¢ry)
runtime.KeepAlive(v)
if err < 0 {
return MakeGitError(err)
}
return nil
}
|
[
"func",
"(",
"v",
"*",
"Index",
")",
"Add",
"(",
"entry",
"*",
"IndexEntry",
")",
"error",
"{",
"var",
"centry",
"C",
".",
"git_index_entry",
"\n\n",
"populateCIndexEntry",
"(",
"entry",
",",
"&",
"centry",
")",
"\n",
"defer",
"freeCIndexEntry",
"(",
"&",
"centry",
")",
"\n\n",
"runtime",
".",
"LockOSThread",
"(",
")",
"\n",
"defer",
"runtime",
".",
"UnlockOSThread",
"(",
")",
"\n\n",
"err",
":=",
"C",
".",
"git_index_add",
"(",
"v",
".",
"ptr",
",",
"&",
"centry",
")",
"\n",
"runtime",
".",
"KeepAlive",
"(",
"v",
")",
"\n",
"if",
"err",
"<",
"0",
"{",
"return",
"MakeGitError",
"(",
"err",
")",
"\n",
"}",
"\n\n",
"return",
"nil",
"\n",
"}"
] |
// Add adds or replaces the given entry to the index, making a copy of
// the data
|
[
"Add",
"adds",
"or",
"replaces",
"the",
"given",
"entry",
"to",
"the",
"index",
"making",
"a",
"copy",
"of",
"the",
"data"
] |
bf1e8a4338822ad2539a3876f58b15b590eb9e1f
|
https://github.com/libgit2/git2go/blob/bf1e8a4338822ad2539a3876f58b15b590eb9e1f/index.go#L164-L180
|
151,163 |
libgit2/git2go
|
index.go
|
RemoveDirectory
|
func (v *Index) RemoveDirectory(dir string, stage int) error {
cstr := C.CString(dir)
defer C.free(unsafe.Pointer(cstr))
runtime.LockOSThread()
defer runtime.UnlockOSThread()
ret := C.git_index_remove_directory(v.ptr, cstr, C.int(stage))
runtime.KeepAlive(v)
if ret < 0 {
return MakeGitError(ret)
}
return nil
}
|
go
|
func (v *Index) RemoveDirectory(dir string, stage int) error {
cstr := C.CString(dir)
defer C.free(unsafe.Pointer(cstr))
runtime.LockOSThread()
defer runtime.UnlockOSThread()
ret := C.git_index_remove_directory(v.ptr, cstr, C.int(stage))
runtime.KeepAlive(v)
if ret < 0 {
return MakeGitError(ret)
}
return nil
}
|
[
"func",
"(",
"v",
"*",
"Index",
")",
"RemoveDirectory",
"(",
"dir",
"string",
",",
"stage",
"int",
")",
"error",
"{",
"cstr",
":=",
"C",
".",
"CString",
"(",
"dir",
")",
"\n",
"defer",
"C",
".",
"free",
"(",
"unsafe",
".",
"Pointer",
"(",
"cstr",
")",
")",
"\n\n",
"runtime",
".",
"LockOSThread",
"(",
")",
"\n",
"defer",
"runtime",
".",
"UnlockOSThread",
"(",
")",
"\n\n",
"ret",
":=",
"C",
".",
"git_index_remove_directory",
"(",
"v",
".",
"ptr",
",",
"cstr",
",",
"C",
".",
"int",
"(",
"stage",
")",
")",
"\n",
"runtime",
".",
"KeepAlive",
"(",
"v",
")",
"\n",
"if",
"ret",
"<",
"0",
"{",
"return",
"MakeGitError",
"(",
"ret",
")",
"\n",
"}",
"\n\n",
"return",
"nil",
"\n",
"}"
] |
// RemoveDirectory removes all entries from the index under a given directory.
|
[
"RemoveDirectory",
"removes",
"all",
"entries",
"from",
"the",
"index",
"under",
"a",
"given",
"directory",
"."
] |
bf1e8a4338822ad2539a3876f58b15b590eb9e1f
|
https://github.com/libgit2/git2go/blob/bf1e8a4338822ad2539a3876f58b15b590eb9e1f/index.go#L306-L320
|
151,164 |
libgit2/git2go
|
index.go
|
ReadTree
|
func (v *Index) ReadTree(tree *Tree) error {
runtime.LockOSThread()
defer runtime.UnlockOSThread()
ret := C.git_index_read_tree(v.ptr, tree.cast_ptr)
runtime.KeepAlive(v)
runtime.KeepAlive(tree)
if ret < 0 {
return MakeGitError(ret)
}
return nil
}
|
go
|
func (v *Index) ReadTree(tree *Tree) error {
runtime.LockOSThread()
defer runtime.UnlockOSThread()
ret := C.git_index_read_tree(v.ptr, tree.cast_ptr)
runtime.KeepAlive(v)
runtime.KeepAlive(tree)
if ret < 0 {
return MakeGitError(ret)
}
return nil
}
|
[
"func",
"(",
"v",
"*",
"Index",
")",
"ReadTree",
"(",
"tree",
"*",
"Tree",
")",
"error",
"{",
"runtime",
".",
"LockOSThread",
"(",
")",
"\n",
"defer",
"runtime",
".",
"UnlockOSThread",
"(",
")",
"\n\n",
"ret",
":=",
"C",
".",
"git_index_read_tree",
"(",
"v",
".",
"ptr",
",",
"tree",
".",
"cast_ptr",
")",
"\n",
"runtime",
".",
"KeepAlive",
"(",
"v",
")",
"\n",
"runtime",
".",
"KeepAlive",
"(",
"tree",
")",
"\n",
"if",
"ret",
"<",
"0",
"{",
"return",
"MakeGitError",
"(",
"ret",
")",
"\n",
"}",
"\n\n",
"return",
"nil",
"\n",
"}"
] |
// ReadTree replaces the contents of the index with those of the given
// tree
|
[
"ReadTree",
"replaces",
"the",
"contents",
"of",
"the",
"index",
"with",
"those",
"of",
"the",
"given",
"tree"
] |
bf1e8a4338822ad2539a3876f58b15b590eb9e1f
|
https://github.com/libgit2/git2go/blob/bf1e8a4338822ad2539a3876f58b15b590eb9e1f/index.go#L340-L352
|
151,165 |
libgit2/git2go
|
describe.go
|
DefaultDescribeOptions
|
func DefaultDescribeOptions() (DescribeOptions, error) {
runtime.LockOSThread()
defer runtime.UnlockOSThread()
opts := C.git_describe_options{}
ecode := C.git_describe_init_options(&opts, C.GIT_DESCRIBE_OPTIONS_VERSION)
if ecode < 0 {
return DescribeOptions{}, MakeGitError(ecode)
}
return DescribeOptions{
MaxCandidatesTags: uint(opts.max_candidates_tags),
Strategy: DescribeOptionsStrategy(opts.describe_strategy),
}, nil
}
|
go
|
func DefaultDescribeOptions() (DescribeOptions, error) {
runtime.LockOSThread()
defer runtime.UnlockOSThread()
opts := C.git_describe_options{}
ecode := C.git_describe_init_options(&opts, C.GIT_DESCRIBE_OPTIONS_VERSION)
if ecode < 0 {
return DescribeOptions{}, MakeGitError(ecode)
}
return DescribeOptions{
MaxCandidatesTags: uint(opts.max_candidates_tags),
Strategy: DescribeOptionsStrategy(opts.describe_strategy),
}, nil
}
|
[
"func",
"DefaultDescribeOptions",
"(",
")",
"(",
"DescribeOptions",
",",
"error",
")",
"{",
"runtime",
".",
"LockOSThread",
"(",
")",
"\n",
"defer",
"runtime",
".",
"UnlockOSThread",
"(",
")",
"\n\n",
"opts",
":=",
"C",
".",
"git_describe_options",
"{",
"}",
"\n",
"ecode",
":=",
"C",
".",
"git_describe_init_options",
"(",
"&",
"opts",
",",
"C",
".",
"GIT_DESCRIBE_OPTIONS_VERSION",
")",
"\n",
"if",
"ecode",
"<",
"0",
"{",
"return",
"DescribeOptions",
"{",
"}",
",",
"MakeGitError",
"(",
"ecode",
")",
"\n",
"}",
"\n\n",
"return",
"DescribeOptions",
"{",
"MaxCandidatesTags",
":",
"uint",
"(",
"opts",
".",
"max_candidates_tags",
")",
",",
"Strategy",
":",
"DescribeOptionsStrategy",
"(",
"opts",
".",
"describe_strategy",
")",
",",
"}",
",",
"nil",
"\n",
"}"
] |
// DefaultDescribeOptions returns default options for the describe operation.
|
[
"DefaultDescribeOptions",
"returns",
"default",
"options",
"for",
"the",
"describe",
"operation",
"."
] |
bf1e8a4338822ad2539a3876f58b15b590eb9e1f
|
https://github.com/libgit2/git2go/blob/bf1e8a4338822ad2539a3876f58b15b590eb9e1f/describe.go#L41-L55
|
151,166 |
libgit2/git2go
|
describe.go
|
DefaultDescribeFormatOptions
|
func DefaultDescribeFormatOptions() (DescribeFormatOptions, error) {
runtime.LockOSThread()
defer runtime.UnlockOSThread()
opts := C.git_describe_format_options{}
ecode := C.git_describe_init_format_options(&opts, C.GIT_DESCRIBE_FORMAT_OPTIONS_VERSION)
if ecode < 0 {
return DescribeFormatOptions{}, MakeGitError(ecode)
}
return DescribeFormatOptions{
AbbreviatedSize: uint(opts.abbreviated_size),
AlwaysUseLongFormat: opts.always_use_long_format == 1,
}, nil
}
|
go
|
func DefaultDescribeFormatOptions() (DescribeFormatOptions, error) {
runtime.LockOSThread()
defer runtime.UnlockOSThread()
opts := C.git_describe_format_options{}
ecode := C.git_describe_init_format_options(&opts, C.GIT_DESCRIBE_FORMAT_OPTIONS_VERSION)
if ecode < 0 {
return DescribeFormatOptions{}, MakeGitError(ecode)
}
return DescribeFormatOptions{
AbbreviatedSize: uint(opts.abbreviated_size),
AlwaysUseLongFormat: opts.always_use_long_format == 1,
}, nil
}
|
[
"func",
"DefaultDescribeFormatOptions",
"(",
")",
"(",
"DescribeFormatOptions",
",",
"error",
")",
"{",
"runtime",
".",
"LockOSThread",
"(",
")",
"\n",
"defer",
"runtime",
".",
"UnlockOSThread",
"(",
")",
"\n\n",
"opts",
":=",
"C",
".",
"git_describe_format_options",
"{",
"}",
"\n",
"ecode",
":=",
"C",
".",
"git_describe_init_format_options",
"(",
"&",
"opts",
",",
"C",
".",
"GIT_DESCRIBE_FORMAT_OPTIONS_VERSION",
")",
"\n",
"if",
"ecode",
"<",
"0",
"{",
"return",
"DescribeFormatOptions",
"{",
"}",
",",
"MakeGitError",
"(",
"ecode",
")",
"\n",
"}",
"\n\n",
"return",
"DescribeFormatOptions",
"{",
"AbbreviatedSize",
":",
"uint",
"(",
"opts",
".",
"abbreviated_size",
")",
",",
"AlwaysUseLongFormat",
":",
"opts",
".",
"always_use_long_format",
"==",
"1",
",",
"}",
",",
"nil",
"\n",
"}"
] |
// DefaultDescribeFormatOptions returns default options for formatting
// the output.
|
[
"DefaultDescribeFormatOptions",
"returns",
"default",
"options",
"for",
"formatting",
"the",
"output",
"."
] |
bf1e8a4338822ad2539a3876f58b15b590eb9e1f
|
https://github.com/libgit2/git2go/blob/bf1e8a4338822ad2539a3876f58b15b590eb9e1f/describe.go#L75-L89
|
151,167 |
libgit2/git2go
|
describe.go
|
Format
|
func (result *DescribeResult) Format(opts *DescribeFormatOptions) (string, error) {
resultBuf := C.git_buf{}
var cFormatOpts *C.git_describe_format_options
if opts != nil {
cDirtySuffix := C.CString(opts.DirtySuffix)
defer C.free(unsafe.Pointer(cDirtySuffix))
cFormatOpts = &C.git_describe_format_options{
version: C.GIT_DESCRIBE_FORMAT_OPTIONS_VERSION,
abbreviated_size: C.uint(opts.AbbreviatedSize),
always_use_long_format: cbool(opts.AlwaysUseLongFormat),
dirty_suffix: cDirtySuffix,
}
}
runtime.LockOSThread()
defer runtime.UnlockOSThread()
ecode := C.git_describe_format(&resultBuf, result.ptr, cFormatOpts)
runtime.KeepAlive(result)
if ecode < 0 {
return "", MakeGitError(ecode)
}
defer C.git_buf_dispose(&resultBuf)
return C.GoString(resultBuf.ptr), nil
}
|
go
|
func (result *DescribeResult) Format(opts *DescribeFormatOptions) (string, error) {
resultBuf := C.git_buf{}
var cFormatOpts *C.git_describe_format_options
if opts != nil {
cDirtySuffix := C.CString(opts.DirtySuffix)
defer C.free(unsafe.Pointer(cDirtySuffix))
cFormatOpts = &C.git_describe_format_options{
version: C.GIT_DESCRIBE_FORMAT_OPTIONS_VERSION,
abbreviated_size: C.uint(opts.AbbreviatedSize),
always_use_long_format: cbool(opts.AlwaysUseLongFormat),
dirty_suffix: cDirtySuffix,
}
}
runtime.LockOSThread()
defer runtime.UnlockOSThread()
ecode := C.git_describe_format(&resultBuf, result.ptr, cFormatOpts)
runtime.KeepAlive(result)
if ecode < 0 {
return "", MakeGitError(ecode)
}
defer C.git_buf_dispose(&resultBuf)
return C.GoString(resultBuf.ptr), nil
}
|
[
"func",
"(",
"result",
"*",
"DescribeResult",
")",
"Format",
"(",
"opts",
"*",
"DescribeFormatOptions",
")",
"(",
"string",
",",
"error",
")",
"{",
"resultBuf",
":=",
"C",
".",
"git_buf",
"{",
"}",
"\n\n",
"var",
"cFormatOpts",
"*",
"C",
".",
"git_describe_format_options",
"\n",
"if",
"opts",
"!=",
"nil",
"{",
"cDirtySuffix",
":=",
"C",
".",
"CString",
"(",
"opts",
".",
"DirtySuffix",
")",
"\n",
"defer",
"C",
".",
"free",
"(",
"unsafe",
".",
"Pointer",
"(",
"cDirtySuffix",
")",
")",
"\n\n",
"cFormatOpts",
"=",
"&",
"C",
".",
"git_describe_format_options",
"{",
"version",
":",
"C",
".",
"GIT_DESCRIBE_FORMAT_OPTIONS_VERSION",
",",
"abbreviated_size",
":",
"C",
".",
"uint",
"(",
"opts",
".",
"AbbreviatedSize",
")",
",",
"always_use_long_format",
":",
"cbool",
"(",
"opts",
".",
"AlwaysUseLongFormat",
")",
",",
"dirty_suffix",
":",
"cDirtySuffix",
",",
"}",
"\n",
"}",
"\n\n",
"runtime",
".",
"LockOSThread",
"(",
")",
"\n",
"defer",
"runtime",
".",
"UnlockOSThread",
"(",
")",
"\n\n",
"ecode",
":=",
"C",
".",
"git_describe_format",
"(",
"&",
"resultBuf",
",",
"result",
".",
"ptr",
",",
"cFormatOpts",
")",
"\n",
"runtime",
".",
"KeepAlive",
"(",
"result",
")",
"\n",
"if",
"ecode",
"<",
"0",
"{",
"return",
"\"",
"\"",
",",
"MakeGitError",
"(",
"ecode",
")",
"\n",
"}",
"\n",
"defer",
"C",
".",
"git_buf_dispose",
"(",
"&",
"resultBuf",
")",
"\n\n",
"return",
"C",
".",
"GoString",
"(",
"resultBuf",
".",
"ptr",
")",
",",
"nil",
"\n",
"}"
] |
// Format prints the DescribeResult as a string.
|
[
"Format",
"prints",
"the",
"DescribeResult",
"as",
"a",
"string",
"."
] |
bf1e8a4338822ad2539a3876f58b15b590eb9e1f
|
https://github.com/libgit2/git2go/blob/bf1e8a4338822ad2539a3876f58b15b590eb9e1f/describe.go#L191-L218
|
151,168 |
libgit2/git2go
|
describe.go
|
Free
|
func (result *DescribeResult) Free() {
runtime.SetFinalizer(result, nil)
C.git_describe_result_free(result.ptr)
result.ptr = nil
}
|
go
|
func (result *DescribeResult) Free() {
runtime.SetFinalizer(result, nil)
C.git_describe_result_free(result.ptr)
result.ptr = nil
}
|
[
"func",
"(",
"result",
"*",
"DescribeResult",
")",
"Free",
"(",
")",
"{",
"runtime",
".",
"SetFinalizer",
"(",
"result",
",",
"nil",
")",
"\n",
"C",
".",
"git_describe_result_free",
"(",
"result",
".",
"ptr",
")",
"\n",
"result",
".",
"ptr",
"=",
"nil",
"\n",
"}"
] |
// Free cleans up the C reference.
|
[
"Free",
"cleans",
"up",
"the",
"C",
"reference",
"."
] |
bf1e8a4338822ad2539a3876f58b15b590eb9e1f
|
https://github.com/libgit2/git2go/blob/bf1e8a4338822ad2539a3876f58b15b590eb9e1f/describe.go#L221-L225
|
151,169 |
libgit2/git2go
|
tag.go
|
Foreach
|
func (c *TagsCollection) Foreach(callback TagForeachCallback) error {
data := tagForeachData{
callback: callback,
err: nil,
}
handle := pointerHandles.Track(&data)
defer pointerHandles.Untrack(handle)
runtime.LockOSThread()
defer runtime.UnlockOSThread()
err := C._go_git_tag_foreach(c.repo.ptr, handle)
runtime.KeepAlive(c)
if err == C.GIT_EUSER {
return data.err
}
if err < 0 {
return MakeGitError(err)
}
return nil
}
|
go
|
func (c *TagsCollection) Foreach(callback TagForeachCallback) error {
data := tagForeachData{
callback: callback,
err: nil,
}
handle := pointerHandles.Track(&data)
defer pointerHandles.Untrack(handle)
runtime.LockOSThread()
defer runtime.UnlockOSThread()
err := C._go_git_tag_foreach(c.repo.ptr, handle)
runtime.KeepAlive(c)
if err == C.GIT_EUSER {
return data.err
}
if err < 0 {
return MakeGitError(err)
}
return nil
}
|
[
"func",
"(",
"c",
"*",
"TagsCollection",
")",
"Foreach",
"(",
"callback",
"TagForeachCallback",
")",
"error",
"{",
"data",
":=",
"tagForeachData",
"{",
"callback",
":",
"callback",
",",
"err",
":",
"nil",
",",
"}",
"\n\n",
"handle",
":=",
"pointerHandles",
".",
"Track",
"(",
"&",
"data",
")",
"\n",
"defer",
"pointerHandles",
".",
"Untrack",
"(",
"handle",
")",
"\n\n",
"runtime",
".",
"LockOSThread",
"(",
")",
"\n",
"defer",
"runtime",
".",
"UnlockOSThread",
"(",
")",
"\n\n",
"err",
":=",
"C",
".",
"_go_git_tag_foreach",
"(",
"c",
".",
"repo",
".",
"ptr",
",",
"handle",
")",
"\n",
"runtime",
".",
"KeepAlive",
"(",
"c",
")",
"\n",
"if",
"err",
"==",
"C",
".",
"GIT_EUSER",
"{",
"return",
"data",
".",
"err",
"\n",
"}",
"\n",
"if",
"err",
"<",
"0",
"{",
"return",
"MakeGitError",
"(",
"err",
")",
"\n",
"}",
"\n\n",
"return",
"nil",
"\n",
"}"
] |
// Foreach calls the callback for each tag in the repository.
|
[
"Foreach",
"calls",
"the",
"callback",
"for",
"each",
"tag",
"in",
"the",
"repository",
"."
] |
bf1e8a4338822ad2539a3876f58b15b590eb9e1f
|
https://github.com/libgit2/git2go/blob/bf1e8a4338822ad2539a3876f58b15b590eb9e1f/tag.go#L223-L245
|
151,170 |
libgit2/git2go
|
reference.go
|
EnsureLog
|
func (c *ReferenceCollection) EnsureLog(name string) error {
cname := C.CString(name)
defer C.free(unsafe.Pointer(cname))
runtime.LockOSThread()
defer runtime.UnlockOSThread()
ret := C.git_reference_ensure_log(c.repo.ptr, cname)
runtime.KeepAlive(c)
if ret < 0 {
return MakeGitError(ret)
}
return nil
}
|
go
|
func (c *ReferenceCollection) EnsureLog(name string) error {
cname := C.CString(name)
defer C.free(unsafe.Pointer(cname))
runtime.LockOSThread()
defer runtime.UnlockOSThread()
ret := C.git_reference_ensure_log(c.repo.ptr, cname)
runtime.KeepAlive(c)
if ret < 0 {
return MakeGitError(ret)
}
return nil
}
|
[
"func",
"(",
"c",
"*",
"ReferenceCollection",
")",
"EnsureLog",
"(",
"name",
"string",
")",
"error",
"{",
"cname",
":=",
"C",
".",
"CString",
"(",
"name",
")",
"\n",
"defer",
"C",
".",
"free",
"(",
"unsafe",
".",
"Pointer",
"(",
"cname",
")",
")",
"\n\n",
"runtime",
".",
"LockOSThread",
"(",
")",
"\n",
"defer",
"runtime",
".",
"UnlockOSThread",
"(",
")",
"\n\n",
"ret",
":=",
"C",
".",
"git_reference_ensure_log",
"(",
"c",
".",
"repo",
".",
"ptr",
",",
"cname",
")",
"\n",
"runtime",
".",
"KeepAlive",
"(",
"c",
")",
"\n",
"if",
"ret",
"<",
"0",
"{",
"return",
"MakeGitError",
"(",
"ret",
")",
"\n",
"}",
"\n\n",
"return",
"nil",
"\n",
"}"
] |
// EnsureLog ensures that there is a reflog for the given reference
// name and creates an empty one if necessary.
|
[
"EnsureLog",
"ensures",
"that",
"there",
"is",
"a",
"reflog",
"for",
"the",
"given",
"reference",
"name",
"and",
"creates",
"an",
"empty",
"one",
"if",
"necessary",
"."
] |
bf1e8a4338822ad2539a3876f58b15b590eb9e1f
|
https://github.com/libgit2/git2go/blob/bf1e8a4338822ad2539a3876f58b15b590eb9e1f/reference.go#L103-L117
|
151,171 |
libgit2/git2go
|
reference.go
|
HasLog
|
func (c *ReferenceCollection) HasLog(name string) (bool, error) {
cname := C.CString(name)
defer C.free(unsafe.Pointer(cname))
runtime.LockOSThread()
defer runtime.UnlockOSThread()
ret := C.git_reference_has_log(c.repo.ptr, cname)
runtime.KeepAlive(c)
if ret < 0 {
return false, MakeGitError(ret)
}
return ret == 1, nil
}
|
go
|
func (c *ReferenceCollection) HasLog(name string) (bool, error) {
cname := C.CString(name)
defer C.free(unsafe.Pointer(cname))
runtime.LockOSThread()
defer runtime.UnlockOSThread()
ret := C.git_reference_has_log(c.repo.ptr, cname)
runtime.KeepAlive(c)
if ret < 0 {
return false, MakeGitError(ret)
}
return ret == 1, nil
}
|
[
"func",
"(",
"c",
"*",
"ReferenceCollection",
")",
"HasLog",
"(",
"name",
"string",
")",
"(",
"bool",
",",
"error",
")",
"{",
"cname",
":=",
"C",
".",
"CString",
"(",
"name",
")",
"\n",
"defer",
"C",
".",
"free",
"(",
"unsafe",
".",
"Pointer",
"(",
"cname",
")",
")",
"\n\n",
"runtime",
".",
"LockOSThread",
"(",
")",
"\n",
"defer",
"runtime",
".",
"UnlockOSThread",
"(",
")",
"\n\n",
"ret",
":=",
"C",
".",
"git_reference_has_log",
"(",
"c",
".",
"repo",
".",
"ptr",
",",
"cname",
")",
"\n",
"runtime",
".",
"KeepAlive",
"(",
"c",
")",
"\n",
"if",
"ret",
"<",
"0",
"{",
"return",
"false",
",",
"MakeGitError",
"(",
"ret",
")",
"\n",
"}",
"\n\n",
"return",
"ret",
"==",
"1",
",",
"nil",
"\n",
"}"
] |
// HasLog returns whether there is a reflog for the given reference
// name
|
[
"HasLog",
"returns",
"whether",
"there",
"is",
"a",
"reflog",
"for",
"the",
"given",
"reference",
"name"
] |
bf1e8a4338822ad2539a3876f58b15b590eb9e1f
|
https://github.com/libgit2/git2go/blob/bf1e8a4338822ad2539a3876f58b15b590eb9e1f/reference.go#L121-L135
|
151,172 |
libgit2/git2go
|
reference.go
|
Dwim
|
func (c *ReferenceCollection) Dwim(name string) (*Reference, error) {
cname := C.CString(name)
defer C.free(unsafe.Pointer(cname))
runtime.LockOSThread()
defer runtime.UnlockOSThread()
var ptr *C.git_reference
ret := C.git_reference_dwim(&ptr, c.repo.ptr, cname)
runtime.KeepAlive(c)
if ret < 0 {
return nil, MakeGitError(ret)
}
return newReferenceFromC(ptr, c.repo), nil
}
|
go
|
func (c *ReferenceCollection) Dwim(name string) (*Reference, error) {
cname := C.CString(name)
defer C.free(unsafe.Pointer(cname))
runtime.LockOSThread()
defer runtime.UnlockOSThread()
var ptr *C.git_reference
ret := C.git_reference_dwim(&ptr, c.repo.ptr, cname)
runtime.KeepAlive(c)
if ret < 0 {
return nil, MakeGitError(ret)
}
return newReferenceFromC(ptr, c.repo), nil
}
|
[
"func",
"(",
"c",
"*",
"ReferenceCollection",
")",
"Dwim",
"(",
"name",
"string",
")",
"(",
"*",
"Reference",
",",
"error",
")",
"{",
"cname",
":=",
"C",
".",
"CString",
"(",
"name",
")",
"\n",
"defer",
"C",
".",
"free",
"(",
"unsafe",
".",
"Pointer",
"(",
"cname",
")",
")",
"\n\n",
"runtime",
".",
"LockOSThread",
"(",
")",
"\n",
"defer",
"runtime",
".",
"UnlockOSThread",
"(",
")",
"\n\n",
"var",
"ptr",
"*",
"C",
".",
"git_reference",
"\n",
"ret",
":=",
"C",
".",
"git_reference_dwim",
"(",
"&",
"ptr",
",",
"c",
".",
"repo",
".",
"ptr",
",",
"cname",
")",
"\n",
"runtime",
".",
"KeepAlive",
"(",
"c",
")",
"\n",
"if",
"ret",
"<",
"0",
"{",
"return",
"nil",
",",
"MakeGitError",
"(",
"ret",
")",
"\n",
"}",
"\n\n",
"return",
"newReferenceFromC",
"(",
"ptr",
",",
"c",
".",
"repo",
")",
",",
"nil",
"\n",
"}"
] |
// Dwim looks up a reference by DWIMing its short name
|
[
"Dwim",
"looks",
"up",
"a",
"reference",
"by",
"DWIMing",
"its",
"short",
"name"
] |
bf1e8a4338822ad2539a3876f58b15b590eb9e1f
|
https://github.com/libgit2/git2go/blob/bf1e8a4338822ad2539a3876f58b15b590eb9e1f/reference.go#L138-L153
|
151,173 |
libgit2/git2go
|
reference.go
|
Owner
|
func (v *Reference) Owner() *Repository {
return &Repository{
ptr: C.git_reference_owner(v.ptr),
}
}
|
go
|
func (v *Reference) Owner() *Repository {
return &Repository{
ptr: C.git_reference_owner(v.ptr),
}
}
|
[
"func",
"(",
"v",
"*",
"Reference",
")",
"Owner",
"(",
")",
"*",
"Repository",
"{",
"return",
"&",
"Repository",
"{",
"ptr",
":",
"C",
".",
"git_reference_owner",
"(",
"v",
".",
"ptr",
")",
",",
"}",
"\n",
"}"
] |
// Owner returns a weak reference to the repository which owns this
// reference.
|
[
"Owner",
"returns",
"a",
"weak",
"reference",
"to",
"the",
"repository",
"which",
"owns",
"this",
"reference",
"."
] |
bf1e8a4338822ad2539a3876f58b15b590eb9e1f
|
https://github.com/libgit2/git2go/blob/bf1e8a4338822ad2539a3876f58b15b590eb9e1f/reference.go#L298-L302
|
151,174 |
libgit2/git2go
|
reference.go
|
Cmp
|
func (v *Reference) Cmp(ref2 *Reference) int {
ret := int(C.git_reference_cmp(v.ptr, ref2.ptr))
runtime.KeepAlive(v)
runtime.KeepAlive(ref2)
return ret
}
|
go
|
func (v *Reference) Cmp(ref2 *Reference) int {
ret := int(C.git_reference_cmp(v.ptr, ref2.ptr))
runtime.KeepAlive(v)
runtime.KeepAlive(ref2)
return ret
}
|
[
"func",
"(",
"v",
"*",
"Reference",
")",
"Cmp",
"(",
"ref2",
"*",
"Reference",
")",
"int",
"{",
"ret",
":=",
"int",
"(",
"C",
".",
"git_reference_cmp",
"(",
"v",
".",
"ptr",
",",
"ref2",
".",
"ptr",
")",
")",
"\n",
"runtime",
".",
"KeepAlive",
"(",
"v",
")",
"\n",
"runtime",
".",
"KeepAlive",
"(",
"ref2",
")",
"\n",
"return",
"ret",
"\n",
"}"
] |
// Cmp compares v to ref2. It returns 0 on equality, otherwise a
// stable sorting.
|
[
"Cmp",
"compares",
"v",
"to",
"ref2",
".",
"It",
"returns",
"0",
"on",
"equality",
"otherwise",
"a",
"stable",
"sorting",
"."
] |
bf1e8a4338822ad2539a3876f58b15b590eb9e1f
|
https://github.com/libgit2/git2go/blob/bf1e8a4338822ad2539a3876f58b15b590eb9e1f/reference.go#L306-L311
|
151,175 |
libgit2/git2go
|
reference.go
|
Shorthand
|
func (v *Reference) Shorthand() string {
ret := C.GoString(C.git_reference_shorthand(v.ptr))
runtime.KeepAlive(v)
return ret
}
|
go
|
func (v *Reference) Shorthand() string {
ret := C.GoString(C.git_reference_shorthand(v.ptr))
runtime.KeepAlive(v)
return ret
}
|
[
"func",
"(",
"v",
"*",
"Reference",
")",
"Shorthand",
"(",
")",
"string",
"{",
"ret",
":=",
"C",
".",
"GoString",
"(",
"C",
".",
"git_reference_shorthand",
"(",
"v",
".",
"ptr",
")",
")",
"\n",
"runtime",
".",
"KeepAlive",
"(",
"v",
")",
"\n",
"return",
"ret",
"\n",
"}"
] |
// Shorthand returns a "human-readable" short reference name.
|
[
"Shorthand",
"returns",
"a",
"human",
"-",
"readable",
"short",
"reference",
"name",
"."
] |
bf1e8a4338822ad2539a3876f58b15b590eb9e1f
|
https://github.com/libgit2/git2go/blob/bf1e8a4338822ad2539a3876f58b15b590eb9e1f/reference.go#L314-L318
|
151,176 |
libgit2/git2go
|
reference.go
|
Name
|
func (v *Reference) Name() string {
ret := C.GoString(C.git_reference_name(v.ptr))
runtime.KeepAlive(v)
return ret
}
|
go
|
func (v *Reference) Name() string {
ret := C.GoString(C.git_reference_name(v.ptr))
runtime.KeepAlive(v)
return ret
}
|
[
"func",
"(",
"v",
"*",
"Reference",
")",
"Name",
"(",
")",
"string",
"{",
"ret",
":=",
"C",
".",
"GoString",
"(",
"C",
".",
"git_reference_name",
"(",
"v",
".",
"ptr",
")",
")",
"\n",
"runtime",
".",
"KeepAlive",
"(",
"v",
")",
"\n",
"return",
"ret",
"\n",
"}"
] |
// Name returns the full name of v.
|
[
"Name",
"returns",
"the",
"full",
"name",
"of",
"v",
"."
] |
bf1e8a4338822ad2539a3876f58b15b590eb9e1f
|
https://github.com/libgit2/git2go/blob/bf1e8a4338822ad2539a3876f58b15b590eb9e1f/reference.go#L321-L325
|
151,177 |
libgit2/git2go
|
reference.go
|
IsNote
|
func (v *Reference) IsNote() bool {
ret := C.git_reference_is_note(v.ptr) == 1
runtime.KeepAlive(v)
return ret
}
|
go
|
func (v *Reference) IsNote() bool {
ret := C.git_reference_is_note(v.ptr) == 1
runtime.KeepAlive(v)
return ret
}
|
[
"func",
"(",
"v",
"*",
"Reference",
")",
"IsNote",
"(",
")",
"bool",
"{",
"ret",
":=",
"C",
".",
"git_reference_is_note",
"(",
"v",
".",
"ptr",
")",
"==",
"1",
"\n",
"runtime",
".",
"KeepAlive",
"(",
"v",
")",
"\n",
"return",
"ret",
"\n",
"}"
] |
// IsNote checks if the reference is a note.
|
[
"IsNote",
"checks",
"if",
"the",
"reference",
"is",
"a",
"note",
"."
] |
bf1e8a4338822ad2539a3876f58b15b590eb9e1f
|
https://github.com/libgit2/git2go/blob/bf1e8a4338822ad2539a3876f58b15b590eb9e1f/reference.go#L352-L356
|
151,178 |
libgit2/git2go
|
reference.go
|
NewReferenceIterator
|
func (repo *Repository) NewReferenceIterator() (*ReferenceIterator, error) {
var ptr *C.git_reference_iterator
runtime.LockOSThread()
defer runtime.UnlockOSThread()
ret := C.git_reference_iterator_new(&ptr, repo.ptr)
if ret < 0 {
return nil, MakeGitError(ret)
}
return newReferenceIteratorFromC(ptr, repo), nil
}
|
go
|
func (repo *Repository) NewReferenceIterator() (*ReferenceIterator, error) {
var ptr *C.git_reference_iterator
runtime.LockOSThread()
defer runtime.UnlockOSThread()
ret := C.git_reference_iterator_new(&ptr, repo.ptr)
if ret < 0 {
return nil, MakeGitError(ret)
}
return newReferenceIteratorFromC(ptr, repo), nil
}
|
[
"func",
"(",
"repo",
"*",
"Repository",
")",
"NewReferenceIterator",
"(",
")",
"(",
"*",
"ReferenceIterator",
",",
"error",
")",
"{",
"var",
"ptr",
"*",
"C",
".",
"git_reference_iterator",
"\n\n",
"runtime",
".",
"LockOSThread",
"(",
")",
"\n",
"defer",
"runtime",
".",
"UnlockOSThread",
"(",
")",
"\n\n",
"ret",
":=",
"C",
".",
"git_reference_iterator_new",
"(",
"&",
"ptr",
",",
"repo",
".",
"ptr",
")",
"\n",
"if",
"ret",
"<",
"0",
"{",
"return",
"nil",
",",
"MakeGitError",
"(",
"ret",
")",
"\n",
"}",
"\n\n",
"return",
"newReferenceIteratorFromC",
"(",
"ptr",
",",
"repo",
")",
",",
"nil",
"\n",
"}"
] |
// NewReferenceIterator creates a new iterator over reference names
|
[
"NewReferenceIterator",
"creates",
"a",
"new",
"iterator",
"over",
"reference",
"names"
] |
bf1e8a4338822ad2539a3876f58b15b590eb9e1f
|
https://github.com/libgit2/git2go/blob/bf1e8a4338822ad2539a3876f58b15b590eb9e1f/reference.go#L373-L385
|
151,179 |
libgit2/git2go
|
reference.go
|
NewReferenceNameIterator
|
func (repo *Repository) NewReferenceNameIterator() (*ReferenceNameIterator, error) {
var ptr *C.git_reference_iterator
runtime.LockOSThread()
defer runtime.UnlockOSThread()
ret := C.git_reference_iterator_new(&ptr, repo.ptr)
if ret < 0 {
return nil, MakeGitError(ret)
}
iter := newReferenceIteratorFromC(ptr, repo)
return iter.Names(), nil
}
|
go
|
func (repo *Repository) NewReferenceNameIterator() (*ReferenceNameIterator, error) {
var ptr *C.git_reference_iterator
runtime.LockOSThread()
defer runtime.UnlockOSThread()
ret := C.git_reference_iterator_new(&ptr, repo.ptr)
if ret < 0 {
return nil, MakeGitError(ret)
}
iter := newReferenceIteratorFromC(ptr, repo)
return iter.Names(), nil
}
|
[
"func",
"(",
"repo",
"*",
"Repository",
")",
"NewReferenceNameIterator",
"(",
")",
"(",
"*",
"ReferenceNameIterator",
",",
"error",
")",
"{",
"var",
"ptr",
"*",
"C",
".",
"git_reference_iterator",
"\n\n",
"runtime",
".",
"LockOSThread",
"(",
")",
"\n",
"defer",
"runtime",
".",
"UnlockOSThread",
"(",
")",
"\n\n",
"ret",
":=",
"C",
".",
"git_reference_iterator_new",
"(",
"&",
"ptr",
",",
"repo",
".",
"ptr",
")",
"\n",
"if",
"ret",
"<",
"0",
"{",
"return",
"nil",
",",
"MakeGitError",
"(",
"ret",
")",
"\n",
"}",
"\n\n",
"iter",
":=",
"newReferenceIteratorFromC",
"(",
"ptr",
",",
"repo",
")",
"\n",
"return",
"iter",
".",
"Names",
"(",
")",
",",
"nil",
"\n",
"}"
] |
// NewReferenceIterator creates a new branch iterator over reference names
|
[
"NewReferenceIterator",
"creates",
"a",
"new",
"branch",
"iterator",
"over",
"reference",
"names"
] |
bf1e8a4338822ad2539a3876f58b15b590eb9e1f
|
https://github.com/libgit2/git2go/blob/bf1e8a4338822ad2539a3876f58b15b590eb9e1f/reference.go#L388-L401
|
151,180 |
libgit2/git2go
|
reference.go
|
NewReferenceIteratorGlob
|
func (repo *Repository) NewReferenceIteratorGlob(glob string) (*ReferenceIterator, error) {
cstr := C.CString(glob)
defer C.free(unsafe.Pointer(cstr))
var ptr *C.git_reference_iterator
runtime.LockOSThread()
defer runtime.UnlockOSThread()
ret := C.git_reference_iterator_glob_new(&ptr, repo.ptr, cstr)
if ret < 0 {
return nil, MakeGitError(ret)
}
return newReferenceIteratorFromC(ptr, repo), nil
}
|
go
|
func (repo *Repository) NewReferenceIteratorGlob(glob string) (*ReferenceIterator, error) {
cstr := C.CString(glob)
defer C.free(unsafe.Pointer(cstr))
var ptr *C.git_reference_iterator
runtime.LockOSThread()
defer runtime.UnlockOSThread()
ret := C.git_reference_iterator_glob_new(&ptr, repo.ptr, cstr)
if ret < 0 {
return nil, MakeGitError(ret)
}
return newReferenceIteratorFromC(ptr, repo), nil
}
|
[
"func",
"(",
"repo",
"*",
"Repository",
")",
"NewReferenceIteratorGlob",
"(",
"glob",
"string",
")",
"(",
"*",
"ReferenceIterator",
",",
"error",
")",
"{",
"cstr",
":=",
"C",
".",
"CString",
"(",
"glob",
")",
"\n",
"defer",
"C",
".",
"free",
"(",
"unsafe",
".",
"Pointer",
"(",
"cstr",
")",
")",
"\n",
"var",
"ptr",
"*",
"C",
".",
"git_reference_iterator",
"\n\n",
"runtime",
".",
"LockOSThread",
"(",
")",
"\n",
"defer",
"runtime",
".",
"UnlockOSThread",
"(",
")",
"\n\n",
"ret",
":=",
"C",
".",
"git_reference_iterator_glob_new",
"(",
"&",
"ptr",
",",
"repo",
".",
"ptr",
",",
"cstr",
")",
"\n",
"if",
"ret",
"<",
"0",
"{",
"return",
"nil",
",",
"MakeGitError",
"(",
"ret",
")",
"\n",
"}",
"\n\n",
"return",
"newReferenceIteratorFromC",
"(",
"ptr",
",",
"repo",
")",
",",
"nil",
"\n",
"}"
] |
// NewReferenceIteratorGlob creates an iterator over reference names
// that match the speicified glob. The glob is of the usual fnmatch
// type.
|
[
"NewReferenceIteratorGlob",
"creates",
"an",
"iterator",
"over",
"reference",
"names",
"that",
"match",
"the",
"speicified",
"glob",
".",
"The",
"glob",
"is",
"of",
"the",
"usual",
"fnmatch",
"type",
"."
] |
bf1e8a4338822ad2539a3876f58b15b590eb9e1f
|
https://github.com/libgit2/git2go/blob/bf1e8a4338822ad2539a3876f58b15b590eb9e1f/reference.go#L406-L420
|
151,181 |
libgit2/git2go
|
reference.go
|
Next
|
func (v *ReferenceNameIterator) Next() (string, error) {
var ptr *C.char
runtime.LockOSThread()
defer runtime.UnlockOSThread()
ret := C.git_reference_next_name(&ptr, v.ptr)
if ret < 0 {
return "", MakeGitError(ret)
}
return C.GoString(ptr), nil
}
|
go
|
func (v *ReferenceNameIterator) Next() (string, error) {
var ptr *C.char
runtime.LockOSThread()
defer runtime.UnlockOSThread()
ret := C.git_reference_next_name(&ptr, v.ptr)
if ret < 0 {
return "", MakeGitError(ret)
}
return C.GoString(ptr), nil
}
|
[
"func",
"(",
"v",
"*",
"ReferenceNameIterator",
")",
"Next",
"(",
")",
"(",
"string",
",",
"error",
")",
"{",
"var",
"ptr",
"*",
"C",
".",
"char",
"\n\n",
"runtime",
".",
"LockOSThread",
"(",
")",
"\n",
"defer",
"runtime",
".",
"UnlockOSThread",
"(",
")",
"\n\n",
"ret",
":=",
"C",
".",
"git_reference_next_name",
"(",
"&",
"ptr",
",",
"v",
".",
"ptr",
")",
"\n",
"if",
"ret",
"<",
"0",
"{",
"return",
"\"",
"\"",
",",
"MakeGitError",
"(",
"ret",
")",
"\n",
"}",
"\n\n",
"return",
"C",
".",
"GoString",
"(",
"ptr",
")",
",",
"nil",
"\n",
"}"
] |
// NextName retrieves the next reference name. If the iteration is over,
// the returned error is git.ErrIterOver
|
[
"NextName",
"retrieves",
"the",
"next",
"reference",
"name",
".",
"If",
"the",
"iteration",
"is",
"over",
"the",
"returned",
"error",
"is",
"git",
".",
"ErrIterOver"
] |
bf1e8a4338822ad2539a3876f58b15b590eb9e1f
|
https://github.com/libgit2/git2go/blob/bf1e8a4338822ad2539a3876f58b15b590eb9e1f/reference.go#L428-L440
|
151,182 |
libgit2/git2go
|
reference.go
|
Next
|
func (v *ReferenceIterator) Next() (*Reference, error) {
var ptr *C.git_reference
runtime.LockOSThread()
defer runtime.UnlockOSThread()
ret := C.git_reference_next(&ptr, v.ptr)
if ret < 0 {
return nil, MakeGitError(ret)
}
return newReferenceFromC(ptr, v.repo), nil
}
|
go
|
func (v *ReferenceIterator) Next() (*Reference, error) {
var ptr *C.git_reference
runtime.LockOSThread()
defer runtime.UnlockOSThread()
ret := C.git_reference_next(&ptr, v.ptr)
if ret < 0 {
return nil, MakeGitError(ret)
}
return newReferenceFromC(ptr, v.repo), nil
}
|
[
"func",
"(",
"v",
"*",
"ReferenceIterator",
")",
"Next",
"(",
")",
"(",
"*",
"Reference",
",",
"error",
")",
"{",
"var",
"ptr",
"*",
"C",
".",
"git_reference",
"\n\n",
"runtime",
".",
"LockOSThread",
"(",
")",
"\n",
"defer",
"runtime",
".",
"UnlockOSThread",
"(",
")",
"\n\n",
"ret",
":=",
"C",
".",
"git_reference_next",
"(",
"&",
"ptr",
",",
"v",
".",
"ptr",
")",
"\n",
"if",
"ret",
"<",
"0",
"{",
"return",
"nil",
",",
"MakeGitError",
"(",
"ret",
")",
"\n",
"}",
"\n\n",
"return",
"newReferenceFromC",
"(",
"ptr",
",",
"v",
".",
"repo",
")",
",",
"nil",
"\n",
"}"
] |
// Next retrieves the next reference. If the iterationis over, the
// returned error is git.ErrIterOver
|
[
"Next",
"retrieves",
"the",
"next",
"reference",
".",
"If",
"the",
"iterationis",
"over",
"the",
"returned",
"error",
"is",
"git",
".",
"ErrIterOver"
] |
bf1e8a4338822ad2539a3876f58b15b590eb9e1f
|
https://github.com/libgit2/git2go/blob/bf1e8a4338822ad2539a3876f58b15b590eb9e1f/reference.go#L444-L456
|
151,183 |
libgit2/git2go
|
reference.go
|
Free
|
func (v *ReferenceIterator) Free() {
runtime.SetFinalizer(v, nil)
C.git_reference_iterator_free(v.ptr)
}
|
go
|
func (v *ReferenceIterator) Free() {
runtime.SetFinalizer(v, nil)
C.git_reference_iterator_free(v.ptr)
}
|
[
"func",
"(",
"v",
"*",
"ReferenceIterator",
")",
"Free",
"(",
")",
"{",
"runtime",
".",
"SetFinalizer",
"(",
"v",
",",
"nil",
")",
"\n",
"C",
".",
"git_reference_iterator_free",
"(",
"v",
".",
"ptr",
")",
"\n",
"}"
] |
// Free the reference iterator
|
[
"Free",
"the",
"reference",
"iterator"
] |
bf1e8a4338822ad2539a3876f58b15b590eb9e1f
|
https://github.com/libgit2/git2go/blob/bf1e8a4338822ad2539a3876f58b15b590eb9e1f/reference.go#L468-L471
|
151,184 |
libgit2/git2go
|
checkout.go
|
populateCheckoutOpts
|
func populateCheckoutOpts(ptr *C.git_checkout_options, opts *CheckoutOpts) *C.git_checkout_options {
if opts == nil {
return nil
}
C.git_checkout_init_options(ptr, 1)
ptr.checkout_strategy = C.uint(opts.Strategy)
ptr.disable_filters = cbool(opts.DisableFilters)
ptr.dir_mode = C.uint(opts.DirMode.Perm())
ptr.file_mode = C.uint(opts.FileMode.Perm())
ptr.notify_flags = C.uint(opts.NotifyFlags)
if opts.NotifyCallback != nil || opts.ProgressCallback != nil {
C._go_git_populate_checkout_cb(ptr)
}
payload := pointerHandles.Track(opts)
if opts.NotifyCallback != nil {
ptr.notify_payload = payload
}
if opts.ProgressCallback != nil {
ptr.progress_payload = payload
}
if opts.TargetDirectory != "" {
ptr.target_directory = C.CString(opts.TargetDirectory)
}
if len(opts.Paths) > 0 {
ptr.paths.strings = makeCStringsFromStrings(opts.Paths)
ptr.paths.count = C.size_t(len(opts.Paths))
}
if opts.Baseline != nil {
ptr.baseline = opts.Baseline.cast_ptr
}
return ptr
}
|
go
|
func populateCheckoutOpts(ptr *C.git_checkout_options, opts *CheckoutOpts) *C.git_checkout_options {
if opts == nil {
return nil
}
C.git_checkout_init_options(ptr, 1)
ptr.checkout_strategy = C.uint(opts.Strategy)
ptr.disable_filters = cbool(opts.DisableFilters)
ptr.dir_mode = C.uint(opts.DirMode.Perm())
ptr.file_mode = C.uint(opts.FileMode.Perm())
ptr.notify_flags = C.uint(opts.NotifyFlags)
if opts.NotifyCallback != nil || opts.ProgressCallback != nil {
C._go_git_populate_checkout_cb(ptr)
}
payload := pointerHandles.Track(opts)
if opts.NotifyCallback != nil {
ptr.notify_payload = payload
}
if opts.ProgressCallback != nil {
ptr.progress_payload = payload
}
if opts.TargetDirectory != "" {
ptr.target_directory = C.CString(opts.TargetDirectory)
}
if len(opts.Paths) > 0 {
ptr.paths.strings = makeCStringsFromStrings(opts.Paths)
ptr.paths.count = C.size_t(len(opts.Paths))
}
if opts.Baseline != nil {
ptr.baseline = opts.Baseline.cast_ptr
}
return ptr
}
|
[
"func",
"populateCheckoutOpts",
"(",
"ptr",
"*",
"C",
".",
"git_checkout_options",
",",
"opts",
"*",
"CheckoutOpts",
")",
"*",
"C",
".",
"git_checkout_options",
"{",
"if",
"opts",
"==",
"nil",
"{",
"return",
"nil",
"\n",
"}",
"\n\n",
"C",
".",
"git_checkout_init_options",
"(",
"ptr",
",",
"1",
")",
"\n",
"ptr",
".",
"checkout_strategy",
"=",
"C",
".",
"uint",
"(",
"opts",
".",
"Strategy",
")",
"\n",
"ptr",
".",
"disable_filters",
"=",
"cbool",
"(",
"opts",
".",
"DisableFilters",
")",
"\n",
"ptr",
".",
"dir_mode",
"=",
"C",
".",
"uint",
"(",
"opts",
".",
"DirMode",
".",
"Perm",
"(",
")",
")",
"\n",
"ptr",
".",
"file_mode",
"=",
"C",
".",
"uint",
"(",
"opts",
".",
"FileMode",
".",
"Perm",
"(",
")",
")",
"\n",
"ptr",
".",
"notify_flags",
"=",
"C",
".",
"uint",
"(",
"opts",
".",
"NotifyFlags",
")",
"\n",
"if",
"opts",
".",
"NotifyCallback",
"!=",
"nil",
"||",
"opts",
".",
"ProgressCallback",
"!=",
"nil",
"{",
"C",
".",
"_go_git_populate_checkout_cb",
"(",
"ptr",
")",
"\n",
"}",
"\n",
"payload",
":=",
"pointerHandles",
".",
"Track",
"(",
"opts",
")",
"\n",
"if",
"opts",
".",
"NotifyCallback",
"!=",
"nil",
"{",
"ptr",
".",
"notify_payload",
"=",
"payload",
"\n",
"}",
"\n",
"if",
"opts",
".",
"ProgressCallback",
"!=",
"nil",
"{",
"ptr",
".",
"progress_payload",
"=",
"payload",
"\n",
"}",
"\n",
"if",
"opts",
".",
"TargetDirectory",
"!=",
"\"",
"\"",
"{",
"ptr",
".",
"target_directory",
"=",
"C",
".",
"CString",
"(",
"opts",
".",
"TargetDirectory",
")",
"\n",
"}",
"\n",
"if",
"len",
"(",
"opts",
".",
"Paths",
")",
">",
"0",
"{",
"ptr",
".",
"paths",
".",
"strings",
"=",
"makeCStringsFromStrings",
"(",
"opts",
".",
"Paths",
")",
"\n",
"ptr",
".",
"paths",
".",
"count",
"=",
"C",
".",
"size_t",
"(",
"len",
"(",
"opts",
".",
"Paths",
")",
")",
"\n",
"}",
"\n\n",
"if",
"opts",
".",
"Baseline",
"!=",
"nil",
"{",
"ptr",
".",
"baseline",
"=",
"opts",
".",
"Baseline",
".",
"cast_ptr",
"\n",
"}",
"\n\n",
"return",
"ptr",
"\n",
"}"
] |
// Convert the CheckoutOpts struct to the corresponding
// C-struct. Returns a pointer to ptr, or nil if opts is nil, in order
// to help with what to pass.
|
[
"Convert",
"the",
"CheckoutOpts",
"struct",
"to",
"the",
"corresponding",
"C",
"-",
"struct",
".",
"Returns",
"a",
"pointer",
"to",
"ptr",
"or",
"nil",
"if",
"opts",
"is",
"nil",
"in",
"order",
"to",
"help",
"with",
"what",
"to",
"pass",
"."
] |
bf1e8a4338822ad2539a3876f58b15b590eb9e1f
|
https://github.com/libgit2/git2go/blob/bf1e8a4338822ad2539a3876f58b15b590eb9e1f/checkout.go#L132-L166
|
151,185 |
libgit2/git2go
|
checkout.go
|
CheckoutHead
|
func (v *Repository) CheckoutHead(opts *CheckoutOpts) error {
runtime.LockOSThread()
defer runtime.UnlockOSThread()
cOpts := opts.toC()
defer freeCheckoutOpts(cOpts)
ret := C.git_checkout_head(v.ptr, cOpts)
runtime.KeepAlive(v)
if ret < 0 {
return MakeGitError(ret)
}
return nil
}
|
go
|
func (v *Repository) CheckoutHead(opts *CheckoutOpts) error {
runtime.LockOSThread()
defer runtime.UnlockOSThread()
cOpts := opts.toC()
defer freeCheckoutOpts(cOpts)
ret := C.git_checkout_head(v.ptr, cOpts)
runtime.KeepAlive(v)
if ret < 0 {
return MakeGitError(ret)
}
return nil
}
|
[
"func",
"(",
"v",
"*",
"Repository",
")",
"CheckoutHead",
"(",
"opts",
"*",
"CheckoutOpts",
")",
"error",
"{",
"runtime",
".",
"LockOSThread",
"(",
")",
"\n",
"defer",
"runtime",
".",
"UnlockOSThread",
"(",
")",
"\n\n",
"cOpts",
":=",
"opts",
".",
"toC",
"(",
")",
"\n",
"defer",
"freeCheckoutOpts",
"(",
"cOpts",
")",
"\n\n",
"ret",
":=",
"C",
".",
"git_checkout_head",
"(",
"v",
".",
"ptr",
",",
"cOpts",
")",
"\n",
"runtime",
".",
"KeepAlive",
"(",
"v",
")",
"\n",
"if",
"ret",
"<",
"0",
"{",
"return",
"MakeGitError",
"(",
"ret",
")",
"\n",
"}",
"\n\n",
"return",
"nil",
"\n",
"}"
] |
// Updates files in the index and the working tree to match the content of
// the commit pointed at by HEAD. opts may be nil.
|
[
"Updates",
"files",
"in",
"the",
"index",
"and",
"the",
"working",
"tree",
"to",
"match",
"the",
"content",
"of",
"the",
"commit",
"pointed",
"at",
"by",
"HEAD",
".",
"opts",
"may",
"be",
"nil",
"."
] |
bf1e8a4338822ad2539a3876f58b15b590eb9e1f
|
https://github.com/libgit2/git2go/blob/bf1e8a4338822ad2539a3876f58b15b590eb9e1f/checkout.go#L183-L197
|
151,186 |
libgit2/git2go
|
checkout.go
|
CheckoutIndex
|
func (v *Repository) CheckoutIndex(index *Index, opts *CheckoutOpts) error {
var iptr *C.git_index = nil
if index != nil {
iptr = index.ptr
}
runtime.LockOSThread()
defer runtime.UnlockOSThread()
cOpts := opts.toC()
defer freeCheckoutOpts(cOpts)
ret := C.git_checkout_index(v.ptr, iptr, cOpts)
runtime.KeepAlive(v)
if ret < 0 {
return MakeGitError(ret)
}
return nil
}
|
go
|
func (v *Repository) CheckoutIndex(index *Index, opts *CheckoutOpts) error {
var iptr *C.git_index = nil
if index != nil {
iptr = index.ptr
}
runtime.LockOSThread()
defer runtime.UnlockOSThread()
cOpts := opts.toC()
defer freeCheckoutOpts(cOpts)
ret := C.git_checkout_index(v.ptr, iptr, cOpts)
runtime.KeepAlive(v)
if ret < 0 {
return MakeGitError(ret)
}
return nil
}
|
[
"func",
"(",
"v",
"*",
"Repository",
")",
"CheckoutIndex",
"(",
"index",
"*",
"Index",
",",
"opts",
"*",
"CheckoutOpts",
")",
"error",
"{",
"var",
"iptr",
"*",
"C",
".",
"git_index",
"=",
"nil",
"\n",
"if",
"index",
"!=",
"nil",
"{",
"iptr",
"=",
"index",
".",
"ptr",
"\n",
"}",
"\n\n",
"runtime",
".",
"LockOSThread",
"(",
")",
"\n",
"defer",
"runtime",
".",
"UnlockOSThread",
"(",
")",
"\n\n",
"cOpts",
":=",
"opts",
".",
"toC",
"(",
")",
"\n",
"defer",
"freeCheckoutOpts",
"(",
"cOpts",
")",
"\n\n",
"ret",
":=",
"C",
".",
"git_checkout_index",
"(",
"v",
".",
"ptr",
",",
"iptr",
",",
"cOpts",
")",
"\n",
"runtime",
".",
"KeepAlive",
"(",
"v",
")",
"\n",
"if",
"ret",
"<",
"0",
"{",
"return",
"MakeGitError",
"(",
"ret",
")",
"\n",
"}",
"\n\n",
"return",
"nil",
"\n",
"}"
] |
// Updates files in the working tree to match the content of the given
// index. If index is nil, the repository's index will be used. opts
// may be nil.
|
[
"Updates",
"files",
"in",
"the",
"working",
"tree",
"to",
"match",
"the",
"content",
"of",
"the",
"given",
"index",
".",
"If",
"index",
"is",
"nil",
"the",
"repository",
"s",
"index",
"will",
"be",
"used",
".",
"opts",
"may",
"be",
"nil",
"."
] |
bf1e8a4338822ad2539a3876f58b15b590eb9e1f
|
https://github.com/libgit2/git2go/blob/bf1e8a4338822ad2539a3876f58b15b590eb9e1f/checkout.go#L202-L221
|
151,187 |
libgit2/git2go
|
packbuilder.go
|
ForEach
|
func (pb *Packbuilder) ForEach(callback PackbuilderForeachCallback) error {
data := packbuilderCbData{
callback: callback,
err: nil,
}
handle := pointerHandles.Track(&data)
defer pointerHandles.Untrack(handle)
runtime.LockOSThread()
defer runtime.UnlockOSThread()
err := C._go_git_packbuilder_foreach(pb.ptr, handle)
runtime.KeepAlive(pb)
if err == C.GIT_EUSER {
return data.err
}
if err < 0 {
return MakeGitError(err)
}
return nil
}
|
go
|
func (pb *Packbuilder) ForEach(callback PackbuilderForeachCallback) error {
data := packbuilderCbData{
callback: callback,
err: nil,
}
handle := pointerHandles.Track(&data)
defer pointerHandles.Untrack(handle)
runtime.LockOSThread()
defer runtime.UnlockOSThread()
err := C._go_git_packbuilder_foreach(pb.ptr, handle)
runtime.KeepAlive(pb)
if err == C.GIT_EUSER {
return data.err
}
if err < 0 {
return MakeGitError(err)
}
return nil
}
|
[
"func",
"(",
"pb",
"*",
"Packbuilder",
")",
"ForEach",
"(",
"callback",
"PackbuilderForeachCallback",
")",
"error",
"{",
"data",
":=",
"packbuilderCbData",
"{",
"callback",
":",
"callback",
",",
"err",
":",
"nil",
",",
"}",
"\n",
"handle",
":=",
"pointerHandles",
".",
"Track",
"(",
"&",
"data",
")",
"\n",
"defer",
"pointerHandles",
".",
"Untrack",
"(",
"handle",
")",
"\n\n",
"runtime",
".",
"LockOSThread",
"(",
")",
"\n",
"defer",
"runtime",
".",
"UnlockOSThread",
"(",
")",
"\n\n",
"err",
":=",
"C",
".",
"_go_git_packbuilder_foreach",
"(",
"pb",
".",
"ptr",
",",
"handle",
")",
"\n",
"runtime",
".",
"KeepAlive",
"(",
"pb",
")",
"\n",
"if",
"err",
"==",
"C",
".",
"GIT_EUSER",
"{",
"return",
"data",
".",
"err",
"\n",
"}",
"\n",
"if",
"err",
"<",
"0",
"{",
"return",
"MakeGitError",
"(",
"err",
")",
"\n",
"}",
"\n\n",
"return",
"nil",
"\n",
"}"
] |
// ForEach repeatedly calls the callback with new packfile data until
// there is no more data or the callback returns an error
|
[
"ForEach",
"repeatedly",
"calls",
"the",
"callback",
"with",
"new",
"packfile",
"data",
"until",
"there",
"is",
"no",
"more",
"data",
"or",
"the",
"callback",
"returns",
"an",
"error"
] |
bf1e8a4338822ad2539a3876f58b15b590eb9e1f
|
https://github.com/libgit2/git2go/blob/bf1e8a4338822ad2539a3876f58b15b590eb9e1f/packbuilder.go#L162-L183
|
151,188 |
libgit2/git2go
|
object.go
|
Owner
|
func (o *Object) Owner() *Repository {
ret := &Repository{
ptr: C.git_object_owner(o.ptr),
}
runtime.KeepAlive(o)
return ret
}
|
go
|
func (o *Object) Owner() *Repository {
ret := &Repository{
ptr: C.git_object_owner(o.ptr),
}
runtime.KeepAlive(o)
return ret
}
|
[
"func",
"(",
"o",
"*",
"Object",
")",
"Owner",
"(",
")",
"*",
"Repository",
"{",
"ret",
":=",
"&",
"Repository",
"{",
"ptr",
":",
"C",
".",
"git_object_owner",
"(",
"o",
".",
"ptr",
")",
",",
"}",
"\n",
"runtime",
".",
"KeepAlive",
"(",
"o",
")",
"\n",
"return",
"ret",
"\n",
"}"
] |
// Owner returns a weak reference to the repository which owns this
// object. This won't keep the underlying repository alive.
|
[
"Owner",
"returns",
"a",
"weak",
"reference",
"to",
"the",
"repository",
"which",
"owns",
"this",
"object",
".",
"This",
"won",
"t",
"keep",
"the",
"underlying",
"repository",
"alive",
"."
] |
bf1e8a4338822ad2539a3876f58b15b590eb9e1f
|
https://github.com/libgit2/git2go/blob/bf1e8a4338822ad2539a3876f58b15b590eb9e1f/object.go#L82-L88
|
151,189 |
libgit2/git2go
|
odb.go
|
NewReadStream
|
func (v *Odb) NewReadStream(id *Oid) (*OdbReadStream, error) {
stream := new(OdbReadStream)
var ctype C.git_object_t
var csize C.size_t
runtime.LockOSThread()
defer runtime.UnlockOSThread()
ret := C.git_odb_open_rstream(&stream.ptr, &csize, &ctype, v.ptr, id.toC())
runtime.KeepAlive(v)
runtime.KeepAlive(id)
if ret < 0 {
return nil, MakeGitError(ret)
}
stream.Size = uint64(csize)
stream.Type = ObjectType(ctype)
runtime.SetFinalizer(stream, (*OdbReadStream).Free)
return stream, nil
}
|
go
|
func (v *Odb) NewReadStream(id *Oid) (*OdbReadStream, error) {
stream := new(OdbReadStream)
var ctype C.git_object_t
var csize C.size_t
runtime.LockOSThread()
defer runtime.UnlockOSThread()
ret := C.git_odb_open_rstream(&stream.ptr, &csize, &ctype, v.ptr, id.toC())
runtime.KeepAlive(v)
runtime.KeepAlive(id)
if ret < 0 {
return nil, MakeGitError(ret)
}
stream.Size = uint64(csize)
stream.Type = ObjectType(ctype)
runtime.SetFinalizer(stream, (*OdbReadStream).Free)
return stream, nil
}
|
[
"func",
"(",
"v",
"*",
"Odb",
")",
"NewReadStream",
"(",
"id",
"*",
"Oid",
")",
"(",
"*",
"OdbReadStream",
",",
"error",
")",
"{",
"stream",
":=",
"new",
"(",
"OdbReadStream",
")",
"\n",
"var",
"ctype",
"C",
".",
"git_object_t",
"\n",
"var",
"csize",
"C",
".",
"size_t",
"\n\n",
"runtime",
".",
"LockOSThread",
"(",
")",
"\n",
"defer",
"runtime",
".",
"UnlockOSThread",
"(",
")",
"\n\n",
"ret",
":=",
"C",
".",
"git_odb_open_rstream",
"(",
"&",
"stream",
".",
"ptr",
",",
"&",
"csize",
",",
"&",
"ctype",
",",
"v",
".",
"ptr",
",",
"id",
".",
"toC",
"(",
")",
")",
"\n",
"runtime",
".",
"KeepAlive",
"(",
"v",
")",
"\n",
"runtime",
".",
"KeepAlive",
"(",
"id",
")",
"\n",
"if",
"ret",
"<",
"0",
"{",
"return",
"nil",
",",
"MakeGitError",
"(",
"ret",
")",
"\n",
"}",
"\n\n",
"stream",
".",
"Size",
"=",
"uint64",
"(",
"csize",
")",
"\n",
"stream",
".",
"Type",
"=",
"ObjectType",
"(",
"ctype",
")",
"\n",
"runtime",
".",
"SetFinalizer",
"(",
"stream",
",",
"(",
"*",
"OdbReadStream",
")",
".",
"Free",
")",
"\n",
"return",
"stream",
",",
"nil",
"\n",
"}"
] |
// NewReadStream opens a read stream from the ODB. Reading from it will give you the
// contents of the object.
|
[
"NewReadStream",
"opens",
"a",
"read",
"stream",
"from",
"the",
"ODB",
".",
"Reading",
"from",
"it",
"will",
"give",
"you",
"the",
"contents",
"of",
"the",
"object",
"."
] |
bf1e8a4338822ad2539a3876f58b15b590eb9e1f
|
https://github.com/libgit2/git2go/blob/bf1e8a4338822ad2539a3876f58b15b590eb9e1f/odb.go#L194-L213
|
151,190 |
libgit2/git2go
|
odb.go
|
NewWriteStream
|
func (v *Odb) NewWriteStream(size int64, otype ObjectType) (*OdbWriteStream, error) {
stream := new(OdbWriteStream)
runtime.LockOSThread()
defer runtime.UnlockOSThread()
ret := C.git_odb_open_wstream(&stream.ptr, v.ptr, C.git_off_t(size), C.git_object_t(otype))
runtime.KeepAlive(v)
if ret < 0 {
return nil, MakeGitError(ret)
}
runtime.SetFinalizer(stream, (*OdbWriteStream).Free)
return stream, nil
}
|
go
|
func (v *Odb) NewWriteStream(size int64, otype ObjectType) (*OdbWriteStream, error) {
stream := new(OdbWriteStream)
runtime.LockOSThread()
defer runtime.UnlockOSThread()
ret := C.git_odb_open_wstream(&stream.ptr, v.ptr, C.git_off_t(size), C.git_object_t(otype))
runtime.KeepAlive(v)
if ret < 0 {
return nil, MakeGitError(ret)
}
runtime.SetFinalizer(stream, (*OdbWriteStream).Free)
return stream, nil
}
|
[
"func",
"(",
"v",
"*",
"Odb",
")",
"NewWriteStream",
"(",
"size",
"int64",
",",
"otype",
"ObjectType",
")",
"(",
"*",
"OdbWriteStream",
",",
"error",
")",
"{",
"stream",
":=",
"new",
"(",
"OdbWriteStream",
")",
"\n\n",
"runtime",
".",
"LockOSThread",
"(",
")",
"\n",
"defer",
"runtime",
".",
"UnlockOSThread",
"(",
")",
"\n\n",
"ret",
":=",
"C",
".",
"git_odb_open_wstream",
"(",
"&",
"stream",
".",
"ptr",
",",
"v",
".",
"ptr",
",",
"C",
".",
"git_off_t",
"(",
"size",
")",
",",
"C",
".",
"git_object_t",
"(",
"otype",
")",
")",
"\n",
"runtime",
".",
"KeepAlive",
"(",
"v",
")",
"\n",
"if",
"ret",
"<",
"0",
"{",
"return",
"nil",
",",
"MakeGitError",
"(",
"ret",
")",
"\n",
"}",
"\n\n",
"runtime",
".",
"SetFinalizer",
"(",
"stream",
",",
"(",
"*",
"OdbWriteStream",
")",
".",
"Free",
")",
"\n",
"return",
"stream",
",",
"nil",
"\n",
"}"
] |
// NewWriteStream opens a write stream to the ODB, which allows you to
// create a new object in the database. The size and type must be
// known in advance
|
[
"NewWriteStream",
"opens",
"a",
"write",
"stream",
"to",
"the",
"ODB",
"which",
"allows",
"you",
"to",
"create",
"a",
"new",
"object",
"in",
"the",
"database",
".",
"The",
"size",
"and",
"type",
"must",
"be",
"known",
"in",
"advance"
] |
bf1e8a4338822ad2539a3876f58b15b590eb9e1f
|
https://github.com/libgit2/git2go/blob/bf1e8a4338822ad2539a3876f58b15b590eb9e1f/odb.go#L218-L232
|
151,191 |
libgit2/git2go
|
odb.go
|
Data
|
func (object *OdbObject) Data() (data []byte) {
var c_blob unsafe.Pointer = C.git_odb_object_data(object.ptr)
var blob []byte
len := int(C.git_odb_object_size(object.ptr))
sliceHeader := (*reflect.SliceHeader)((unsafe.Pointer(&blob)))
sliceHeader.Cap = len
sliceHeader.Len = len
sliceHeader.Data = uintptr(c_blob)
return blob
}
|
go
|
func (object *OdbObject) Data() (data []byte) {
var c_blob unsafe.Pointer = C.git_odb_object_data(object.ptr)
var blob []byte
len := int(C.git_odb_object_size(object.ptr))
sliceHeader := (*reflect.SliceHeader)((unsafe.Pointer(&blob)))
sliceHeader.Cap = len
sliceHeader.Len = len
sliceHeader.Data = uintptr(c_blob)
return blob
}
|
[
"func",
"(",
"object",
"*",
"OdbObject",
")",
"Data",
"(",
")",
"(",
"data",
"[",
"]",
"byte",
")",
"{",
"var",
"c_blob",
"unsafe",
".",
"Pointer",
"=",
"C",
".",
"git_odb_object_data",
"(",
"object",
".",
"ptr",
")",
"\n",
"var",
"blob",
"[",
"]",
"byte",
"\n\n",
"len",
":=",
"int",
"(",
"C",
".",
"git_odb_object_size",
"(",
"object",
".",
"ptr",
")",
")",
"\n\n",
"sliceHeader",
":=",
"(",
"*",
"reflect",
".",
"SliceHeader",
")",
"(",
"(",
"unsafe",
".",
"Pointer",
"(",
"&",
"blob",
")",
")",
")",
"\n",
"sliceHeader",
".",
"Cap",
"=",
"len",
"\n",
"sliceHeader",
".",
"Len",
"=",
"len",
"\n",
"sliceHeader",
".",
"Data",
"=",
"uintptr",
"(",
"c_blob",
")",
"\n\n",
"return",
"blob",
"\n",
"}"
] |
// Data returns a slice pointing to the unmanaged object memory. You must make
// sure the object is referenced for at least as long as the slice is used.
|
[
"Data",
"returns",
"a",
"slice",
"pointing",
"to",
"the",
"unmanaged",
"object",
"memory",
".",
"You",
"must",
"make",
"sure",
"the",
"object",
"is",
"referenced",
"for",
"at",
"least",
"as",
"long",
"as",
"the",
"slice",
"is",
"used",
"."
] |
bf1e8a4338822ad2539a3876f58b15b590eb9e1f
|
https://github.com/libgit2/git2go/blob/bf1e8a4338822ad2539a3876f58b15b590eb9e1f/odb.go#L267-L279
|
151,192 |
libgit2/git2go
|
odb.go
|
Read
|
func (stream *OdbReadStream) Read(data []byte) (int, error) {
header := (*reflect.SliceHeader)(unsafe.Pointer(&data))
ptr := (*C.char)(unsafe.Pointer(header.Data))
size := C.size_t(header.Cap)
runtime.LockOSThread()
defer runtime.UnlockOSThread()
ret := C.git_odb_stream_read(stream.ptr, ptr, size)
runtime.KeepAlive(stream)
if ret < 0 {
return 0, MakeGitError(ret)
}
if ret == 0 {
return 0, io.EOF
}
header.Len = int(ret)
return len(data), nil
}
|
go
|
func (stream *OdbReadStream) Read(data []byte) (int, error) {
header := (*reflect.SliceHeader)(unsafe.Pointer(&data))
ptr := (*C.char)(unsafe.Pointer(header.Data))
size := C.size_t(header.Cap)
runtime.LockOSThread()
defer runtime.UnlockOSThread()
ret := C.git_odb_stream_read(stream.ptr, ptr, size)
runtime.KeepAlive(stream)
if ret < 0 {
return 0, MakeGitError(ret)
}
if ret == 0 {
return 0, io.EOF
}
header.Len = int(ret)
return len(data), nil
}
|
[
"func",
"(",
"stream",
"*",
"OdbReadStream",
")",
"Read",
"(",
"data",
"[",
"]",
"byte",
")",
"(",
"int",
",",
"error",
")",
"{",
"header",
":=",
"(",
"*",
"reflect",
".",
"SliceHeader",
")",
"(",
"unsafe",
".",
"Pointer",
"(",
"&",
"data",
")",
")",
"\n",
"ptr",
":=",
"(",
"*",
"C",
".",
"char",
")",
"(",
"unsafe",
".",
"Pointer",
"(",
"header",
".",
"Data",
")",
")",
"\n",
"size",
":=",
"C",
".",
"size_t",
"(",
"header",
".",
"Cap",
")",
"\n\n",
"runtime",
".",
"LockOSThread",
"(",
")",
"\n",
"defer",
"runtime",
".",
"UnlockOSThread",
"(",
")",
"\n\n",
"ret",
":=",
"C",
".",
"git_odb_stream_read",
"(",
"stream",
".",
"ptr",
",",
"ptr",
",",
"size",
")",
"\n",
"runtime",
".",
"KeepAlive",
"(",
"stream",
")",
"\n",
"if",
"ret",
"<",
"0",
"{",
"return",
"0",
",",
"MakeGitError",
"(",
"ret",
")",
"\n",
"}",
"\n",
"if",
"ret",
"==",
"0",
"{",
"return",
"0",
",",
"io",
".",
"EOF",
"\n",
"}",
"\n\n",
"header",
".",
"Len",
"=",
"int",
"(",
"ret",
")",
"\n\n",
"return",
"len",
"(",
"data",
")",
",",
"nil",
"\n",
"}"
] |
// Read reads from the stream
|
[
"Read",
"reads",
"from",
"the",
"stream"
] |
bf1e8a4338822ad2539a3876f58b15b590eb9e1f
|
https://github.com/libgit2/git2go/blob/bf1e8a4338822ad2539a3876f58b15b590eb9e1f/odb.go#L288-L308
|
151,193 |
libgit2/git2go
|
odb.go
|
Write
|
func (stream *OdbWriteStream) Write(data []byte) (int, error) {
header := (*reflect.SliceHeader)(unsafe.Pointer(&data))
ptr := (*C.char)(unsafe.Pointer(header.Data))
size := C.size_t(header.Len)
runtime.LockOSThread()
defer runtime.UnlockOSThread()
ret := C.git_odb_stream_write(stream.ptr, ptr, size)
runtime.KeepAlive(stream)
if ret < 0 {
return 0, MakeGitError(ret)
}
return len(data), nil
}
|
go
|
func (stream *OdbWriteStream) Write(data []byte) (int, error) {
header := (*reflect.SliceHeader)(unsafe.Pointer(&data))
ptr := (*C.char)(unsafe.Pointer(header.Data))
size := C.size_t(header.Len)
runtime.LockOSThread()
defer runtime.UnlockOSThread()
ret := C.git_odb_stream_write(stream.ptr, ptr, size)
runtime.KeepAlive(stream)
if ret < 0 {
return 0, MakeGitError(ret)
}
return len(data), nil
}
|
[
"func",
"(",
"stream",
"*",
"OdbWriteStream",
")",
"Write",
"(",
"data",
"[",
"]",
"byte",
")",
"(",
"int",
",",
"error",
")",
"{",
"header",
":=",
"(",
"*",
"reflect",
".",
"SliceHeader",
")",
"(",
"unsafe",
".",
"Pointer",
"(",
"&",
"data",
")",
")",
"\n",
"ptr",
":=",
"(",
"*",
"C",
".",
"char",
")",
"(",
"unsafe",
".",
"Pointer",
"(",
"header",
".",
"Data",
")",
")",
"\n",
"size",
":=",
"C",
".",
"size_t",
"(",
"header",
".",
"Len",
")",
"\n\n",
"runtime",
".",
"LockOSThread",
"(",
")",
"\n",
"defer",
"runtime",
".",
"UnlockOSThread",
"(",
")",
"\n\n",
"ret",
":=",
"C",
".",
"git_odb_stream_write",
"(",
"stream",
".",
"ptr",
",",
"ptr",
",",
"size",
")",
"\n",
"runtime",
".",
"KeepAlive",
"(",
"stream",
")",
"\n",
"if",
"ret",
"<",
"0",
"{",
"return",
"0",
",",
"MakeGitError",
"(",
"ret",
")",
"\n",
"}",
"\n\n",
"return",
"len",
"(",
"data",
")",
",",
"nil",
"\n",
"}"
] |
// Write writes to the stream
|
[
"Write",
"writes",
"to",
"the",
"stream"
] |
bf1e8a4338822ad2539a3876f58b15b590eb9e1f
|
https://github.com/libgit2/git2go/blob/bf1e8a4338822ad2539a3876f58b15b590eb9e1f/odb.go#L327-L342
|
151,194 |
libgit2/git2go
|
odb.go
|
Close
|
func (stream *OdbWriteStream) Close() error {
runtime.LockOSThread()
defer runtime.UnlockOSThread()
ret := C.git_odb_stream_finalize_write(stream.Id.toC(), stream.ptr)
runtime.KeepAlive(stream)
if ret < 0 {
return MakeGitError(ret)
}
return nil
}
|
go
|
func (stream *OdbWriteStream) Close() error {
runtime.LockOSThread()
defer runtime.UnlockOSThread()
ret := C.git_odb_stream_finalize_write(stream.Id.toC(), stream.ptr)
runtime.KeepAlive(stream)
if ret < 0 {
return MakeGitError(ret)
}
return nil
}
|
[
"func",
"(",
"stream",
"*",
"OdbWriteStream",
")",
"Close",
"(",
")",
"error",
"{",
"runtime",
".",
"LockOSThread",
"(",
")",
"\n",
"defer",
"runtime",
".",
"UnlockOSThread",
"(",
")",
"\n\n",
"ret",
":=",
"C",
".",
"git_odb_stream_finalize_write",
"(",
"stream",
".",
"Id",
".",
"toC",
"(",
")",
",",
"stream",
".",
"ptr",
")",
"\n",
"runtime",
".",
"KeepAlive",
"(",
"stream",
")",
"\n",
"if",
"ret",
"<",
"0",
"{",
"return",
"MakeGitError",
"(",
"ret",
")",
"\n",
"}",
"\n\n",
"return",
"nil",
"\n",
"}"
] |
// Close signals that all the data has been written and stores the
// resulting object id in the stream's Id field.
|
[
"Close",
"signals",
"that",
"all",
"the",
"data",
"has",
"been",
"written",
"and",
"stores",
"the",
"resulting",
"object",
"id",
"in",
"the",
"stream",
"s",
"Id",
"field",
"."
] |
bf1e8a4338822ad2539a3876f58b15b590eb9e1f
|
https://github.com/libgit2/git2go/blob/bf1e8a4338822ad2539a3876f58b15b590eb9e1f/odb.go#L346-L357
|
151,195 |
libgit2/git2go
|
credentials.go
|
NewCredSshKey
|
func NewCredSshKey(username string, publicKeyPath string, privateKeyPath string, passphrase string) (int, Cred) {
cred := Cred{}
cusername := C.CString(username)
defer C.free(unsafe.Pointer(cusername))
cpublickey := C.CString(publicKeyPath)
defer C.free(unsafe.Pointer(cpublickey))
cprivatekey := C.CString(privateKeyPath)
defer C.free(unsafe.Pointer(cprivatekey))
cpassphrase := C.CString(passphrase)
defer C.free(unsafe.Pointer(cpassphrase))
ret := C.git_cred_ssh_key_new(&cred.ptr, cusername, cpublickey, cprivatekey, cpassphrase)
return int(ret), cred
}
|
go
|
func NewCredSshKey(username string, publicKeyPath string, privateKeyPath string, passphrase string) (int, Cred) {
cred := Cred{}
cusername := C.CString(username)
defer C.free(unsafe.Pointer(cusername))
cpublickey := C.CString(publicKeyPath)
defer C.free(unsafe.Pointer(cpublickey))
cprivatekey := C.CString(privateKeyPath)
defer C.free(unsafe.Pointer(cprivatekey))
cpassphrase := C.CString(passphrase)
defer C.free(unsafe.Pointer(cpassphrase))
ret := C.git_cred_ssh_key_new(&cred.ptr, cusername, cpublickey, cprivatekey, cpassphrase)
return int(ret), cred
}
|
[
"func",
"NewCredSshKey",
"(",
"username",
"string",
",",
"publicKeyPath",
"string",
",",
"privateKeyPath",
"string",
",",
"passphrase",
"string",
")",
"(",
"int",
",",
"Cred",
")",
"{",
"cred",
":=",
"Cred",
"{",
"}",
"\n",
"cusername",
":=",
"C",
".",
"CString",
"(",
"username",
")",
"\n",
"defer",
"C",
".",
"free",
"(",
"unsafe",
".",
"Pointer",
"(",
"cusername",
")",
")",
"\n",
"cpublickey",
":=",
"C",
".",
"CString",
"(",
"publicKeyPath",
")",
"\n",
"defer",
"C",
".",
"free",
"(",
"unsafe",
".",
"Pointer",
"(",
"cpublickey",
")",
")",
"\n",
"cprivatekey",
":=",
"C",
".",
"CString",
"(",
"privateKeyPath",
")",
"\n",
"defer",
"C",
".",
"free",
"(",
"unsafe",
".",
"Pointer",
"(",
"cprivatekey",
")",
")",
"\n",
"cpassphrase",
":=",
"C",
".",
"CString",
"(",
"passphrase",
")",
"\n",
"defer",
"C",
".",
"free",
"(",
"unsafe",
".",
"Pointer",
"(",
"cpassphrase",
")",
")",
"\n",
"ret",
":=",
"C",
".",
"git_cred_ssh_key_new",
"(",
"&",
"cred",
".",
"ptr",
",",
"cusername",
",",
"cpublickey",
",",
"cprivatekey",
",",
"cpassphrase",
")",
"\n",
"return",
"int",
"(",
"ret",
")",
",",
"cred",
"\n",
"}"
] |
// NewCredSshKey creates new ssh credentials reading the public and private keys
// from the file system.
|
[
"NewCredSshKey",
"creates",
"new",
"ssh",
"credentials",
"reading",
"the",
"public",
"and",
"private",
"keys",
"from",
"the",
"file",
"system",
"."
] |
bf1e8a4338822ad2539a3876f58b15b590eb9e1f
|
https://github.com/libgit2/git2go/blob/bf1e8a4338822ad2539a3876f58b15b590eb9e1f/credentials.go#L49-L61
|
151,196 |
libgit2/git2go
|
credentials.go
|
NewCredSshKeyFromMemory
|
func NewCredSshKeyFromMemory(username string, publicKey string, privateKey string, passphrase string) (int, Cred) {
cred := Cred{}
cusername := C.CString(username)
defer C.free(unsafe.Pointer(cusername))
cpublickey := C.CString(publicKey)
defer C.free(unsafe.Pointer(cpublickey))
cprivatekey := C.CString(privateKey)
defer C.free(unsafe.Pointer(cprivatekey))
cpassphrase := C.CString(passphrase)
defer C.free(unsafe.Pointer(cpassphrase))
ret := C.git_cred_ssh_key_memory_new(&cred.ptr, cusername, cpublickey, cprivatekey, cpassphrase)
return int(ret), cred
}
|
go
|
func NewCredSshKeyFromMemory(username string, publicKey string, privateKey string, passphrase string) (int, Cred) {
cred := Cred{}
cusername := C.CString(username)
defer C.free(unsafe.Pointer(cusername))
cpublickey := C.CString(publicKey)
defer C.free(unsafe.Pointer(cpublickey))
cprivatekey := C.CString(privateKey)
defer C.free(unsafe.Pointer(cprivatekey))
cpassphrase := C.CString(passphrase)
defer C.free(unsafe.Pointer(cpassphrase))
ret := C.git_cred_ssh_key_memory_new(&cred.ptr, cusername, cpublickey, cprivatekey, cpassphrase)
return int(ret), cred
}
|
[
"func",
"NewCredSshKeyFromMemory",
"(",
"username",
"string",
",",
"publicKey",
"string",
",",
"privateKey",
"string",
",",
"passphrase",
"string",
")",
"(",
"int",
",",
"Cred",
")",
"{",
"cred",
":=",
"Cred",
"{",
"}",
"\n",
"cusername",
":=",
"C",
".",
"CString",
"(",
"username",
")",
"\n",
"defer",
"C",
".",
"free",
"(",
"unsafe",
".",
"Pointer",
"(",
"cusername",
")",
")",
"\n",
"cpublickey",
":=",
"C",
".",
"CString",
"(",
"publicKey",
")",
"\n",
"defer",
"C",
".",
"free",
"(",
"unsafe",
".",
"Pointer",
"(",
"cpublickey",
")",
")",
"\n",
"cprivatekey",
":=",
"C",
".",
"CString",
"(",
"privateKey",
")",
"\n",
"defer",
"C",
".",
"free",
"(",
"unsafe",
".",
"Pointer",
"(",
"cprivatekey",
")",
")",
"\n",
"cpassphrase",
":=",
"C",
".",
"CString",
"(",
"passphrase",
")",
"\n",
"defer",
"C",
".",
"free",
"(",
"unsafe",
".",
"Pointer",
"(",
"cpassphrase",
")",
")",
"\n",
"ret",
":=",
"C",
".",
"git_cred_ssh_key_memory_new",
"(",
"&",
"cred",
".",
"ptr",
",",
"cusername",
",",
"cpublickey",
",",
"cprivatekey",
",",
"cpassphrase",
")",
"\n",
"return",
"int",
"(",
"ret",
")",
",",
"cred",
"\n",
"}"
] |
// NewCredSshKeyFromMemory creates new ssh credentials using the publicKey and privateKey
// arguments as the values for the public and private keys.
|
[
"NewCredSshKeyFromMemory",
"creates",
"new",
"ssh",
"credentials",
"using",
"the",
"publicKey",
"and",
"privateKey",
"arguments",
"as",
"the",
"values",
"for",
"the",
"public",
"and",
"private",
"keys",
"."
] |
bf1e8a4338822ad2539a3876f58b15b590eb9e1f
|
https://github.com/libgit2/git2go/blob/bf1e8a4338822ad2539a3876f58b15b590eb9e1f/credentials.go#L65-L77
|
151,197 |
uber-go/fx
|
shutdown.go
|
Shutdown
|
func (s *shutdowner) Shutdown(opts ...ShutdownOption) error {
return s.app.broadcastSignal(syscall.SIGTERM)
}
|
go
|
func (s *shutdowner) Shutdown(opts ...ShutdownOption) error {
return s.app.broadcastSignal(syscall.SIGTERM)
}
|
[
"func",
"(",
"s",
"*",
"shutdowner",
")",
"Shutdown",
"(",
"opts",
"...",
"ShutdownOption",
")",
"error",
"{",
"return",
"s",
".",
"app",
".",
"broadcastSignal",
"(",
"syscall",
".",
"SIGTERM",
")",
"\n",
"}"
] |
// Shutdown broadcasts a signal to all of the application's Done channels
// and begins the Stop process.
|
[
"Shutdown",
"broadcasts",
"a",
"signal",
"to",
"all",
"of",
"the",
"application",
"s",
"Done",
"channels",
"and",
"begins",
"the",
"Stop",
"process",
"."
] |
544d97a6e020226621cefffcbc38a9e2d320584c
|
https://github.com/uber-go/fx/blob/544d97a6e020226621cefffcbc38a9e2d320584c/shutdown.go#L49-L51
|
151,198 |
uber-go/fx
|
internal/lifecycle/lifecycle.go
|
New
|
func New(logger *fxlog.Logger) *Lifecycle {
if logger == nil {
logger = fxlog.New()
}
return &Lifecycle{logger: logger}
}
|
go
|
func New(logger *fxlog.Logger) *Lifecycle {
if logger == nil {
logger = fxlog.New()
}
return &Lifecycle{logger: logger}
}
|
[
"func",
"New",
"(",
"logger",
"*",
"fxlog",
".",
"Logger",
")",
"*",
"Lifecycle",
"{",
"if",
"logger",
"==",
"nil",
"{",
"logger",
"=",
"fxlog",
".",
"New",
"(",
")",
"\n",
"}",
"\n",
"return",
"&",
"Lifecycle",
"{",
"logger",
":",
"logger",
"}",
"\n",
"}"
] |
// New constructs a new Lifecycle.
|
[
"New",
"constructs",
"a",
"new",
"Lifecycle",
"."
] |
544d97a6e020226621cefffcbc38a9e2d320584c
|
https://github.com/uber-go/fx/blob/544d97a6e020226621cefffcbc38a9e2d320584c/internal/lifecycle/lifecycle.go#L47-L52
|
151,199 |
uber-go/fx
|
internal/lifecycle/lifecycle.go
|
Append
|
func (l *Lifecycle) Append(hook Hook) {
hook.caller = fxreflect.Caller()
l.hooks = append(l.hooks, hook)
}
|
go
|
func (l *Lifecycle) Append(hook Hook) {
hook.caller = fxreflect.Caller()
l.hooks = append(l.hooks, hook)
}
|
[
"func",
"(",
"l",
"*",
"Lifecycle",
")",
"Append",
"(",
"hook",
"Hook",
")",
"{",
"hook",
".",
"caller",
"=",
"fxreflect",
".",
"Caller",
"(",
")",
"\n",
"l",
".",
"hooks",
"=",
"append",
"(",
"l",
".",
"hooks",
",",
"hook",
")",
"\n",
"}"
] |
// Append adds a Hook to the lifecycle.
|
[
"Append",
"adds",
"a",
"Hook",
"to",
"the",
"lifecycle",
"."
] |
544d97a6e020226621cefffcbc38a9e2d320584c
|
https://github.com/uber-go/fx/blob/544d97a6e020226621cefffcbc38a9e2d320584c/internal/lifecycle/lifecycle.go#L55-L58
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.