Returns the channel this discriminator discriminates on behalf of.
321429
public Channel getChannel() {
        if (tc.isEntryEnabled())
            SibTr.entry(this, tc, "getChannel");
        if (tc.isEntryEnabled())
            SibTr.exit(this, tc, "getChannel", channel);
        return channel;
    }
932588
private Integer getChannelForSymbol(final BitfinexStreamSymbol symbol) {
		synchronized (channelIdToHandlerMap) {
			return channelIdToHandlerMap.values()
					.stream()
					.filter(v -> Objects.equals(v.getSymbol(), symbol))
					.map(ChannelCallbackHandler::getChannelId)
					.findFirst().orElse(null);
		}
	}
380743
def _detail_channel(
            self,
            participant1: Address,
            participant2: Address,
            block_identifier: BlockSpecification,
            channel_identifier: ChannelID = None,
    ) -> ChannelData:
        
        channel_identifier = self._inspect_channel_identifier(
            participant1=participant1,
            participant2=participant2,
            called_by_fn='_detail_channel(',
            block_identifier=block_identifier,
            channel_identifier=channel_identifier,
        )

        channel_data = self._call_and_check_result(
            block_identifier,
            'getChannelInfo',
            channel_identifier=channel_identifier,
            participant1=to_checksum_address(participant1),
            participant2=to_checksum_address(participant2),
        )

        return ChannelData(
            channel_identifier=channel_identifier,
            settle_block_number=channel_data[ChannelInfoIndex.SETTLE_BLOCK],
            state=channel_data[ChannelInfoIndex.STATE],
        )
450904
def channel(self, channel_id=None, auto_encode_decode=True):
        """"""
        try:
            return self.channels[channel_id]
        except KeyError:
            return self.Channel(self, channel_id,
                                auto_encode_decode=auto_encode_decode)
1191348
def channels(self):
        
        if self._channels is None:
            self._channels = ChannelList(self._version, service_sid=self._solution['sid'], )
        return self._channels
835772
def _next_channel_id(self):
        ''''''
        self._channel_counter += 1
        if self._channel_counter >= self._channel_max:
            self._channel_counter = 1
        return self._channel_counter
106454
def get_output_channel(self, output_channel_name):
        
        if not output_channel_name in self.output_channels.keys():
            self.output_channels[output_channel_name] = Channel()
        self.output_channels[output_channel_name].add_producer(self)
        return self.output_channels[output_channel_name]
1019882
def GetNeighboringChannels(channel):
    '''
    

    '''

    x = divmod(channel - 1, 4)[1]
    return channel + np.array(range(-x, -x + 4), dtype=int)
351106
def __getChannelId(self):

        

        if not self.search_params.get("channelId"):
            return

        api_fixed_url = "https://www.googleapis.com/youtube/v3/channels?part=id&maxResults=1&fields=items%2Fid&"
        url = api_fixed_url + urlencode({"key": self.api_key, "forUsername": self.search_params["channelId"]})
        get = requests.get(url).json()

        try:
            self.search_params["channelId"] = get['items'][0]['id']
            return # got it

        except IndexError:
            pass # try searching now...

        api_fixed_url = "https://www.googleapis.com/youtube/v3/search?part=snippet&type=channel&fields=items%2Fid&"
        url = api_fixed_url + urlencode({"key": self.api_key, "q": self.search_params['channelId']})
        get = requests.get(url).json()

        try:
            self.search_params["channelId"] = get['items'][0]['id']['channelId']

        except IndexError:
            del self.search_params["channelId"]
740920
public Channel getChannel(String channelName) throws ChannelFinderException {
		try {
			return wrappedSubmit(new FindByChannelName(channelName));
		} catch (ChannelFinderException e) {
			if (e.getStatus().equals(ClientResponse.Status.NOT_FOUND)) {
				return null;
			} else {
				throw e;
			}
		}

	}
1251406
public void disableChannel(Channel inputChannel)
                    throws InvalidChannelNameException, DiscriminationProcessException {
        if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) {
            Tr.entry(tc, "disableChannel: " + inputChannel.getName());
        }
        synchronized (state) {
            if (RuntimeState.STARTED.equals(state) || RuntimeState.QUIESCED.equals(state)) {
                String targetName = inputChannel.getName();
                int index = 0;
                InboundChannel prevChannel = null;
                // Find the index of the input channel in this chain.
                for (; index < channels.length; index++) {
                    if (channels[index].getName().equals(targetName)) {
                        break;
                    }
                    prevChannel = (InboundChannel) channels[index];
                }
                if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled()) {
                    Tr.debug(tc, "Index of channel, " + index);
                }

                if (channels.length == index) {
                    // Never found the channel. Log an error.
                    InvalidChannelNameException e =
                                    new InvalidChannelNameException(
                                                    "ERROR: can't unlink unknown channel, " + targetName);
                    FFDCFilter.processException(e, getClass().getName() + ".disableChannel",
                                                "319", this, new Object[] { inputChannel });
                    if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) {
                        Tr.exit(tc, "disableChannel");
                    }
                    throw e;
                } else if (null != prevChannel) {
                    // Note: do nothing if the index was zero, meaning input channel is a connector.
                    if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled()) {
                        Tr.debug(tc, "Previous channel, " + prevChannel.getName());
                    }
                    // Discriminator was only added after the chain was started.
                    Class<?> discriminatoryType = prevChannel.getDiscriminatoryType();
                    DiscriminationProcessImpl newDp = new DiscriminationProcessImpl(
                                    discriminatoryType,
                                    (DiscriminationGroup) prevChannel.getDiscriminationProcess());
                    newDp.removeDiscriminator(((InboundChannel) inputChannel).getDiscriminator());
                    prevChannel.setDiscriminationProcess(newDp);
                }
            } else {
                if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled()) {
                    Tr.debug(tc, "RuntimeState invalid to disable channel: "
                                 + inputChannel.getName() + ", chain state: " + state.ordinal);
                }
            }
        } // End synchronize
        if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) {
            Tr.exit(tc, "disableChannel");
        }
    }
117798
def _get_channel(self):
        
        if self.channel is None:
            # Get default channel as the first one that pops up in
            # 'amixer scontrols' output, which contains strings in the
            # following format:
            #
            #     Simple mixer control 'Master',0
            #     Simple mixer control 'Capture',0
            out = check_output(['amixer', 'scontrols']).decode()
            m = re.search(r"'(?P<channel>[^']+)'", out)
            if m:
                self.channel = m.group('channel')
            else:
                self.channel = 'Playback'

        return self.channel
864329
def Channel(channel)
      return channel if channel.is_a?(Channel)
      bot.channel_list.find_ensured(channel)
    end
1111046
def notification_channel_descriptor_path(cls, project, channel_descriptor):
        """"""
        return google.api_core.path_template.expand(
            "projects/{project}/notificationChannelDescriptors/{channel_descriptor}",
            project=project,
            channel_descriptor=channel_descriptor,
        )
561602
def show_channel(self, channel, owner):
        '''
        '''
        url = '%s/channels/%s/%s' % (self.domain, owner, channel)

        res = self.session.get(url)
        self._check_response(res, [200])
        return res.json()
321329
def get_channel_name(self, group, index):
        
        gp_nr, ch_nr = self._validate_channel_selection(None, group, index)

        return self.groups[gp_nr].channels[ch_nr].name
25889
def get_channels(self):
        
        selectedItems = self.idx_chan.selectedItems()
        selected_chan = [x.text() for x in selectedItems]
        chan_in_order = []
        for chan in self.chan:
            if chan in selected_chan:
                chan_in_order.append(chan)

        return chan_in_order