| /* |
| * Licensed to the Apache Software Foundation (ASF) under one or more |
| * contributor license agreements. See the NOTICE file distributed with |
| * this work for additional information regarding copyright ownership. |
| * The ASF licenses this file to You under the Apache License, Version 2.0 |
| * (the "License"); you may not use this file except in compliance with |
| * the License. You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, software |
| * distributed under the License is distributed on an "AS IS" BASIS, |
| * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| * See the License for the specific language governing permissions and |
| * limitations under the License. |
| */ |
| package org.apache.activemq.artemis.protocol.amqp.proton; |
| |
| import java.util.ArrayDeque; |
| import java.util.Deque; |
| |
| /** |
| * Utility class that can generate and if enabled pool the binary tag values |
| * used to identify transfers over an AMQP link. |
| */ |
| public final class AmqpTransferTagGenerator { |
| |
| public static final int DEFAULT_TAG_POOL_SIZE = 1024; |
| |
| private final Deque<byte[]> tagPool; |
| |
| private long nextTagId; |
| private int maxPoolSize = DEFAULT_TAG_POOL_SIZE; |
| |
| public AmqpTransferTagGenerator() { |
| this(true); |
| } |
| |
| public AmqpTransferTagGenerator(boolean pool) { |
| if (pool) { |
| this.tagPool = new ArrayDeque<byte[]>(); |
| } else { |
| this.tagPool = null; |
| } |
| } |
| |
| /** |
| * Retrieves the next available tag. |
| * |
| * @return a new or unused tag depending on the pool option. |
| */ |
| public synchronized byte[] getNextTag() { |
| byte[] tagBytes = null; |
| |
| if (tagPool != null) { |
| tagBytes = tagPool.pollFirst(); |
| } |
| |
| if (tagBytes == null) { |
| long tag = nextTagId++; |
| int size = encodingSize(tag); |
| |
| tagBytes = new byte[size]; |
| |
| for (int i = 0; i < size; ++i) { |
| tagBytes[size - 1 - i] = (byte) (tag >>> (i * 8)); |
| } |
| } |
| |
| return tagBytes; |
| } |
| |
| /** |
| * When used as a pooled cache of tags the unused tags should always be |
| * returned once the transfer has been settled. |
| * |
| * @param data |
| * a previously borrowed tag that is no longer in use. |
| */ |
| public synchronized void returnTag(byte[] data) { |
| if (tagPool != null && tagPool.size() < maxPoolSize) { |
| tagPool.offerLast(data); |
| } |
| } |
| |
| /** |
| * Gets the current max pool size value. |
| * |
| * @return the current max tag pool size. |
| */ |
| public int getMaxPoolSize() { |
| return maxPoolSize; |
| } |
| |
| /** |
| * Sets the max tag pool size. If the size is smaller than the current number |
| * of pooled tags the pool will drain over time until it matches the max. |
| * |
| * @param maxPoolSize |
| * the maximum number of tags to hold in the pool. |
| */ |
| public void setMaxPoolSize(int maxPoolSize) { |
| this.maxPoolSize = maxPoolSize; |
| } |
| |
| /** |
| * @return true if the generator is using a pool of tags to reduce |
| * allocations. |
| */ |
| public boolean isPooling() { |
| return tagPool != null; |
| } |
| |
| private int encodingSize(long value) { |
| if (value < 0) { |
| return Long.BYTES; |
| } |
| |
| int size = 1; |
| while (size < 8 && (value >= (1L << (size * 8)))) { |
| size++; |
| } |
| |
| return size; |
| } |
| } |