FWD » Core Development » Database

**     RAA 20221215 Added computeIfAbsent.

import java.util.function.*;

    * Function which does the following things:

    * 1. First, it checks if the key is present in the cache.

    * If the key is present, and a non-null value is related to the key, then it returns that value.

    * If not (the key is not present or is present, but has a null value related), it moves on to step 2.

    * 

    * 2. It attempts to compute the value using the given {@code mappingFunction}.

    * It also enters the calculated value into the map unless the calculated value is null. 

    * 

    * @param   key

    *          A hashable key.

    * @param   mappingFunction

    *          Function that takes one argument and produces a result.

    *          That result, unless it is null, is then put in the cache.

    *          

    * @return  The value at the given key, either directly retrieved or calculated.

    */

   public V computeIfAbsent(K key,

            Function<? super K, ? extends V> mappingFunction);

   /**

*      RAA 20221215 Added computeIfAbsent.

    * Function which does the following things:

    * 1. First, it checks if the key is present in the cache.

    * If the key is present, and a non-null value is related to the key, then it returns that value.

    * If not (the key is not present or is present, but has a null value related), it moves on to step 2.

    * 

    * 2. It attempts to compute the value using the given {@code mappingFunction}.

    * It also enters the calculated value into the map unless the calculated value is null.

    * When the cache is full, before adding another element, it pushes out the least desirable element(s).

    * 

    * @param   key

    *          A hashable key.

    * @param   mappingFunction

    *          Function that takes one argument and produces a result.

    *          That result, unless it is null, is then put in the cache.

    *          

    * @return  The value at the given key, either directly retrieved or calculated.

    */

   public V computeIfAbsent(K key, Function<? super K, ? extends V> mappingFunction)

   {

      Objects.requireNonNull(mappingFunction);

      V v;

      if ((v = get(key)) == null) 

      {

         V newValue;

         if ((newValue = mappingFunction.apply(key)) != null) 

         {

            put(key, newValue);

            return newValue;

         }

      }

      return v;

    }

   /**

**     RAA 20230105 Changed how a SortCriterion is generated. It now uses SortCriterionFactory

**                  instead of just calling the constructor.

         ret.add(criterion.getAlias().equals(alias) ? criterion :

                 SortCriterionFactory.getInstance(criterion, alias));

**     RAA 20230105          Changed how a SortCriterion is generated. It now uses SortCriterionFactory

**                           instead of just calling the constructor.

         SortCriterion crit = SortCriterionFactory.getInstance(buffer, part);

            workList.add(SortCriterionFactory.getInstance(buffer, sb.toString()));

**     RAA 20221215          Changed how a SortCriterion is generated. It now uses SortCriterionFactory

**                           instead of just calling the constructor.

         SortCriterion crit = SortCriterionFactory.getInstance(

**     RAA 20221213          Added a cache for storing the result of toSortExpression() method.

**     RAA 20221215          Changed how a SortCriterion is generated. It now uses SortCriterionFactory

**                           instead of just calling the constructor.

   /** Cache for storing the result of {@code toSortExpression} method. */

   private final Vector<String> toStringCache; 

   private final String name;

   private final int subscript;

   private final Dialect dialect;

      String actualName = rawName;

      int actualSubscript = -1;

         actualName = rawName.substring(0, bracketPos);

      int dotPos = actualName.lastIndexOf(".");

      String propName = actualName.substring(dotPos + 1);

      String alias = actualName.substring(0, dotPos);

               actualSubscript = Integer.parseInt(sub);

            actualName = alias + "." + propertyName;

         actualName = actualName.intern();

      name = actualName;

      subscript = actualSubscript;

      toStringCache = new Vector<>(16);

      toStringCache.setSize(16);

      toStringCache = new Vector<>(16);

      toStringCache.setSize(16);

            next = SortCriterionFactory.getInstance(dialect, sortComp.trim(), dmoInfo);

         sortCriteria.add(SortCriterionFactory.getInstance(dialect, sortComp, dmoInfo));

      int cacheKey = 0;

      cacheKey += (invert ? 1 << 3 : 0);

      cacheKey += (useTableAlias ? 1 << 2 : 0);

      cacheKey += (uniqueAlias ? 1 << 1 : 0);

      cacheKey += (doSpecificProcessing ? 1 : 0);

      String cacheResult = null;

      cacheResult = toStringCache.get(cacheKey);

      if (cacheResult != null)

      {

         return cacheResult;

      }

      String result = buf.toString();

      toStringCache.setElementAt(result, cacheKey);

      return result;

