_id stringlengths 2 7 | title stringlengths 1 118 | partition stringclasses 3 values | text stringlengths 52 85.5k | language stringclasses 1 value | meta_information dict |
|---|---|---|---|---|---|
q9100 | MaxDuration | train | func (ta *TrackAttributes) MaxDuration(duration int) *TrackAttributes {
ta.intAttributes["max_duration_ms"] = duration
return ta
} | go | {
"resource": ""
} |
q9101 | MinDuration | train | func (ta *TrackAttributes) MinDuration(duration int) *TrackAttributes {
ta.intAttributes["min_duration_ms"] = duration
return ta
} | go | {
"resource": ""
} |
q9102 | TargetDuration | train | func (ta *TrackAttributes) TargetDuration(duration int) *TrackAttributes {
ta.intAttributes["target_duration_ms"] = duration
return ta
} | go | {
"resource": ""
} |
q9103 | MaxEnergy | train | func (ta *TrackAttributes) MaxEnergy(energy float64) *TrackAttributes {
ta.floatAttributes["max_energy"] = energy
return ta
} | go | {
"resource": ""
} |
q9104 | MinEnergy | train | func (ta *TrackAttributes) MinEnergy(energy float64) *TrackAttributes {
ta.floatAttributes["min_energy"] = energy
return ta
} | go | {
"resource": ""
} |
q9105 | TargetEnergy | train | func (ta *TrackAttributes) TargetEnergy(energy float64) *TrackAttributes {
ta.floatAttributes["target_energy"] = energy
return ta
} | go | {
"resource": ""
} |
q9106 | MaxInstrumentalness | train | func (ta *TrackAttributes) MaxInstrumentalness(instrumentalness float64) *TrackAttributes {
ta.floatAttributes["max_instrumentalness"] = instrumentalness
return ta
} | go | {
"resource": ""
} |
q9107 | MinInstrumentalness | train | func (ta *TrackAttributes) MinInstrumentalness(instrumentalness float64) *TrackAttributes {
ta.floatAttributes["min_instrumentalness"] = instrumentalness
return ta
} | go | {
"resource": ""
} |
q9108 | TargetInstrumentalness | train | func (ta *TrackAttributes) TargetInstrumentalness(instrumentalness float64) *TrackAttributes {
ta.floatAttributes["target_instrumentalness"] = instrumentalness
return ta
} | go | {
"resource": ""
} |
q9109 | MaxLiveness | train | func (ta *TrackAttributes) MaxLiveness(liveness float64) *TrackAttributes {
ta.floatAttributes["max_liveness"] = liveness
return ta
} | go | {
"resource": ""
} |
q9110 | MinLiveness | train | func (ta *TrackAttributes) MinLiveness(liveness float64) *TrackAttributes {
ta.floatAttributes["min_liveness"] = liveness
return ta
} | go | {
"resource": ""
} |
q9111 | TargetLiveness | train | func (ta *TrackAttributes) TargetLiveness(liveness float64) *TrackAttributes {
ta.floatAttributes["target_liveness"] = liveness
return ta
} | go | {
"resource": ""
} |
q9112 | MaxSpeechiness | train | func (ta *TrackAttributes) MaxSpeechiness(speechiness float64) *TrackAttributes {
ta.floatAttributes["max_speechiness"] = speechiness
return ta
} | go | {
"resource": ""
} |
q9113 | MinSpeechiness | train | func (ta *TrackAttributes) MinSpeechiness(speechiness float64) *TrackAttributes {
ta.floatAttributes["min_speechiness"] = speechiness
return ta
} | go | {
"resource": ""
} |
q9114 | TargetSpeechiness | train | func (ta *TrackAttributes) TargetSpeechiness(speechiness float64) *TrackAttributes {
ta.floatAttributes["target_speechiness"] = speechiness
return ta
} | go | {
"resource": ""
} |
q9115 | GetAudioAnalysis | train | func (c *Client) GetAudioAnalysis(id ID) (*AudioAnalysis, error) {
url := fmt.Sprintf("%saudio-analysis/%s", c.baseURL, id)
temp := AudioAnalysis{}
err := c.get(url, &temp)
if err != nil {
return nil, err
}
return &temp, nil
} | go | {
"resource": ""
} |
q9116 | NextArtistResults | train | func (c *Client) NextArtistResults(s *SearchResult) error {
if s.Artists == nil || s.Artists.Next == "" {
return ErrNoMorePages
}
return c.get(s.Artists.Next, s)
} | go | {
"resource": ""
} |
q9117 | PreviousArtistResults | train | func (c *Client) PreviousArtistResults(s *SearchResult) error {
if s.Artists == nil || s.Artists.Previous == "" {
return ErrNoMorePages
}
return c.get(s.Artists.Previous, s)
} | go | {
"resource": ""
} |
q9118 | NextAlbumResults | train | func (c *Client) NextAlbumResults(s *SearchResult) error {
if s.Albums == nil || s.Albums.Next == "" {
return ErrNoMorePages
}
return c.get(s.Albums.Next, s)
} | go | {
"resource": ""
} |
q9119 | PreviousAlbumResults | train | func (c *Client) PreviousAlbumResults(s *SearchResult) error {
if s.Albums == nil || s.Albums.Previous == "" {
return ErrNoMorePages
}
return c.get(s.Albums.Previous, s)
} | go | {
"resource": ""
} |
q9120 | NextPlaylistResults | train | func (c *Client) NextPlaylistResults(s *SearchResult) error {
if s.Playlists == nil || s.Playlists.Next == "" {
return ErrNoMorePages
}
return c.get(s.Playlists.Next, s)
} | go | {
"resource": ""
} |
q9121 | PreviousPlaylistResults | train | func (c *Client) PreviousPlaylistResults(s *SearchResult) error {
if s.Playlists == nil || s.Playlists.Previous == "" {
return ErrNoMorePages
}
return c.get(s.Playlists.Previous, s)
} | go | {
"resource": ""
} |
q9122 | PreviousTrackResults | train | func (c *Client) PreviousTrackResults(s *SearchResult) error {
if s.Tracks == nil || s.Tracks.Previous == "" {
return ErrNoMorePages
}
return c.get(s.Tracks.Previous, s)
} | go | {
"resource": ""
} |
q9123 | NextTrackResults | train | func (c *Client) NextTrackResults(s *SearchResult) error {
if s.Tracks == nil || s.Tracks.Next == "" {
return ErrNoMorePages
}
return c.get(s.Tracks.Next, s)
} | go | {
"resource": ""
} |
q9124 | TimeDuration | train | func (t *SimpleTrack) TimeDuration() time.Duration {
return time.Duration(t.Duration) * time.Millisecond
} | go | {
"resource": ""
} |
q9125 | GetTrack | train | func (c *Client) GetTrack(id ID) (*FullTrack, error) {
spotifyURL := c.baseURL + "tracks/" + string(id)
var t FullTrack
err := c.get(spotifyURL, &t)
if err != nil {
return nil, err
}
return &t, nil
} | go | {
"resource": ""
} |
q9126 | GetTracks | train | func (c *Client) GetTracks(ids ...ID) ([]*FullTrack, error) {
if len(ids) > 50 {
return nil, errors.New("spotify: FindTracks supports up to 50 tracks")
}
spotifyURL := c.baseURL + "tracks?ids=" + strings.Join(toStringSlice(ids), ",")
var t struct {
Tracks []*FullTrack `json:"tracks"`
}
err := c.get(spotifyURL, &t)
if err != nil {
return nil, err
}
return t.Tracks, nil
} | go | {
"resource": ""
} |
q9127 | GetAudioFeatures | train | func (c *Client) GetAudioFeatures(ids ...ID) ([]*AudioFeatures, error) {
url := fmt.Sprintf("%saudio-features?ids=%s", c.baseURL, strings.Join(toStringSlice(ids), ","))
temp := struct {
F []*AudioFeatures `json:"audio_features"`
}{}
err := c.get(url, &temp)
if err != nil {
return nil, err
}
return temp.F, nil
} | go | {
"resource": ""
} |
q9128 | count | train | func (s Seeds) count() int {
return len(s.Artists) + len(s.Tracks) + len(s.Genres)
} | go | {
"resource": ""
} |
q9129 | setSeedValues | train | func setSeedValues(seeds Seeds, v url.Values) {
if len(seeds.Artists) != 0 {
v.Set("seed_artists", strings.Join(toStringSlice(seeds.Artists), ","))
}
if len(seeds.Tracks) != 0 {
v.Set("seed_tracks", strings.Join(toStringSlice(seeds.Tracks), ","))
}
if len(seeds.Genres) != 0 {
v.Set("seed_genres", strings.Join(seeds.Genres, ","))
}
} | go | {
"resource": ""
} |
q9130 | setTrackAttributesValues | train | func setTrackAttributesValues(trackAttributes *TrackAttributes, values url.Values) {
if trackAttributes == nil {
return
}
for attr, val := range trackAttributes.intAttributes {
values.Set(attr, strconv.Itoa(val))
}
for attr, val := range trackAttributes.floatAttributes {
values.Set(attr, strconv.FormatFloat(val, 'f', -1, 64))
}
} | go | {
"resource": ""
} |
q9131 | GetRecommendations | train | func (c *Client) GetRecommendations(seeds Seeds, trackAttributes *TrackAttributes, opt *Options) (*Recommendations, error) {
v := url.Values{}
if seeds.count() == 0 {
return nil, fmt.Errorf("spotify: at least one seed is required")
}
if seeds.count() > MaxNumberOfSeeds {
return nil, fmt.Errorf("spotify: exceeded maximum of %d seeds", MaxNumberOfSeeds)
}
setSeedValues(seeds, v)
setTrackAttributesValues(trackAttributes, v)
if opt != nil {
if opt.Limit != nil {
v.Set("limit", strconv.Itoa(*opt.Limit))
}
if opt.Country != nil {
v.Set("market", *opt.Country)
}
}
spotifyURL := c.baseURL + "recommendations?" + v.Encode()
var recommendations Recommendations
err := c.get(spotifyURL, &recommendations)
if err != nil {
return nil, err
}
return &recommendations, err
} | go | {
"resource": ""
} |
q9132 | GetAvailableGenreSeeds | train | func (c *Client) GetAvailableGenreSeeds() ([]string, error) {
spotifyURL := c.baseURL + "recommendations/available-genre-seeds"
genreSeeds := make(map[string][]string)
err := c.get(spotifyURL, &genreSeeds)
if err != nil {
return nil, err
}
return genreSeeds["genres"], nil
} | go | {
"resource": ""
} |
q9133 | Download | train | func (i Image) Download(dst io.Writer) error {
resp, err := http.Get(i.URL)
if err != nil {
return err
}
defer resp.Body.Close()
// TODO: get Content-Type from header?
if resp.StatusCode != http.StatusOK {
return errors.New("Couldn't download image - HTTP" + strconv.Itoa(resp.StatusCode))
}
_, err = io.Copy(dst, resp.Body)
return err
} | go | {
"resource": ""
} |
q9134 | decodeError | train | func (c *Client) decodeError(resp *http.Response) error {
responseBody, err := ioutil.ReadAll(resp.Body)
if err != nil {
return err
}
if len(responseBody) == 0 {
return fmt.Errorf("spotify: HTTP %d: %s (body empty)", resp.StatusCode, http.StatusText(resp.StatusCode))
}
buf := bytes.NewBuffer(responseBody)
var e struct {
E Error `json:"error"`
}
err = json.NewDecoder(buf).Decode(&e)
if err != nil {
return fmt.Errorf("spotify: couldn't decode error: (%d) [%s]", len(responseBody), responseBody)
}
if e.E.Message == "" {
// Some errors will result in there being a useful status-code but an
// empty message, which will confuse the user (who only has access to
// the message and not the code). An example of this is when we send
// some of the arguments directly in the HTTP query and the URL ends-up
// being too long.
e.E.Message = fmt.Sprintf("spotify: unexpected HTTP %d: %s (empty error)",
resp.StatusCode, http.StatusText(resp.StatusCode))
}
return e.E
} | go | {
"resource": ""
} |
q9135 | shouldRetry | train | func shouldRetry(status int) bool {
return status == http.StatusAccepted || status == http.StatusTooManyRequests
} | go | {
"resource": ""
} |
q9136 | isFailure | train | func isFailure(code int, validCodes []int) bool {
for _, item := range validCodes {
if item == code {
return false
}
}
return true
} | go | {
"resource": ""
} |
q9137 | execute | train | func (c *Client) execute(req *http.Request, result interface{}, needsStatus ...int) error {
for {
resp, err := c.http.Do(req)
if err != nil {
return err
}
defer resp.Body.Close()
if c.AutoRetry && shouldRetry(resp.StatusCode) {
time.Sleep(retryDuration(resp))
continue
}
if resp.StatusCode != http.StatusOK && isFailure(resp.StatusCode, needsStatus) {
return c.decodeError(resp)
}
if result != nil {
if err := json.NewDecoder(resp.Body).Decode(result); err != nil {
return err
}
}
break
}
return nil
} | go | {
"resource": ""
} |
q9138 | NewReleasesOpt | train | func (c *Client) NewReleasesOpt(opt *Options) (albums *SimpleAlbumPage, err error) {
spotifyURL := c.baseURL + "browse/new-releases"
if opt != nil {
v := url.Values{}
if opt.Country != nil {
v.Set("country", *opt.Country)
}
if opt.Limit != nil {
v.Set("limit", strconv.Itoa(*opt.Limit))
}
if opt.Offset != nil {
v.Set("offset", strconv.Itoa(*opt.Offset))
}
if params := v.Encode(); params != "" {
spotifyURL += "?" + params
}
}
var objmap map[string]*json.RawMessage
err = c.get(spotifyURL, &objmap)
if err != nil {
return nil, err
}
var result SimpleAlbumPage
err = json.Unmarshal(*objmap["albums"], &result)
if err != nil {
return nil, err
}
return &result, nil
} | go | {
"resource": ""
} |
q9139 | NewReleases | train | func (c *Client) NewReleases() (albums *SimpleAlbumPage, err error) {
return c.NewReleasesOpt(nil)
} | go | {
"resource": ""
} |
q9140 | Check | train | func Check(g Iterator) Stats {
if g, ok := g.(*Immutable); ok {
return g.stats
}
_, mutable := g.(*Mutable)
n := g.Order()
degree := make([]int, n)
type edge struct{ v, w int }
edges := make(map[edge]bool)
var stats Stats
for v := 0; v < n; v++ {
g.Visit(v, func(w int, c int64) (skip bool) {
if w < 0 || w >= n {
panic("vertex out of range: " + strconv.Itoa(w))
}
if v == w {
stats.Loops++
}
if c != 0 {
stats.Weighted++
}
degree[v]++
if mutable { // A Mutable is never a multigraph.
stats.Size++
return
}
if edges[edge{v, w}] {
stats.Multi++
} else {
stats.Size++
}
edges[edge{v, w}] = true
return
})
}
for _, deg := range degree {
if deg == 0 {
stats.Isolated++
}
}
return stats
} | go | {
"resource": ""
} |
q9141 | Equal | train | func Equal(g, h Iterator) bool {
if g.Order() != h.Order() {
return false
}
edges := make(map[edge]int)
for v := 0; v < g.Order(); v++ {
g.Visit(v, func(w int, c int64) (skip bool) {
edges[edge{v, w, c}]++
return
})
if h.Visit(v, func(w int, c int64) (skip bool) {
if edges[edge{v, w, c}] == 0 {
return true
}
edges[edge{v, w, c}]--
return
}) {
return false
}
for _, n := range edges {
if n > 0 {
return false
}
}
}
return true
} | go | {
"resource": ""
} |
q9142 | Subgraph | train | func (g *Virtual) Subgraph(s VertexSet) *Virtual {
n := g.Order()
s = s.And(Range(0, n))
m := s.size()
switch {
case m == 0:
return null
case m == 1:
return singleton()
case m == n:
return g
}
cost := func(v, w int) int64 {
return g.cost(s.get(v), s.get(w))
}
res := generic(m, cost, func(v, w int) bool {
return g.edge(s.get(v), s.get(w))
})
res.visit = func(v int, a int, do func(w int, c int64) bool) (aborted bool) {
if a >= m {
return
}
v0 := s.get(v)
s0 := s.And(Range(s.get(a), n))
for _, in := range s0.set {
if more := false; g.visit(v0, in.a, func(w0 int, c int64) (skip bool) {
switch {
case w0 >= in.b:
more, skip = true, true
return
case do(s.rank(w0), c):
return true
default:
return
}
}) && !more {
return true
}
}
return
}
return res
} | go | {
"resource": ""
} |
q9143 | StrongComponents | train | func StrongComponents(g Iterator) [][]int {
n := g.Order()
s := &scc{
graph: g,
visited: make([]bool, n),
lowLink: make([]int, n),
}
components := [][]int{}
for v := range s.visited {
if !s.visited[v] {
components = s.append(components, v)
}
}
return components
} | go | {
"resource": ""
} |
q9144 | append | train | func (s *scc) append(components [][]int, v int) [][]int {
// A vertex remains on this stack after it has been visited iff
// there is a path from it to some vertex earlier on the stack.
s.stack = append(s.stack, v)
// lowLink[v] is the smallest vertex known to be reachable from v.
s.lowLink[v] = s.time
s.time++
newComponent := true
s.visited[v] = true
s.graph.Visit(v, func(w int, _ int64) (skip bool) {
if !s.visited[w] {
components = s.append(components, w)
}
if s.lowLink[v] > s.lowLink[w] {
s.lowLink[v] = s.lowLink[w]
newComponent = false
}
return
})
if !newComponent {
return components
}
var comp []int
for {
n := len(s.stack) - 1
w := s.stack[n]
s.stack = s.stack[:n]
s.lowLink[w] = int(^uint(0) >> 1) // maxint
comp = append(comp, w)
if v == w {
return append(components, comp)
}
}
} | go | {
"resource": ""
} |
q9145 | find | train | func (g *Virtual) find(v int, a int) (w int, n int) {
prev := -1
g.visit(v, a, func(w0 int, c0 int64) (skip bool) {
switch prev {
case -1:
w, n = w0, 1
prev = w0
return
case w0 - 1:
n += 1
prev = w0
return
}
return true
})
return
} | go | {
"resource": ""
} |
q9146 | New | train | func New(n int) *Mutable {
return &Mutable{edges: make([]map[int]int64, n)}
} | go | {
"resource": ""
} |
q9147 | Copy | train | func Copy(g Iterator) *Mutable {
switch g := g.(type) {
case *Mutable:
return copyMutable(g)
case *Immutable:
return copyImmutable(g)
}
n := g.Order()
h := New(n)
for v := 0; v < n; v++ {
g.Visit(v, func(w int, c int64) (skip bool) {
h.AddCost(v, w, c)
return
})
}
return h
} | go | {
"resource": ""
} |
q9148 | Visit | train | func (g *Mutable) Visit(v int, do func(w int, c int64) bool) bool {
for w, c := range g.edges[v] {
if do(w, c) {
return true
}
}
return false
} | go | {
"resource": ""
} |
q9149 | Add | train | func (g *Mutable) Add(v, w int) {
g.AddCost(v, w, 0)
} | go | {
"resource": ""
} |
q9150 | AddCost | train | func (g *Mutable) AddCost(v, w int, c int64) {
// Make sure not to break internal state.
if w < 0 || w >= len(g.edges) {
panic("vertex out of range: " + strconv.Itoa(w))
}
if g.edges[v] == nil {
g.edges[v] = make(map[int]int64, initialMapSize)
}
g.edges[v][w] = c
} | go | {
"resource": ""
} |
q9151 | AddBoth | train | func (g *Mutable) AddBoth(v, w int) {
g.AddCost(v, w, 0)
if v != w {
g.AddCost(w, v, 0)
}
} | go | {
"resource": ""
} |
q9152 | AddBothCost | train | func (g *Mutable) AddBothCost(v, w int, c int64) {
g.AddCost(v, w, c)
if v != w {
g.AddCost(w, v, c)
}
} | go | {
"resource": ""
} |
q9153 | Delete | train | func (g *Mutable) Delete(v, w int) {
delete(g.edges[v], w)
} | go | {
"resource": ""
} |
q9154 | DeleteBoth | train | func (g *Mutable) DeleteBoth(v, w int) {
g.Delete(v, w)
if v != w {
g.Delete(w, v)
}
} | go | {
"resource": ""
} |
q9155 | TopSort | train | func TopSort(g Iterator) (order []int, ok bool) {
order, ok = topsort(g, true)
return
} | go | {
"resource": ""
} |
q9156 | Acyclic | train | func Acyclic(g Iterator) bool {
_, acyclic := topsort(g, false)
return acyclic
} | go | {
"resource": ""
} |
q9157 | topsort | train | func topsort(g Iterator, output bool) (order []int, acyclic bool) {
indegree := make([]int, g.Order())
for v := range indegree {
g.Visit(v, func(w int, _ int64) (skip bool) {
indegree[w]++
return
})
}
// Invariant: this queue holds all vertices with indegree 0.
var queue []int
for v, degree := range indegree {
if degree == 0 {
queue = append(queue, v)
}
}
order = []int{}
vertexCount := 0
for len(queue) > 0 {
v := queue[0]
queue = queue[1:]
if output {
order = append(order, v)
}
vertexCount++
g.Visit(v, func(w int, _ int64) (skip bool) {
indegree[w]--
if indegree[w] == 0 {
queue = append(queue, w)
}
return
})
}
if vertexCount != g.Order() {
return
}
acyclic = true
return
} | go | {
"resource": ""
} |
q9158 | EulerDirected | train | func EulerDirected(g Iterator) (walk []int, ok bool) {
n := g.Order()
degree := make([]int, n) // outdegree - indegree for each vertex
edgeCount := 0
for v := range degree {
g.Visit(v, func(w int, _ int64) (skip bool) {
edgeCount++
degree[v]++
degree[w]--
return
})
}
if edgeCount == 0 {
return []int{}, true
}
start, end := -1, -1
for v := range degree {
switch {
case degree[v] == 0:
case degree[v] == 1 && start == -1:
start = v
case degree[v] == -1 && end == -1:
end = v
default:
return []int{}, false
}
}
// Make a copy of g
h := make([][]int, n)
for v := range h {
g.Visit(v, func(w int, _ int64) (skip bool) {
h[v] = append(h[v], w)
return
})
}
// Find a starting point with neighbors.
if start == -1 {
for v, neighbors := range h {
if len(neighbors) > 0 {
start = v
break
}
}
}
for stack := []int{start}; len(stack) > 0; {
n := len(stack)
v := stack[n-1]
stack = stack[:n-1]
for len(h[v]) > 0 {
stack = append(stack, v)
v, h[v] = h[v][0], h[v][1:]
edgeCount--
}
walk = append(walk, v)
}
if edgeCount > 0 {
return []int{}, false
}
for i, j := 0, len(walk)-1; i < j; i, j = i+1, j-1 {
walk[i], walk[j] = walk[j], walk[i]
}
return walk, true
} | go | {
"resource": ""
} |
q9159 | EulerUndirected | train | func EulerUndirected(g Iterator) (walk []int, ok bool) {
n := g.Order()
out := make([]int, n) // outdegree for each vertex
edgeCount := 0
for v := range out {
g.Visit(v, func(w int, _ int64) (skip bool) {
edgeCount++
if v != w {
out[v]++
}
return
})
}
if edgeCount == 0 {
return []int{}, true
}
start, oddDeg := -1, 0
for v := range out {
if out[v]&1 == 1 {
start = v
oddDeg++
}
}
if !(oddDeg == 0 || oddDeg == 2) {
return []int{}, false
}
// Find a starting point with neighbors.
if start == -1 {
for v := 0; v < n; v++ {
if g.Visit(v, func(w int, _ int64) (skip bool) {
start = w
return true
}) {
break
}
}
}
h := Copy(g)
for stack := []int{start}; len(stack) > 0; {
n := len(stack)
v := stack[n-1]
stack = stack[:n-1]
for h.Degree(v) > 0 {
stack = append(stack, v)
var w int
h.Visit(v, func(u int, _ int64) (skip bool) {
w = u
return true
})
h.DeleteBoth(v, w)
edgeCount--
if v != w {
edgeCount--
}
v = w
}
walk = append(walk, v)
}
if edgeCount > 0 {
return []int{}, false
}
return walk, true
} | go | {
"resource": ""
} |
q9160 | Add | train | func (g *Virtual) Add(e EdgeSet) *Virtual {
return g.union(newEdges(g.Order(), e), true)
} | go | {
"resource": ""
} |
q9161 | Delete | train | func (g *Virtual) Delete(e EdgeSet) *Virtual {
return g.Keep(func(v, w int) bool {
return !e.Contains(v, w)
})
} | go | {
"resource": ""
} |
q9162 | Sort | train | func Sort(g Iterator) *Immutable {
if g, ok := g.(*Immutable); ok {
return g
}
return build(g, false)
} | go | {
"resource": ""
} |
q9163 | singleton | train | func singleton() *Virtual {
return &Virtual{
order: 1,
edge: neverEdge,
cost: zero,
degree: degreeZero,
visit: noNeighbors,
}
} | go | {
"resource": ""
} |
q9164 | generic | train | func generic(n int, cost CostFunc, edge func(v, w int) bool) *Virtual {
switch {
case n < 0:
return nil
case n == 0:
return null
case n == 1:
return singleton()
}
g := &Virtual{
order: n,
edge: func(v, w int) bool { return v != w && edge(v, w) },
cost: cost,
}
g.degree = func(v int) (deg int) {
g.visit(v, 0, func(int, int64) (skip bool) {
deg++
return
})
return
}
g.visit = func(v int, a int, do func(w int, c int64) bool) (aborted bool) {
for w := a; w < n; w++ {
if g.edge(v, w) && do(w, cost(v, w)) {
return true
}
}
return
}
return g
} | go | {
"resource": ""
} |
q9165 | Specific | train | func Specific(g graph.Iterator) *Virtual {
h := graph.Sort(g)
stats := graph.Check(h)
if stats.Multi != 0 || stats.Loops != 0 {
panic("Virtual doesn't support multiple edges or self-loops")
}
res := &Virtual{
order: h.Order(),
edge: h.Edge,
visit: h.VisitFrom,
degree: h.Degree,
}
if stats.Weighted == 0 {
res.cost = zero
return res
}
res.cost = func(v, w int) (cost int64) {
if !h.Edge(v, w) {
return 0
}
h.VisitFrom(v, w, func(w int, c int64) (skip bool) {
cost = c
return true
})
return
}
return res
} | go | {
"resource": ""
} |
q9166 | Empty | train | func Empty(n int) *Virtual {
switch {
case n < 0:
return nil
case n == 0:
return null
case n == 1:
return singleton()
}
return &Virtual{
order: n,
edge: neverEdge,
cost: zero,
degree: degreeZero,
visit: noNeighbors,
}
} | go | {
"resource": ""
} |
q9167 | Kn | train | func Kn(n int) *Virtual {
switch {
case n < 0:
return nil
case n == 0:
return null
case n == 1:
return singleton()
}
g := &Virtual{
order: n,
edge: alwaysEdge,
cost: zero,
degree: func(v int) int { return n - 1 },
}
g.visit = func(v int, a int, do func(w int, c int64) bool) (aborted bool) {
for w := a; w < g.order; w++ {
if v != w && do(w, 0) {
return true
}
}
return
}
return g
} | go | {
"resource": ""
} |
q9168 | Complement | train | func (g *Virtual) Complement() *Virtual {
n := g.order
switch n {
case 0:
return null
case 1:
return singleton()
}
res := generic0(n, func(v, w int) (edge bool) {
return v != w && !g.edge(v, w)
})
res.degree = func(v int) int { return n - 1 - g.degree(v) }
res.visit = func(v int, a int, do func(w int, c int64) bool) (aborted bool) {
prev := a
if g.visit(v, a, func(w0 int, _ int64) (skip bool) {
for w := prev; w < w0; w++ {
if v != w && do(w, 0) {
return true
}
}
prev = w0 + 1
return
}) {
return true
}
for w := prev; w < n; w++ {
if v != w && do(w, 0) {
return true
}
}
return
}
return res
} | go | {
"resource": ""
} |
q9169 | AddCost | train | func (g *Virtual) AddCost(c int64) *Virtual {
res := *g
res.cost = Cost(c)
res.visit = func(v int, a int, do func(w int, c int64) bool) (aborted bool) {
return g.visit(v, a, func(w int, _ int64) bool {
return do(w, c)
})
}
return &res
} | go | {
"resource": ""
} |
q9170 | AddCostFunc | train | func (g *Virtual) AddCostFunc(c CostFunc) *Virtual {
if c == nil {
h := g.AddCost(0)
return h
}
res := *g
res.cost = c
res.visit = func(v int, a int, do func(w int, c int64) bool) (aborted bool) {
return g.visit(v, a, func(w int, _ int64) bool {
return do(w, c(v, w))
})
}
return &res
} | go | {
"resource": ""
} |
q9171 | Bipartition | train | func Bipartition(g Iterator) (part []int, ok bool) {
type color byte
const (
none color = iota
white
black
)
colors := make([]color, g.Order())
whiteCount := 0
for v := range colors {
if colors[v] != none {
continue
}
colors[v] = white
whiteCount++
for queue := []int{v}; len(queue) > 0; {
v := queue[0]
queue = queue[1:]
if g.Visit(v, func(w int, _ int64) (skip bool) {
switch {
case colors[w] != none:
if colors[v] == colors[w] {
skip = true
}
return
case colors[v] == white:
colors[w] = black
default:
colors[w] = white
whiteCount++
}
queue = append(queue, w)
return
}) {
return []int{}, false
}
}
}
part = make([]int, 0, whiteCount)
for v, color := range colors {
if color == white {
part = append(part, v)
}
}
return part, true
} | go | {
"resource": ""
} |
q9172 | update | train | func (s VertexSet) update() {
prev := 0
for i, in := range s.set {
s.set[i].index = prev
prev += in.b - in.a
}
} | go | {
"resource": ""
} |
q9173 | size | train | func (s VertexSet) size() (size int) {
switch {
case s.set == nil:
return -1
case len(s.set) == 0:
return 0
}
in := s.set[len(s.set)-1]
return in.index + in.b - in.a
} | go | {
"resource": ""
} |
q9174 | rank | train | func (s VertexSet) rank(n int) int {
if len(s.set) == 0 || n < s.set[0].a {
return -1
}
// The smallest index i such that n < set[i].a
i := sort.Search(len(s.set), func(i int) bool {
return n < s.set[i].a
})
in := s.set[i-1]
if n >= in.b {
return -1
}
return in.index + n - in.a
} | go | {
"resource": ""
} |
q9175 | Contains | train | func (s VertexSet) Contains(v int) bool {
switch {
case s.set == nil:
return true
case len(s.set) == 0 || v < s.set[0].a:
return false
}
// The smallest index i such that v < set[i].a
i := sort.Search(len(s.set), func(i int) bool {
return v < s.set[i].a
})
if v >= s.set[i-1].b {
return false
}
return true
} | go | {
"resource": ""
} |
q9176 | AndNot | train | func (s1 VertexSet) AndNot(s2 VertexSet) VertexSet {
return s1.And(s2.complement())
} | go | {
"resource": ""
} |
q9177 | complement | train | func (s VertexSet) complement() VertexSet {
switch {
case s.set == nil:
return empty()
case len(s.set) == 0:
return VertexSet{}
}
t := empty()
prev := minInt
for _, in := range s.set {
if prev != in.a {
t.set = append(t.set, interval{prev, in.a, 0})
}
prev = in.b
}
if prev < maxInt {
t.set = append(t.set, interval{prev, maxInt, 0})
}
t.update()
return t
} | go | {
"resource": ""
} |
q9178 | And | train | func (s1 VertexSet) And(s2 VertexSet) VertexSet {
switch {
case s1.set == nil:
return s2
case s2.set == nil:
return s1
}
type point struct {
x int
a bool // Tells if x is a of [a, b).
}
points := make([]point, 0, 2*(len(s1.set)+len(s2.set)))
for _, in := range s1.set {
points = append(points, point{in.a, true})
points = append(points, point{in.b, false})
}
for _, in := range s2.set {
points = append(points, point{in.a, true})
points = append(points, point{in.b, false})
}
sort.Slice(points, func(i, j int) bool {
if points[i].x == points[j].x {
return !points[i].a
}
return points[i].x < points[j].x
})
s := empty()
start, count := 0, 0
for _, p := range points {
switch count {
case 0:
count++
case 1:
if p.a {
start = p.x
count++
} else {
count--
}
case 2:
s.set = append(s.set, interval{start, p.x, 0})
count--
}
}
s.update()
return s
} | go | {
"resource": ""
} |
q9179 | ServiceGoCode | train | func ServiceGoCode(svc *gen.ServiceMetadata, chars []*gen.CharacteristicMetadata) ([]byte, error) {
var err error
var buf bytes.Buffer
data := ServiceDecl(svc, chars)
t := template.New("Test Template")
t, err = t.Parse(ServiceStructTemplate)
t.Execute(&buf, data)
return buf.Bytes(), err
} | go | {
"resource": ""
} |
q9180 | NewBridge | train | func NewBridge(info Info) *Bridge {
acc := Bridge{}
acc.Accessory = New(info, TypeBridge)
return &acc
} | go | {
"resource": ""
} |
q9181 | NewSetupClientController | train | func NewSetupClientController(pin string, client hap.Device, database db.Database) *SetupClientController {
session := NewSetupClientSession("Pair-Setup", pin)
controller := SetupClientController{
client: client,
session: session,
database: database,
}
return &controller
} | go | {
"resource": ""
} |
q9182 | InitialPairingRequest | train | func (setup *SetupClientController) InitialPairingRequest() io.Reader {
out := util.NewTLV8Container()
out.SetByte(TagPairingMethod, 0)
out.SetByte(TagSequence, PairStepStartRequest.Byte())
return out.BytesBuffer()
} | go | {
"resource": ""
} |
q9183 | NewTemperatureSensor | train | func NewTemperatureSensor(info Info, temp, min, max, steps float64) *Thermometer {
acc := Thermometer{}
acc.Accessory = New(info, TypeThermostat)
acc.TempSensor = service.NewTemperatureSensor()
acc.TempSensor.CurrentTemperature.SetValue(temp)
acc.TempSensor.CurrentTemperature.SetMinValue(min)
acc.TempSensor.CurrentTemperature.SetMaxValue(max)
acc.TempSensor.CurrentTemperature.SetStepValue(steps)
acc.AddService(acc.TempSensor.Service)
return &acc
} | go | {
"resource": ""
} |
q9184 | GeneratePrivateKey | train | func GeneratePrivateKey() [keySize]byte {
var b [keySize]byte
rand.Read(b[:])
return b
} | go | {
"resource": ""
} |
q9185 | PublicKey | train | func PublicKey(privateKey [keySize]byte) [keySize]byte {
var k [keySize]byte
curve25519.ScalarBaseMult(&k, &privateKey)
return k
} | go | {
"resource": ""
} |
q9186 | SharedSecret | train | func SharedSecret(privateKey, otherPublicKey [keySize]byte) [keySize]byte {
var k [keySize]byte
curve25519.ScalarMult(&k, &privateKey, &otherPublicKey)
return k
} | go | {
"resource": ""
} |
q9187 | NewKeepAlive | train | func NewKeepAlive(timeout time.Duration, context Context) *KeepAlive {
k := KeepAlive{
timeout: timeout,
context: context,
}
return &k
} | go | {
"resource": ""
} |
q9188 | Start | train | func (k *KeepAlive) Start(ctx gocontext.Context) {
for {
select {
case <-ctx.Done():
return
case <-time.After(k.timeout):
k.sendKeepAlive()
}
}
} | go | {
"resource": ""
} |
q9189 | NewVerifyClientController | train | func NewVerifyClientController(client hap.Device, database db.Database) *VerifyClientController {
controller := VerifyClientController{
client: client,
database: database,
session: NewVerifySession(),
}
return &controller
} | go | {
"resource": ""
} |
q9190 | Handle | train | func (verify *VerifyClientController) Handle(in util.Container) (util.Container, error) {
var out util.Container
var err error
method := PairMethodType(in.GetByte(TagPairingMethod))
// It is valid that method is not sent
// If method is sent then it must be 0x00
if method != PairingMethodDefault {
return nil, errInvalidPairMethod(method)
}
seq := VerifyStepType(in.GetByte(TagSequence))
switch seq {
case VerifyStepStartResponse:
out, err = verify.handlePairStepVerifyResponse(in)
case VerifyStepFinishResponse:
out, err = verify.handlePairVerifyStepFinishResponse(in)
default:
return nil, errInvalidVerifyStep(seq)
}
return out, err
} | go | {
"resource": ""
} |
q9191 | InitialKeyVerifyRequest | train | func (verify *VerifyClientController) InitialKeyVerifyRequest() io.Reader {
out := util.NewTLV8Container()
out.SetByte(TagPairingMethod, 0)
out.SetByte(TagSequence, VerifyStepStartRequest.Byte())
out.SetBytes(TagPublicKey, verify.session.PublicKey[:])
fmt.Println("<- A:", hex.EncodeToString(out.GetBytes(TagPublicKey)))
return out.BytesBuffer()
} | go | {
"resource": ""
} |
q9192 | NewContextForSecuredDevice | train | func NewContextForSecuredDevice(b SecuredDevice) Context {
ctx := context{
storage: map[interface{}]interface{}{},
mutex: &sync.Mutex{},
}
ctx.SetSecuredDevice(b)
return &ctx
} | go | {
"resource": ""
} |
q9193 | ActiveConnections | train | func (ctx *context) ActiveConnections() []net.Conn {
var connections []net.Conn
ctx.mutex.Lock()
defer ctx.mutex.Unlock()
for _, v := range ctx.storage {
if s, ok := v.(Session); ok == true {
connections = append(connections, s.Connection())
}
}
return connections
} | go | {
"resource": ""
} |
q9194 | noWritePerms | train | func noWritePerms(permissions []string) bool {
for _, value := range permissions {
if value == PermWrite {
return false
}
}
return true
} | go | {
"resource": ""
} |
q9195 | Equal | train | func (c *Characteristic) Equal(other interface{}) bool {
if characteristic, ok := other.(*Characteristic); ok == true {
// The value type (e.g. float32, bool,...) of property `Value` may be different even though
// they look the same. They are equal when they have the same string representation.
value := fmt.Sprintf("%+v", c.Value)
otherValue := fmt.Sprintf("%+v", characteristic.Value)
return value == otherValue && c.ID == characteristic.ID && c.Type == characteristic.Type && len(c.Perms) == len(characteristic.Perms) && c.Description == characteristic.Description && c.Format == characteristic.Format && c.Unit == characteristic.Unit && c.MaxLen == characteristic.MaxLen && c.MaxValue == characteristic.MaxValue && c.MinValue == characteristic.MinValue && c.StepValue == characteristic.StepValue && c.Events == characteristic.Events
}
return false
} | go | {
"resource": ""
} |
q9196 | New | train | func New(typ string) *Service {
s := Service{
Type: typ,
Characteristics: []*characteristic.Characteristic{},
Linked: []int64{},
}
return &s
} | go | {
"resource": ""
} |
q9197 | GetCharacteristics | train | func (s *Service) GetCharacteristics() []*characteristic.Characteristic {
var result []*characteristic.Characteristic
for _, c := range s.Characteristics {
result = append(result, c)
}
return result
} | go | {
"resource": ""
} |
q9198 | Equal | train | func (s *Service) Equal(other interface{}) bool {
if service, ok := other.(*Service); ok == true {
if len(s.Characteristics) != len(service.Characteristics) {
println("Number of chars wrong")
return false
}
for i, c := range s.Characteristics {
other := service.Characteristics[i]
if c.Equal(other) == false {
return false
}
}
return s.ID == service.ID && s.Type == service.Type
}
return false
} | go | {
"resource": ""
} |
q9199 | NewSecureSessionFromSharedKey | train | func NewSecureSessionFromSharedKey(sharedKey [32]byte) (Cryptographer, error) {
salt := []byte("Control-Salt")
out := []byte("Control-Read-Encryption-Key")
in := []byte("Control-Write-Encryption-Key")
var s = new(secureSession)
var err error
s.encryptKey, err = hkdf.Sha512(sharedKey[:], salt, out)
s.encryptCount = 0
if err != nil {
return nil, err
}
s.decryptKey, err = hkdf.Sha512(sharedKey[:], salt, in)
s.decryptCount = 0
return s, err
} | go | {
"resource": ""
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.