_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(spotifyU... | 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,... | 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.Joi... | 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(... | 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: exceed... | 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... | 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)
... | 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 != ht... | 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.Offs... | 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 |... | 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 {
... | 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) b... | 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++
... | 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 in... | 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 [... | 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... | 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) {
... | 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 ... | 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) {
... | 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 ... | 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 ... | 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 ... | 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 = app... | 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{i... | 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.Curre... | 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,... | 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(TagPu... | 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.Spr... | 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) =... | 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.encryptCoun... | go | {
"resource": ""
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.