# Sequence.java

    /*
    ** Module   : Sequence.java
    ** Abstract : Structure that holds the definition of a sequence in memory.
    **
    ** Copyright (c) 2013-2025, Golden Code Development Corporation.
    **
    ** -#- -I- --Date-- ---------------------------------------Description---------------------------------------
    ** 001 OM  20130107 Created initial version.
    ** 002 OM  20130712 Added additional fields: legacyName and initial value.
    ** 003 OM  20201010 Cleanup.
    ** 004 OM  20250110 Added sequence support for multi-tenant databases.
    */

    /*
    ** 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.sequence;

    /**
     * In-memory properties of a sequence. This class is in fact just an immutable data structure that
     * gathers sequence properties. The information is needed for database servers (like H2) that do
     * not fully support 4GL sequence feature or support is incomplete.
     */
    public class Sequence
    {
       /** The database schema to which this sequence belongs to */
       private final String schema;

       /** The sql-legal name. */
       private final String name;

       /** The legacy name of the sequence used by dynamic forms. */
       private final String legacyName;

       /** The initial value of the sequence. */
       private final long initial;

       /** The minimum value */
       private final long min;

       /** The maximum value */
       private final long max;

       /** The increment value, must not be 0 */
       private final long increment;

       /** Flag for cycling sequences */
       private final boolean cycle;

       /** Is this sequence multi-tenant private? Default is {@code false}. */
       private final boolean multiTenant;

       /**
        * The only constructor. Builds an object that has all static information for a sequence.
        *
        * @param   schema
        *          The name of the scheme this sequence belong to.
        * @param   sqlName
        *          The name of the sequence from database.
        * @param   legacyName
        *          The original name of the sequence in 4GL.
        * @param   init
        *          Initial value of the sequence.
        * @param   min
        *          Minimum value of the sequence.
        * @param   max
        *          Maximum value of the sequence.
        * @param   increment
        *          The increment of the sequence.
        * @param   cycle
        *          Cycling flag.
        * @param   multiTenant
        *          Multi-tenant flag.
        */
       public Sequence(String  schema,
                       String  legacyName,
                       String  sqlName,
                       long    init,
                       long    min,
                       long    max,
                       long    increment,
                       boolean cycle,
                       boolean multiTenant)
       {
          this.schema      = schema;
          this.name        = sqlName;
          this.legacyName  = legacyName;
          this.initial     = init;
          this.min         = min;
          this.max         = max;
          this.increment   = increment;
          this.cycle       = cycle;
          this.multiTenant = multiTenant;
       }

       /**
        * Displays the content of this sequence in a string.
        * Used only for debugging purposes.
        *
        * @return all essential data about this sequence as string
        */
       @Override
       public String toString()
       {
          return name + "[" +
                 " s" + initial +
                 " i" + increment +
                 " (" + min + ", " + max + ")" +
                 (cycle ? " loop" : "") +
                 (multiTenant ? " multiTenant" : "") +
                 " ]";
       }

       /**
        * Obtain the schema where the sequence was defined into.
        *
        * @return  The name of the schema from where the sequence was imported
        *          from.
        */
       public String getSchema()
       {
          return schema;
       }

       /**
        * Obtain the name for the sequence from 4GL.
        *
        * @return  The legacy name of the sequence.
        */
       public String getLegacyName()
       {
          return legacyName;
       }

       /**
        * Obtain the name for the sequence.
        *
        * @return  The name of the sequence.
        */
       public String getName()
       {
          return name;
       }

       /**
        * Obtain the minimum allowable value for the sequence.
        *
        * @return  The minimum value of the sequence.
        */
       public long getMin()
       {
          return min;
       }

       /**
        * Obtain the maximum allowable value for the sequence.
        *
        * @return  The maximum value of the sequence.
        */
       public long getMax()
       {
          return max;
       }

       /**
        * Obtain increment of the sequence. This is always not null.
        *
        * @return  The increment of the sequence.
        */
       public long getIncrement()
       {
          return increment;
       }

       /**
        * Checks if the sequence is cycling.
        *
        * @return  <code>true</code> if the sequence is cycling.
        */
       public boolean isCycle()
       {
          return cycle;
       }

       /**
        * Obtain the initial value of the sequence. This is always not null.
        * This is only important for cycle sequences as when cycling, this is the value to start
        * counting from.
        *
        * @return  The initial value of the sequence.
        */
       public long getInitial()
       {
          return initial;
       }

       /**
        * Checks whether this is a tenant private sequence.
        *
        * @return  {@code true} if the sequence is tenant-private.
        */
       public boolean isMultiTenant()
       {
          return multiTenant;
       }
    }