/*

** Module   : SortCriterionFactory.java

** Abstract : Factory for an object which encapsulates a single "order by" sort criterion

**

** Copyright (c) 2004-2022, Golden Code Development Corporation.

**

** -#- -I- --Date-- --JPRM-- -----------------------------------Description-----------------------------------

** 001 RAA 20221214          Created initial version.

*/

/*

** This program is free software: you can redistribute it and/or modify

** it under the terms of the GNU Affero General Public License as

** published by the Free Software Foundation, either version 3 of the

** License, or (at your option) any later version.

**

** This program is distributed in the hope that it will be useful,

** but WITHOUT ANY WARRANTY; without even the implied warranty of

** MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

** GNU Affero General Public License for more details.

**

** You may find a copy of the GNU Affero GPL version 3 at the following

** location: https://www.gnu.org/licenses/agpl-3.0.en.html

** 

** Additional terms under GNU Affero GPL version 3 section 7:

** 

**   Under Section 7 of the GNU Affero GPL version 3, the following additional

**   terms apply to the works covered under the License.  These additional terms

**   are non-permissive additional terms allowed under Section 7 of the GNU

**   Affero GPL version 3 and may not be removed by you.

** 

**   0. Attribution Requirement.

** 

**     You must preserve all legal notices or author attributions in the covered

**     work or Appropriate Legal Notices displayed by works containing the covered

**     work.  You may not remove from the covered work any author or developer

**     credit already included within the covered work.

** 

**   1. No License To Use Trademarks.

** 

**     This license does not grant any license or rights to use the trademarks

**     Golden Code, FWD, any Golden Code or FWD logo, or any other trademarks

**     of Golden Code Development Corporation. You are not authorized to use the

**     name Golden Code, FWD, or the names of any author or contributor, for

**     publicity purposes without written authorization.

** 

**   2. No Misrepresentation of Affiliation.

** 

**     You may not represent yourself as Golden Code Development Corporation or FWD.

** 

**     You may not represent yourself for publicity purposes as associated with

**     Golden Code Development Corporation, FWD, or any author or contributor to

**     the covered work, without written authorization.

** 

**   3. No Misrepresentation of Source or Origin.

** 

**     You may not represent the covered work as solely your work.  All modified

**     versions of the covered work must be marked in a reasonable way to make it

**     clear that the modified work is not originating from Golden Code Development

**     Corporation or FWD.  All modified versions must contain the notices of

**     attribution required in this license.

*/

package com.goldencode.p2j.persist;

import java.util.logging.*;

import com.goldencode.cache.*;

import com.goldencode.p2j.persist.dialect.*;

import com.goldencode.p2j.persist.orm.*;

import com.goldencode.p2j.util.*;

/**

 * Factory design pattern for a {@link SortCriterion}. Its purpose is to quickly retrieve an already created

 * {@code SortCriterion}. If that does not happen, the instance is created and then stored in cache. 

 */

public final class SortCriterionFactory

{

   /** Logger for {@code SortCriterionFactory}. */

   private static final Logger log = LogHelper.getLogger(SortCriterionFactory.class.getName());

   /** Cache for quickly returning an already created {@code SortCriterion}. */

   static final Cache<Key, SortCriterion> cache = new LRUCache<>(2048);

   /**

    * Function which simulates the behavior of the {@link SortCriterion} constructor with

    * {@link RecordBuffer} and {@code String} parameters.

    * 

    * It is strongly advised to use this function because the instance has a chance to be retrieved

    * from cache, meaning that it would be faster than creating a new one.

    * 

    * @param   buffer

    *          Record buffer.

    * @param   text

    *          Text representation of sort component, as provided by query.

    *          

    * @return  The instance of the requested {@code SortCriterion}.

    */

   static SortCriterion getInstance(RecordBuffer buffer, String text)

   throws PersistenceException

   {

      return getInstance(buffer.getDialect(), text, buffer.getDmoInfo(), false);

   }

   /**

    * Function which simulates the behavior of the {@link SortCriterion} constructor with

    * {@link Dialect}, {@code String} and {@link DmoMeta} parameters.

    * 

    * It is strongly advised to use this function because the instance has a chance to be retrieved

    * from cache, meaning that it would be faster than creating a new one.

    * 

    * @param   dialect

    *          Database dialect.

    * @param   text

    *          Text representation of sort component, as provided by query.

    * @param   dmoInfo

    *          Metadata for the table.

    *          

    * @return  The instance of the requested {@code SortCriterion}.

    */

   static SortCriterion getInstance(Dialect dialect, String text, DmoMeta dmoInfo)

