Migrates the channel's configuration to the given {@code channel}.
495450
private void migrateConfiguration(Channel channel) throws Exception {
    channel.setDefaultConsumer(delegate.getDefaultConsumer());
    if (flowBlocked)
      channel.flowBlocked();
    if (basicQos != null)
      basicQos.invoke(channel);
    if (confirmSelect)
      channel.confirmSelect();
    if (txSelect)
      channel.txSelect();
    synchronized (shutdownListeners) {
      for (ShutdownListener listener : shutdownListeners)
        channel.addShutdownListener(listener);
    }
    for (ConfirmListener listener : confirmListeners)
      channel.addConfirmListener(listener);
    for (FlowListener listener : flowListeners)
      channel.addFlowListener(listener);
    for (ReturnListener listener : returnListeners)
      channel.addReturnListener(listener);
  }
103364
def set_channels(self, channels):
        
        for key in channels:
            self.set(key, channels[key])
960350
public void migrateTo(DTMManager mgr)
   {
     m_mgr = mgr;
     if(mgr instanceof DTMManagerDefault)
       m_mgrDefault=(DTMManagerDefault)mgr;     
   }
588359
public ChannelFuture handshake(Channel channel) {
        if (channel == null) {
            throw new NullPointerException("channel");
        }
        return handshake(channel, channel.newPromise());
    }
1162622
def _create_channel(self, channel):
        
        super()._create_channel(channel)
        if 'EXCEPTS' in self._isupport:
            self.channels[channel]['exceptlist'] = None
        if 'INVEX' in self._isupport:
            self.channels[channel]['inviteexceptlist'] = None
908933
protected void populateChannel(final Channel channel, final Element eChannel) {
        final String title = channel.getTitle();
        if (title != null) {
            eChannel.addContent(generateSimpleElement("title", title));
        }
        final String link = channel.getLink();
        if (link != null) {
            eChannel.addContent(generateSimpleElement("link", link));
        }
        final String description = channel.getDescription();
        if (description != null) {
            eChannel.addContent(generateSimpleElement("description", description));
        }
    }
193641
public void addChannel(
            T channel,
            String functionalityName,
            String requesterID,
            String conversationID)
    {
        T oldCh = null;
        synchronized (this.channelsWithId)
        {
            oldCh = this.channelsWithId.get(calculateId(functionalityName, requesterID, conversationID));
            this.channelsWithId.put(calculateId(functionalityName, requesterID, conversationID), channel);
        }
        synchronized (this.channelsWithFunctionalityName)
        {
            Collection<T> channelsForFunctionalityName = this.channelsWithFunctionalityName.get(functionalityName);
            if (null == channelsForFunctionalityName)
            {
                channelsForFunctionalityName = new ArrayList<T>();
            }
            // channels are stored in
            if (null != oldCh)
            {
                channelsForFunctionalityName.remove(oldCh);
            }
            channelsForFunctionalityName = this.removeInternalChannels(channelsForFunctionalityName);
            channelsForFunctionalityName.add(channel);
            this.channelsWithFunctionalityName.put(functionalityName, channelsForFunctionalityName);
        }
    }
202853
public DeviceControllerTerminalConfiguration getTerminalConfiguration(
			final DeviceControllerChannel channel) throws IOException {

		if (channel == null) {
			throw new RuntimeException("null-channel is not allowed. For devices "
					+ "knowing just one wiper Channel.A is mandatory for "
					+ "parameter 'channel'");
		}

		// read configuration from device
		int tcon = read(channel.getTerminalControllAddress());

		// build result
		boolean channelEnabled = (tcon & channel.getHardwareConfigControlBit()) > 0;
		boolean pinAEnabled = (tcon & channel.getTerminalAConnectControlBit()) > 0;
		boolean pinWEnabled = (tcon & channel.getWiperConnectControlBit()) > 0;
		boolean pinBEnabled = (tcon & channel.getTerminalBConnectControlBit()) > 0;

		return new DeviceControllerTerminalConfiguration(channel, channelEnabled,
				pinAEnabled, pinWEnabled, pinBEnabled);

	}
