-/**
- * ============LICENSE_START====================================================
- * org.onap.aaf
- * ===========================================================================
- * Copyright (c) 2018 AT&T Intellectual Property. All rights reserved.
- * ===========================================================================
- * Licensed 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.
- * ============LICENSE_END====================================================
- *
- */
-
-/*
- * Pool
- *
- * Author: Jonathan
- * 5/27/2011
- */
-package org.onap.aaf.misc.env.util;
-
-import java.util.LinkedList;
-
-import org.onap.aaf.misc.env.APIException;
-import org.onap.aaf.misc.env.LogTarget;
-
-/**
- * This Class pools on an As-Needed-Basis any particular kind of class, which is
- * quite suitable for expensive operations.
- *
- * The user calls "get" on a Pool, and if a waiting resource (T) is available,
- * it will be returned. Otherwise, one will be created with the "Creator" class
- * (must be defined for (T)).
- *
- * You can Prime the instances to avoid huge startup costs
- *
- * The returned "Pooled" object simply has to call "done()" and the object is
- * returned to the pool. If the developer does not return the object, a memory
- * leak does not occur. There are no references to the object once "get" is
- * called. However, the developer who does not return the object when done
- * obviates the point of the pool, as new Objects are created in place of the
- * Object not returned when another call to "get" is made.
- *
- * There is a cushion of extra objects, currently defaulted to MAX_RANGE. If the
- * items returned become higher than the MAX_RANGE, the object is allowed to go
- * out of scope, and be cleaned up. the default can be changed on a per-pool
- * basis.
- *
- *
- * @author Jonathan
- *
- * @param <T>
- */
-public class Pool<T> {
- /**
- * This is a constant which specified the default maximum number of unused
- * objects to be held at any given time.
- */
- private static final int MAX_RANGE = 6; // safety
-
- /**
- * only Simple List needed.
- *
- * NOTE TO MAINTAINERS: THIS OBJECT DOES IT'S OWN SYNCHRONIZATION. All
- * changes that touch list must account for correctly synchronizing list.
- */
- private LinkedList<Pooled<T>> list;
-
- /**
- * keep track of how many elements exist, to avoid asking list.
- */
- private int count;
-
- /**
- * Spares are those Object that are primed and ready to go.
- */
- private int spares;
-
- /**
- * Actual MAX number of spares allowed to hang around. Can be set to
- * something besides the default MAX_RANGE.
- */
- private int max_range = MAX_RANGE;
-
- /**
- * The Creator for this particular pool. It must work for type T.
- */
- private Creator<T> creator;
-
- /**
- * Create a new Pool, given the implementation of Creator<T>, which must be
- * able to create/destroy T objects at will.
- *
- * @param creator
- */
- public Pool(Creator<T> creator) {
- count = spares = 0;
- this.creator = creator;
- list = new LinkedList<Pooled<T>>();
- }
-
- /**
- * Preallocate a certain number of T Objects. Useful for services so that
- * the first transactions don't get hit with all the Object creation costs
- *
- * @param lt
- * @param prime
- * @throws APIException
- */
- public void prime(LogTarget lt, int prime) throws APIException {
- for (int i = 0; i < prime; ++i) {
- Pooled<T> pt = new Pooled<T>(creator.create(), this, lt);
- synchronized (list) {
- list.addFirst(pt);
- ++count;
- }
- }
-
- }
-
- /**
- * Destroy and remove all remaining objects. This is valuable for closing
- * down all Allocated objects cleanly for exiting. It is also a good method
- * for removing objects when, for instance, all Objects are invalid because
- * of broken connections, etc.
- */
- public void drain() {
- synchronized (list) {
- for (int i = 0; i < list.size(); ++i) {
- Pooled<T> pt = list.remove();
- creator.destroy(pt.content);
- pt.logTarget.log("Pool drained ", creator.toString());
- }
- count = spares = 0;
- }
-
- }
-
- /**
- * This is the essential function for Pool. Get an Object "T" inside a
- * "Pooled<T>" object. If there is a spare Object, then use it. If not, then
- * create and pass back.
- *
- * This one uses a Null LogTarget
- *
- * IMPORTANT: When the use of this object is done (and the object is still
- * in a valid state), then "done()" should be called immediately to allow
- * the object to be reused. That is the point of the Pool...
- *
- * If the Object is in an invalid state, then "toss()" should be used so the
- * Pool doesn't pass on invalid objects to others.
- *
- * @param lt
- * @return
- * @throws APIException
- */
- public Pooled<T> get() throws APIException {
- Pooled<T> pt;
- synchronized (list) {
- if (list.isEmpty()) {
- pt = null;
- } else {
- pt = list.removeLast();
- --count;
- creator.reuse(pt.content);
- }
- }
- if (pt == null) {
- if (spares < max_range)
- ++spares;
- pt = new Pooled<T>(creator.create(), this, LogTarget.NULL);
- } else {
- if (spares > 1)
- --spares;
- }
- return pt;
- }
-
- /**
- * This is the essential function for Pool. Get an Object "T" inside a
- * "Pooled<T>" object. If there is a spare Object, then use it. If not, then
- * create and pass back.
- *
- * If you don't have access to a LogTarget from Env, use LogTarget.NULL
- *
- * IMPORTANT: When the use of this object is done (and the object is still
- * in a valid state), then "done()" should be called immediately to allow
- * the object to be reused. That is the point of the Pool...
- *
- * If the Object is in an invalid state, then "toss()" should be used so the
- * Pool doesn't pass on invalid objects to others.
- *
- * @param lt
- * @return
- * @throws APIException
- */
- public Pooled<T> get(LogTarget lt) throws APIException {
- Pooled<T> pt;
- synchronized (list) {
- if (list.isEmpty()) {
- pt = null;
- } else {
- pt = list.remove();
- --count;
- creator.reuse(pt.content);
- }
- }
- if (pt == null) {
- if (spares < max_range)
- ++spares;
- pt = new Pooled<T>(creator.create(), this, lt);
- lt.log("Pool created ", creator.toString());
- } else {
- if (spares > 1)
- --spares;
- }
- return pt;
- }
-
- /**
- * This function will validate whether the Objects are still in a usable
- * state. If not, they are tossed from the Pool. This is valuable to have
- * when Remote Connections go down, and there is a question on whether the
- * Pooled Objects are still functional.
- *
- * @return
- */
- public boolean validate() {
- boolean rv = true;
- synchronized (list) {
- for (Pooled<T> t : list) {
- if (!creator.isValid(t.content)) {
- rv = false;
- t.toss();
- list.remove(t);
- }
- }
- }
- return rv;
- }
-
- /**
- * This is an internal method, used only by the Internal Pooled<T> class.
- *
- * The Pooled<T> class "offers" it's Object back after use. It is an
- * "offer", because Pool will simply destroy and remove the object if it has
- * more than enough spares.
- *
- * @param lt
- * @param used
- * @return
- */
- // Used only by Pooled<T>
- private boolean offer(LogTarget lt, Pooled<T> used) {
- if (count < spares) {
- synchronized (list) {
- list.addFirst(used);
- ++count;
- }
- lt.log("Pool recovered ", creator.toString());
- } else {
- lt.log("Pool destroyed ", creator.toString());
- creator.destroy(used.content);
- }
- return false;
- }
-
- /**
- * The Creator Interface give the Pool the ability to Create, Destroy and
- * Validate the Objects it is maintaining. Thus, it is a specially written
- * Implementation for each type.
- *
- * @author Jonathan
- *
- * @param <T>
- */
- public interface Creator<T> {
- public T create() throws APIException;
-
- public void destroy(T t);
-
- public boolean isValid(T t);
-
- public void reuse(T t);
- }
-
- /**
- * The "Pooled<T>" class is the transient class that wraps the actual Object
- * T for API use/ It gives the ability to return ("done()", or "toss()") the
- * Object to the Pool when processing is finished.
- *
- * For Safety, i.e. to avoid memory leaks and invalid Object States, there
- * is a "finalize" method. It is strictly for when coder forgets to return
- * the object, or perhaps hasn't covered the case during Exceptions or
- * Runtime Exceptions with finally (preferred). This should not be
- * considered normal procedure, as finalize() is called at an undetermined
- * time during garbage collection, and is thus rather useless for a Pool.
- * However, we don't want Coding Mistakes to put the whole program in an
- * invalid state, so if something happened such that "done()" or "toss()"
- * were not called, the resource is still cleaned up as well as possible.
- *
- * @author Jonathan
- *
- * @param <T>
- */
- public static class Pooled<T> {
- public final T content;
- private Pool<T> pool;
- protected LogTarget logTarget;
-
- /**
- * Create the Wrapping Object Pooled<T>.
- *
- * @param t
- * @param pool
- * @param logTarget
- */
- public Pooled(T t, Pool<T> pool, LogTarget logTarget) {
- content = t;
- this.pool = pool;
- this.logTarget = logTarget;
- }
-
- /**
- * This is the key API for the Pool, as calling "done()" offers this
- * object back to the Pool for reuse.
- *
- * Do not use the Pooled<T> object again after calling "done()".
- */
- public void done() {
- if (pool != null) {
- pool.offer(logTarget, this);
- }
- }
-
- /**
- * The user of the Object may discover that the Object t is no longer in
- * a valid state. Don't put Garbage back in the Refrigerator... Toss it,
- * if it's no longer valid.
- *
- * toss() is also used for draining the Pool, etc.
- *
- * toss() will attempt to destroy the Object by using the Creator
- * Interface.
- *
- */
- public void toss() {
- if (pool != null) {
- pool.creator.destroy(content);
- }
- // Don't allow finalize to put it back in.
- pool = null;
- }
-
- /**
- * Just in case someone neglected to offer back object... Do not rely on
- * this, as there is no specific time when finalize is called, which
- * rather defeats the purpose of a Pool.
- */
- @Override
- protected void finalize() throws Throwable {
- if (pool != null) {
- done();
- pool = null;
- }
- }
- }
-
- /**
- * Get the maximum number of spare objects allowed at any moment
- *
- * @return
- */
- public int getMaxRange() {
- return max_range;
- }
-
- /**
- * Set a Max Range for numbers of spare objects waiting to be used.
- *
- * No negative numbers are allowed
- *
- * @return
- */
- public void setMaxRange(int max_range) {
- // Do not allow negative numbers
- this.max_range = Math.max(0, max_range);
- }
-
-}
+/**\r
+ * ============LICENSE_START====================================================\r
+ * org.onap.aaf\r
+ * ===========================================================================\r
+ * Copyright (c) 2018 AT&T Intellectual Property. All rights reserved.\r
+ * ===========================================================================\r
+ * Licensed under the Apache License, Version 2.0 (the "License");\r
+ * you may not use this file except in compliance with the License.\r
+ * You may obtain a copy of the License at\r
+ * \r
+ * http://www.apache.org/licenses/LICENSE-2.0\r
+ * \r
+ * Unless required by applicable law or agreed to in writing, software\r
+ * distributed under the License is distributed on an "AS IS" BASIS,\r
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\r
+ * See the License for the specific language governing permissions and\r
+ * limitations under the License.\r
+ * ============LICENSE_END====================================================\r
+ *\r
+ */\r
+\r
+/*\r
+ * Pool\r
+ * \r
+ * Author: Jonathan\r
+ * 5/27/2011\r
+ */\r
+package org.onap.aaf.misc.env.util;\r
+\r
+import java.util.LinkedList;\r
+\r
+import org.onap.aaf.misc.env.APIException;\r
+import org.onap.aaf.misc.env.LogTarget;\r
+\r
+/**\r
+ * This Class pools on an As-Needed-Basis any particular kind of class, which is\r
+ * quite suitable for expensive operations.\r
+ * \r
+ * The user calls "get" on a Pool, and if a waiting resource (T) is available,\r
+ * it will be returned. Otherwise, one will be created with the "Creator" class\r
+ * (must be defined for (T)).\r
+ * \r
+ * You can Prime the instances to avoid huge startup costs\r
+ * \r
+ * The returned "Pooled" object simply has to call "done()" and the object is\r
+ * returned to the pool. If the developer does not return the object, a memory\r
+ * leak does not occur. There are no references to the object once "get" is\r
+ * called. However, the developer who does not return the object when done\r
+ * obviates the point of the pool, as new Objects are created in place of the\r
+ * Object not returned when another call to "get" is made.\r
+ * \r
+ * There is a cushion of extra objects, currently defaulted to MAX_RANGE. If the\r
+ * items returned become higher than the MAX_RANGE, the object is allowed to go\r
+ * out of scope, and be cleaned up. the default can be changed on a per-pool\r
+ * basis.\r
+ * \r
+ * \r
+ * @author Jonathan\r
+ * \r
+ * @param <T>\r
+ */\r
+public class Pool<T> {\r
+ /**\r
+ * This is a constant which specified the default maximum number of unused\r
+ * objects to be held at any given time.\r
+ */\r
+ private static final int MAX_RANGE = 6; // safety\r
+\r
+ /**\r
+ * only Simple List needed.\r
+ * \r
+ * NOTE TO MAINTAINERS: THIS OBJECT DOES IT'S OWN SYNCHRONIZATION. All\r
+ * changes that touch list must account for correctly synchronizing list.\r
+ */\r
+ private LinkedList<Pooled<T>> list;\r
+\r
+ /**\r
+ * keep track of how many elements exist, to avoid asking list.\r
+ */\r
+ private int count;\r
+\r
+ /**\r
+ * Spares are those Object that are primed and ready to go.\r
+ */\r
+ private int spares;\r
+\r
+ /**\r
+ * Actual MAX number of spares allowed to hang around. Can be set to\r
+ * something besides the default MAX_RANGE.\r
+ */\r
+ private int max_range = MAX_RANGE;\r
+\r
+ /**\r
+ * The Creator for this particular pool. It must work for type T.\r
+ */\r
+ private Creator<T> creator;\r
+\r
+ /**\r
+ * Create a new Pool, given the implementation of Creator<T>, which must be\r
+ * able to create/destroy T objects at will.\r
+ * \r
+ * @param creator\r
+ */\r
+ public Pool(Creator<T> creator) {\r
+ count = spares = 0;\r
+ this.creator = creator;\r
+ list = new LinkedList<>();\r
+ }\r
+\r
+ /**\r
+ * Preallocate a certain number of T Objects. Useful for services so that\r
+ * the first transactions don't get hit with all the Object creation costs\r
+ * \r
+ * @param lt\r
+ * @param prime\r
+ * @throws APIException\r
+ */\r
+ public void prime(LogTarget lt, int prime) throws APIException {\r
+ for (int i = 0; i < prime; ++i) {\r
+ Pooled<T> pt = new Pooled<T>(creator.create(), this, lt);\r
+ synchronized (list) {\r
+ list.addFirst(pt);\r
+ ++count;\r
+ }\r
+ }\r
+\r
+ }\r
+\r
+ /**\r
+ * Destroy and remove all remaining objects. This is valuable for closing\r
+ * down all Allocated objects cleanly for exiting. It is also a good method\r
+ * for removing objects when, for instance, all Objects are invalid because\r
+ * of broken connections, etc.\r
+ */\r
+ public void drain() {\r
+ synchronized (list) {\r
+ for (int i = 0; i < list.size(); ++i) {\r
+ Pooled<T> pt = list.remove();\r
+ creator.destroy(pt.content);\r
+ pt.logTarget.log("Pool drained ", creator.toString());\r
+ }\r
+ count = spares = 0;\r
+ }\r
+\r
+ }\r
+\r
+ /**\r
+ * This is the essential function for Pool. Get an Object "T" inside a\r
+ * "Pooled<T>" object. If there is a spare Object, then use it. If not, then\r
+ * create and pass back.\r
+ * \r
+ * This one uses a Null LogTarget\r
+ * \r
+ * IMPORTANT: When the use of this object is done (and the object is still\r
+ * in a valid state), then "done()" should be called immediately to allow\r
+ * the object to be reused. That is the point of the Pool...\r
+ * \r
+ * If the Object is in an invalid state, then "toss()" should be used so the\r
+ * Pool doesn't pass on invalid objects to others.\r
+ * \r
+ * @param lt\r
+ * @return\r
+ * @throws APIException\r
+ */\r
+ public Pooled<T> get() throws APIException {\r
+ Pooled<T> pt;\r
+ synchronized (list) {\r
+ if (list.isEmpty()) {\r
+ pt = null;\r
+ } else {\r
+ pt = list.removeLast();\r
+ --count;\r
+ creator.reuse(pt.content);\r
+ }\r
+ }\r
+ if (pt == null) {\r
+ if (spares < max_range)\r
+ ++spares;\r
+ pt = new Pooled<T>(creator.create(), this, LogTarget.NULL);\r
+ } else {\r
+ if (spares > 1)\r
+ --spares;\r
+ }\r
+ return pt;\r
+ }\r
+\r
+ /**\r
+ * This is the essential function for Pool. Get an Object "T" inside a\r
+ * "Pooled<T>" object. If there is a spare Object, then use it. If not, then\r
+ * create and pass back.\r
+ * \r
+ * If you don't have access to a LogTarget from Env, use LogTarget.NULL\r
+ * \r
+ * IMPORTANT: When the use of this object is done (and the object is still\r
+ * in a valid state), then "done()" should be called immediately to allow\r
+ * the object to be reused. That is the point of the Pool...\r
+ * \r
+ * If the Object is in an invalid state, then "toss()" should be used so the\r
+ * Pool doesn't pass on invalid objects to others.\r
+ * \r
+ * @param lt\r
+ * @return\r
+ * @throws APIException\r
+ */\r
+ public Pooled<T> get(LogTarget lt) throws APIException {\r
+ Pooled<T> pt;\r
+ synchronized (list) {\r
+ if (list.isEmpty()) {\r
+ pt = null;\r
+ } else {\r
+ pt = list.remove();\r
+ --count;\r
+ creator.reuse(pt.content);\r
+ }\r
+ }\r
+ if (pt == null) {\r
+ if (spares < max_range)\r
+ ++spares;\r
+ pt = new Pooled<T>(creator.create(), this, lt);\r
+ lt.log("Pool created ", creator.toString());\r
+ } else {\r
+ if (spares > 1)\r
+ --spares;\r
+ }\r
+ return pt;\r
+ }\r
+\r
+ /**\r
+ * This function will validate whether the Objects are still in a usable\r
+ * state. If not, they are tossed from the Pool. This is valuable to have\r
+ * when Remote Connections go down, and there is a question on whether the\r
+ * Pooled Objects are still functional.\r
+ * \r
+ * @return\r
+ */\r
+ public boolean validate() {\r
+ boolean rv = true;\r
+ synchronized (list) {\r
+ for (Pooled<T> t : list) {\r
+ if (!creator.isValid(t.content)) {\r
+ rv = false;\r
+ t.toss();\r
+ list.remove(t);\r
+ }\r
+ }\r
+ }\r
+ return rv;\r
+ }\r
+\r
+ /**\r
+ * This is an internal method, used only by the Internal Pooled<T> class.\r
+ * \r
+ * The Pooled<T> class "offers" it's Object back after use. It is an\r
+ * "offer", because Pool will simply destroy and remove the object if it has\r
+ * more than enough spares.\r
+ * \r
+ * @param lt\r
+ * @param used\r
+ * @return\r
+ */\r
+ // Used only by Pooled<T>\r
+ private boolean offer(LogTarget lt, Pooled<T> used) {\r
+ if (count < spares) {\r
+ synchronized (list) {\r
+ list.addFirst(used);\r
+ ++count;\r
+ }\r
+ lt.log("Pool recovered ", creator.toString());\r
+ } else {\r
+ lt.log("Pool destroyed ", creator.toString());\r
+ creator.destroy(used.content);\r
+ }\r
+ return false;\r
+ }\r
+\r
+ /**\r
+ * The Creator Interface give the Pool the ability to Create, Destroy and\r
+ * Validate the Objects it is maintaining. Thus, it is a specially written\r
+ * Implementation for each type.\r
+ * \r
+ * @author Jonathan\r
+ * \r
+ * @param <T>\r
+ */\r
+ public interface Creator<T> {\r
+ public T create() throws APIException;\r
+\r
+ public void destroy(T t);\r
+\r
+ public boolean isValid(T t);\r
+\r
+ public void reuse(T t);\r
+ }\r
+\r
+ /**\r
+ * The "Pooled<T>" class is the transient class that wraps the actual Object\r
+ * T for API use/ It gives the ability to return ("done()", or "toss()") the\r
+ * Object to the Pool when processing is finished.\r
+ * \r
+ * For Safety, i.e. to avoid memory leaks and invalid Object States, there\r
+ * is a "finalize" method. It is strictly for when coder forgets to return\r
+ * the object, or perhaps hasn't covered the case during Exceptions or\r
+ * Runtime Exceptions with finally (preferred). This should not be\r
+ * considered normal procedure, as finalize() is called at an undetermined\r
+ * time during garbage collection, and is thus rather useless for a Pool.\r
+ * However, we don't want Coding Mistakes to put the whole program in an\r
+ * invalid state, so if something happened such that "done()" or "toss()"\r
+ * were not called, the resource is still cleaned up as well as possible.\r
+ * \r
+ * @author Jonathan\r
+ * \r
+ * @param <T>\r
+ */\r
+ public static class Pooled<T> {\r
+ public final T content;\r
+ private Pool<T> pool;\r
+ protected LogTarget logTarget;\r
+\r
+ /**\r
+ * Create the Wrapping Object Pooled<T>.\r
+ * \r
+ * @param t\r
+ * @param pool\r
+ * @param logTarget\r
+ */\r
+ public Pooled(T t, Pool<T> pool, LogTarget logTarget) {\r
+ content = t;\r
+ this.pool = pool;\r
+ this.logTarget = logTarget;\r
+ }\r
+\r
+ /**\r
+ * This is the key API for the Pool, as calling "done()" offers this\r
+ * object back to the Pool for reuse.\r
+ * \r
+ * Do not use the Pooled<T> object again after calling "done()".\r
+ */\r
+ public void done() {\r
+ if (pool != null) {\r
+ pool.offer(logTarget, this);\r
+ }\r
+ }\r
+\r
+ /**\r
+ * The user of the Object may discover that the Object t is no longer in\r
+ * a valid state. Don't put Garbage back in the Refrigerator... Toss it,\r
+ * if it's no longer valid.\r
+ * \r
+ * toss() is also used for draining the Pool, etc.\r
+ * \r
+ * toss() will attempt to destroy the Object by using the Creator\r
+ * Interface.\r
+ * \r
+ */\r
+ public void toss() {\r
+ if (pool != null) {\r
+ pool.creator.destroy(content);\r
+ }\r
+ // Don't allow finalize to put it back in.\r
+ pool = null;\r
+ }\r
+\r
+ /**\r
+ * Just in case someone neglected to offer back object... Do not rely on\r
+ * this, as there is no specific time when finalize is called, which\r
+ * rather defeats the purpose of a Pool.\r
+ */\r
+ @Override\r
+ protected void finalize() throws Throwable {\r
+ if (pool != null) {\r
+ done();\r
+ pool = null;\r
+ }\r
+ }\r
+ }\r
+\r
+ /**\r
+ * Get the maximum number of spare objects allowed at any moment\r
+ * \r
+ * @return\r
+ */\r
+ public int getMaxRange() {\r
+ return max_range;\r
+ }\r
+\r
+ /**\r
+ * Set a Max Range for numbers of spare objects waiting to be used.\r
+ * \r
+ * No negative numbers are allowed\r
+ * \r
+ * @return\r
+ */\r
+ public void setMaxRange(int max_range) {\r
+ // Do not allow negative numbers\r
+ this.max_range = Math.max(0, max_range);\r
+ }\r
+\r
+}\r