   throws PersistenceException

   {

      return getInstance(dialect, text, dmoInfo, true);

   }

   /**

    * Function which simulates the behavior of the {@link SortCriterion} constructor with

    * {@link Dialect}, {@code String}, {@link DmoMeta} and {@code boolean} parameters.

    * 

    * It is strongly advised to use this function because the instance has a chance to be retrieved

    * from cache, meaning that it would be faster than creating a new one.

    * 

    * @param   dialect

    *          Database dialect.

    * @param   text

    *          Text representation of sort component, as provided by query.

    * @param   dmoInfo

    *          Metadata for the table.

    * @param   internStrings

    *          {@code true} to intern string fields, else {@code false}.

    *          

    * @return  The instance of the requested {@code SortCriterion}.

    */

   static SortCriterion getInstance(Dialect dialect, String text,

                                    DmoMeta dmoInfo, boolean internStrings)

   throws PersistenceException

   {

      Key key = new Key(dialect, text, dmoInfo, internStrings);

      synchronized (cache)

      {

         return cache.computeIfAbsent(key, k -> {

            try

            {

               return new SortCriterion(dialect, text, dmoInfo, internStrings);

            }

            catch (PersistenceException e)

            {

               if (log.isLoggable(Level.WARNING))

               {

                  log.log(Level.WARNING, "Could not create a new SortCriterion", e);

               }

            }

            return null;

         });

      }

   }

   /**

    * Function which simulates the behavior of the {@link SortCriterion} constructor with

    * {@code SortCriterion} and {@code String} parameters.

    * 

    * There are two reasons as to why this method does not involve caching:

    * 1. It is rarely used.

    * 2. Adding another element to the cache key (alias) and storing multiple {@code SortCriterion} with

    * just different aliases might provide more negative than positive aspects. It would make the

    * common cases (>95%) more difficult to obtain and the ones that are rarer easier to find.

    * 

    * @param   other

    *          The source {@code SortCriterion} to copy.

    * @param   alias

    *          The new alias to be used.

    *          

    * @return  The instance of the requested {@code SortCriterion}.

    */

   static SortCriterion getInstance(SortCriterion other, String alias)

   {

      return new SortCriterion(other, alias);

   }

   /**

    * Key for cached {@code SortCriterion}s.

    */

   private static class Key

   {

      /** Database dialect. */

      private final Dialect dialect;

      /** Text representation of sort component, as provided by query. */

      private final String text;

      /** Metadata for the table. */

      private final DmoMeta dmoInfo;

      /** Database dialect. */

      private final boolean internStrings;

      /** {@code true} to intern string fields, else {@code false}. */

      private final int hashCode;

      /**

       * Constructor.

       * 

       * @param   dialect

       *          Database dialect.

       * @param   text

       *          Text representation of sort component, as provided by query.

       * @param   dmoInfo

       *          Metadata for the table.

       * @param   internStrings

       *          {@code true} to intern string fields, else {@code false}.

       */

      Key(Dialect dialect, String text, DmoMeta dmoInfo, boolean internStrings)

      {

         this.dialect = dialect;

         this.text = text;

         this.dmoInfo = dmoInfo;

         this.internStrings = internStrings;

         int result = 17;

         result = 37 * result + (dialect == null ? 0 : dialect.hashCode());

         result = 37 * result + (text == null ? 0 : text.hashCode());

         result = 37 * result + (dmoInfo == null ? 0 : dmoInfo.hashCode());

         result = 37 * result + (internStrings == false ? 0 : 1);

         this.hashCode = result;

      }

      /**

       * Override of the default hash code algorithm. Consistent with {@link #equals(Object)}.

       * 

       * @return  Hash code.

       */

      @Override

      public int hashCode()

      {

         return hashCode;

      }

      /**

       * Override of the default equivalence algorithm. Consistent with {@link #hashCode()}.

       * 

       * return   {@code true} if this object is equivalent to the given object, else {@code

       *          false}.

       */

      @Override

      public boolean equals(Object o)

      {

         if (!(o instanceof Key))

         {

            return false;

         }

         Key that = (Key) o;

         if (this.dialect != that.dialect)

         {

            return false;

         }

         if ((this.text == null && that.text != null) ||

             (this.text != null && that.text == null) ||

             (!this.text.equals(that.text)))

         {

            return false;

         }

         if (this.dmoInfo != that.dmoInfo)

         {

            return false;

         }

         if (this.internStrings != that.internStrings)

         {

            return false;

         }

         return true;

      }

   }

}