252517
public void unsubscribe(String channel) {
		ChannelSubscription subscribedChannel = subscribedChannels.get(channel);

		if (isUnsubscribeValid(channel, subscribedChannel)) {
			subscribedChannel.setSubscribeOnReconnected(false);
			unsubscribe(channel, true, subscribedChannel.isWithNotification());
		}

		//subscribedChannels.remove(channel);
	}
938995
public WritableByteChannel reset(WritableByteChannel channel)
            throws IOException
    {
        WritableByteChannel old = this.channel;
        this.channel = channel;
        return old;
    }
1369499
@Process(actionType = ReadConfig.class)
    public void readConfig(final ReadConfig action, final Dispatcher.Channel channel) {
        readConfig(action.getAddressTemplate(), channel);
    }
627104
public Channel getChannel(int channelId) {
        Channel channel = channels.putIfAbsent(channelId, new Channel(this, channelId));
        if (channel == null) {
            channel = channels.get(channelId);
        }
        return channel;
    }
786342
@Override
    public synchronized ChannelData updateAllChannelProperties(String channelName, Map<Object, Object> newProperties) throws ChannelException {
        if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) {
            Tr.entry(tc, "updateAllChannelProperties: " + channelName);
        }
        if (null == channelName) {
            throw new InvalidChannelNameException("Input channel name is null");
        }
        if (null == newProperties) {
            throw new ChannelException("Null properties found.");
        }

        // Find the existing channel config
        ChannelDataImpl channelData = (ChannelDataImpl) channelDataMap.get(channelName);
        if (null == channelData) {
            throw new InvalidChannelNameException("Unable to find input channel, " + channelName);
        }

        // Update the property bag. Note this may throw an exception.
        channelData.setPropertyBag(newProperties);
        // Trace each of the properties being added.
        if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled()) {
            Tr.debug(tc, "New properties for channel " + channelName + ", properties:\n" + stringForMap(newProperties));
        }

        // Update each running channel that is using this parent channel data
        // object.
        updateRunningChannels(channelData);

        if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) {
            Tr.exit(tc, "updateAllChannelProperties");
        }
        return channelData;
    }
681665
function registerChannel(channel) {
  channels[channel.name] = channel;
  NativeBridge.registerChannel(channel.name, bridgeListener);
}
829993
public GrpcChannelBuilder setChannelType(Class<? extends io.netty.channel.Channel> channelType) {
    mChannelKey.setChannelType(channelType);
    return this;
  }
503787
@SuppressWarnings("unchecked")
    @Override
    public T newChannel() {
        switch (kind) {
            case ACCEPTOR:
                switch (type) {
                    case DATAGRAM:
                        return (T) new NioUdtMessageAcceptorChannel();
                    case STREAM:
                        return (T) new NioUdtByteAcceptorChannel();
                    default:
                        throw new IllegalStateException("wrong type=" + type);
                }
            case CONNECTOR:
                switch (type) {
                    case DATAGRAM:
                        return (T) new NioUdtMessageConnectorChannel();
                    case STREAM:
                        return (T) new NioUdtByteConnectorChannel();
                    default:
                        throw new IllegalStateException("wrong type=" + type);
                }
            case RENDEZVOUS:
                switch (type) {
                    case DATAGRAM:
                        return (T) new NioUdtMessageRendezvousChannel();
                    case STREAM:
                        return (T) new NioUdtByteRendezvousChannel();
                    default:
                        throw new IllegalStateException("wrong type=" + type);
                }
            default:
                throw new IllegalStateException("wrong kind=" + kind);
        }
    }
75448
synchronized void setChannelFactory(ChannelFactory factory) throws ChannelFactoryException {
        if (factory != null && cf != null) {
            throw new ChannelFactoryException("ChannelFactory already exists");
        }
        this.cf = factory;
    }