10 examples of 'golang channel' in Go

77
func (b *GetParticipantsQueryBuilder) Channel(paramChannel tg.InputChannelClass) *GetParticipantsQueryBuilder {
78
	b.req.Channel = paramChannel
79
	return b
80
}

46
func (d *ServoBlaster) Channel(channel int) *pwmChannel {
47
	return &pwmChannel{d: d, channel: channel}
48
}

142
func (b *Client) Channel() string {
143
	b.chatmut.Lock()
144
	var res = b.channel
145
	b.chatmut.Unlock()
146
	return res
147
}

69
func main() {
70
	var err error
71
	client, err = NewClient(CreateChannelClient{
72
		CONFIG_PATH,
73
		CHANNELID,
74
		USERNAME,
75
		ORGNAME,
76
	})
77
	if err != nil {
78
		fmt.Println("Failed to create new SDK: %s", err)
79
		return
80
	}
81
82
	http.HandleFunc("/gettest", GetHandler)
83
	http.HandleFunc("/puttest", PutHandler)
84
	http.HandleFunc("/helloworld", HelloWorldHandler)
85
	err = http.ListenAndServe("127.0.0.1:8080", nil)
86
	if err != nil {
87
		fmt.Println("ListenAndServe:", err)
88
	}
89
90
}

520
func cgoOnDataChannel(p int, o unsafe.Pointer) {
521
	INFO.Println("fired OnDataChannel: ", p, o)
522
	pc := PCMap.Get(p).(*PeerConnection)
523
	dc := NewDataChannel(o)
524
	if nil != pc.OnDataChannel {
525
		pc.OnDataChannel(dc)
526
	}
527
}

104
func (c *EndpointsConfig) Channel(source string) chan EndpointsUpdate {
105
	ch := c.mux.Channel(source)
106
	endpointsCh := make(chan EndpointsUpdate)
107
	go func() {
108
		for update := range endpointsCh {
109
			ch <- update
110
		}
111
	}()
112
	return endpointsCh
113
}

133
func Channel(ch *messagingTypes.Channel) *outgoing.Channel {
134
	var flag = messagingTypes.ChannelMembershipFlagNone
135
136
	if ch.Member != nil {
137
		flag = ch.Member.Flag
138
	}
139
140
	return &outgoing.Channel{
141
		ID:               Uint64toa(ch.ID),
142
		Name:             ch.Name,
143
		LastMessageID:    Uint64toa(ch.LastMessageID),
144
		Topic:            ch.Topic,
145
		Type:             string(ch.Type),
146
		MembershipFlag:   string(flag),
147
		MembershipPolicy: string(ch.MembershipPolicy),
148
		Members:          Uint64stoa(ch.Members),
149
		Unread:           ChannelUnread(ch.Unread),
150
151
		CanJoin:                   ch.CanJoin,
152
		CanPart:                   ch.CanPart,
153
		CanObserve:                ch.CanObserve,
154
		CanSendMessages:           ch.CanSendMessages,
155
		CanDeleteMessages:         ch.CanDeleteMessages,
156
		CanChangeMembers:          ch.CanChangeMembers,
157
		CanChangeMembershipPolicy: ch.CanChangeMembershipPolicy,
158
		CanUpdate:                 ch.CanUpdate,
159
		CanArchive:                ch.CanArchive,
160
		CanDelete:                 ch.CanDelete,
161
162
		CreatedAt:  ch.CreatedAt,
163
		UpdatedAt:  ch.UpdatedAt,
164
		ArchivedAt: ch.ArchivedAt,
165
		DeletedAt:  ch.DeletedAt,
166
	}
167
}

160
func (n *MenuNode) Channel() chan struct{} {
161
	switch n.item.(type) {
162
	case *systray.MenuItem:
163
		return n.item.(*systray.MenuItem).ClickedCh
164
	case *mockItem:
165
		return n.item.(*mockItem).ClickedCh()
166
	default:
167
		return nil
168
	}
169
}

408
func ChannelsCmd(n *node.Node) (proto.Response, error) {
409
	body := proto.ChannelsBody{}
410
	channels, err := n.Channels()
411
	if err != nil {
412
		logger.ERROR.Println(err)
413
		resp := proto.NewAPIChannelsResponse(body)
414
		resp.SetErr(proto.ResponseError{proto.ErrInternalServerError, proto.ErrorAdviceNone})
415
		return resp, nil
416
	}
417
	body.Data = channels
418
	return proto.NewAPIChannelsResponse(body), nil
419
}

22
func (chs *Channels) CreateChannel(context string, ch *meta.Channel) error {
23
	if chs.fail != nil {
24
		return chs.fail
25
	}
26
	return nil
27
}