sets the ChannelConfiguration from a byte array

@param channelConfigurationAsBytes the byte array containing the serialized channel configuration
480243
public void setChannelConfiguration(byte[] channelConfigurationAsBytes) throws InvalidArgumentException {
        if (channelConfigurationAsBytes == null) {
            throw new InvalidArgumentException("ChannelConfiguration channelConfigurationAsBytes must be non-null");
        }
        logger.trace("Creating setChannelConfiguration from bytes");
        this.configBytes = channelConfigurationAsBytes;
    }
778230
@SuppressWarnings("unused")
    private void allocateDataChannel(int channelType) {
        switch (channelType) {
            case NORMALS:
                m_normals = ByteBuffer.allocateDirect(
                        m_numVertices * 3 * SIZEOF_FLOAT);
                m_normals.order(ByteOrder.nativeOrder());
                break;
            case TANGENTS:
                m_tangents = ByteBuffer.allocateDirect(
                        m_numVertices * 3 * SIZEOF_FLOAT);
                m_tangents.order(ByteOrder.nativeOrder());
                break;
            default:
                throw new IllegalArgumentException("unsupported channel type");
        }
    }
169837
@Benchmark
	@BenchmarkMode(Mode.AverageTime)
	public void byteBufferFileChannel(final Configuration configuration) throws IOException {
		ByteBuffer buffer = ByteBuffer.allocate(BUFFER_CAPACITY);

		try (RandomAccessFile file = new RandomAccessFile(configuration.file, "rw")) {
			try (FileChannel channel = file.getChannel()) {
				for (long i = 0; i < LINES; ++i) {
					if (buffer.remaining() < DATA.length) {
						buffer.flip();
						channel.write(buffer);
						buffer.clear();
					}

					if (buffer.remaining() < DATA.length) {
						file.write(DATA);
					} else {
						buffer.put(DATA);
					}
				}

				if (buffer.position() > 0) {
					buffer.flip();
					channel.write(buffer);
				}
			}
		}
	}
63512
public void  setByte(String name, byte value) throws UnsupportedEncodingException {
    if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) SibTr.entry(this, tc, "setByte", Byte.valueOf(value));
    getBodyMap().put(name, Byte.valueOf(value));
    if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) SibTr.exit(this, tc, "setByte");
  }
776275
public <T> AioServer setOption(SocketOption<T> name, T value) throws IOException {
		this.channel.setOption(name, value);
		return this;
	}
422682
public void setNetworkBindings(java.util.Collection<NetworkBinding> networkBindings) {
        if (networkBindings == null) {
            this.networkBindings = null;
            return;
        }

        this.networkBindings = new com.amazonaws.internal.SdkInternalList<NetworkBinding>(networkBindings);
    }
1074074
public static void encodeConfiguration(CounterConfiguration configuration, Consumer<Byte> byteConsumer,
         LongConsumer longConsumer, IntConsumer intConsumer) {
      byteConsumer.accept(encodeTypeAndStorage(configuration));
      switch (configuration.type()) {
         case WEAK:
            intConsumer.accept(configuration.concurrencyLevel());
            break;
         case BOUNDED_STRONG:
            longConsumer.accept(configuration.lowerBound());
            longConsumer.accept(configuration.upperBound());
            break;
         case UNBOUNDED_STRONG:
            break;
         default:
            throw new IllegalStateException();
      }
      longConsumer.accept(configuration.initialValue());
   }
1030489
public byte[] getUpdateChannelConfigurationSignature(UpdateChannelConfiguration updateChannelConfiguration,
                                                         User signer) throws InvalidArgumentException {

        clientCheck();

        Channel systemChannel = Channel.newSystemChannel(this);
        return systemChannel.getUpdateChannelConfigurationSignature(updateChannelConfiguration, signer);

    }
1341731
public void setRequestedBytes(int newRequestedBytes)
   {
      if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) SibTr.entry(this, tc, "setRequestedBytes", newRequestedBytes);
      requestedBytes = newRequestedBytes;
      if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) SibTr.exit(this, tc, "setRequestedBytes");
   }
604367
@Override
	public final void setByteProperty(String name, byte value) throws JMSException
    {
        setProperty(name,Byte.valueOf(value));
    }
1018005
public void setProtocolString(String protocolString) {
    this.protocolString = protocolString;
    if (protocolString != null) {
      try {
        this.stringLength = protocolString.getBytes("US-ASCII").length;
      } catch (UnsupportedEncodingException uee) {
        this.stringLength = 0;
        log.error("Couldn't encode to US-ASCII.", uee);
      }
    } else {
      this.stringLength = 0;
    }
  }
1183073
public void addChannel(WebSocketChannel channel) {
        Objects.requireNonNull(channel, Required.CHANNEL.toString());

        final String url = RequestUtils.getWebSocketURL(channel);
        Set<WebSocketChannel> channels = getChannels(url);
        if (channels == null) {
            channels = new HashSet<>();
            channels.add(channel);
        } else {
            channels.add(channel);
        }
        setChannels(url, channels);
    }
940457
public void set(Collection<Builder> channels) throws ChannelFinderException {
		wrappedSubmit(new SetChannels(ChannelUtil.toCollectionXmlChannels(channels)));
	}
9599
def set_channels(channels, conf)
      if channels.nil?
        @channels = [] if @channels.nil?
        return
      end
      @channels = valid!(channels, Channel.deserialize_all(channels, conf),
                         :@channels,
                         invalid_error: 'invalid channel list %s') { [] }
    end
732345
private StreamConfiguration adjustConfigurations(AudioFormat format) {
    int sampleRate = (int) format.getSampleRate();
    int sampleSize = format.getSampleSizeInBits();
    int channels = format.getChannels();

    StreamConfiguration streamConfiguration = new StreamConfiguration();
    streamConfiguration.setSampleRate(sampleRate);
    streamConfiguration.setBitsPerSample(sampleSize);
    streamConfiguration.setChannelCount(channels);

    return streamConfiguration;
  }
1362851
public void init() throws ChannelException {
        if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled()) {
            Tr.debug(this, tc, "UDP Channel: " + getConfig().getExternalName() + " listening port: " + String.valueOf(getConfig().getPort()));
        }
    }
147294
public void setConfigurationProperties(java.util.Collection<SdkConfigurationProperty> configurationProperties) {
        if (configurationProperties == null) {
            this.configurationProperties = null;
            return;
        }

        this.configurationProperties = new java.util.ArrayList<SdkConfigurationProperty>(configurationProperties);
    }