# Debugger.java

    /*
    ** Module   : Debugger.java
    ** Abstract : The implementation of a Debugger resource.
    **
    ** Copyright (c) 2018-2023, Golden Code Development Corporation.
    **
    ** -#- -I- --Date-- --------------------------------------Description-----------------------------------------
    ** 001 CA  20181204 Created initial version.
    ** 002 OM  20201203 Fixed handling of READ/ONLY attributes.
    ** 003 VVT 20221003 CommonHandle.getResourceType() method renamed to resourceType() to prevent conflicts
    **                  with namesakes in DMO. See #6694.
    ** 004 CA  20231129 Fixed resource-type in 'readOnlyError'.
    */

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

    import com.goldencode.p2j.security.*;
    import com.goldencode.proxy.*;

    /**
     * DEBUGGER legacy resource implementation.
     * <p>
     * FWD just implements stub methods for the DEBUGGER attributes/methods - in case an attribute or
     * a method returns a logical, a <code>false</code> value will be returned.
     */
    public class Debugger
    {
       /** Context-local instance. */
       private static final ContextLocal<WorkArea> work = new ContextLocal<WorkArea>()
       {
          @Override
          protected WorkArea initialValue()
          {
             return new WorkArea();
          }
       };

       /**
        * Get a the instance for the DEBUGGER system handle.  Is obtained using a call to the
        * {@link StaticProxy#obtain(Class, Class[])}, using the {@link DebuggerResource} interface and
        * its methods implemented by these classes: {@link Debugger}.
        *
        * @return   See above.
        */
       public static handle asHandle()
       {
          WorkArea wa = work.get();

          Class<?>[] classes = new Class[] { Debugger.class };

          DebuggerResource proxy = StaticProxy.obtain(DebuggerResource.class, classes);

          if (wa.id == null)
          {
             wa.id = handle.resourceId(proxy);
          }

          return new handle(proxy);
       }

       /**
        * Get this resource's ID.
        *
        * @return   The resource's ID.
        */
       public static Long id()
       {
          WorkArea wa = work.get();

          return wa.id;
       }

       /**
        * Set this resource's ID.
        * <p>
        * This is a no-op for system handles.
        *
        * @param    id
        *           The resource's ID.
        */
       public static void id(long id)
       {
          // no-op
       }

       /**
        * Get the type of its associated handle.
        *
        * @return   Always return the PSEUDO-WIDGET value.
        */
       public static character resourceType()
       {
          return new character(LegacyResource.PSEUDO_WIDGET);
       }

       /**
        * Implementation for the {@link WrappedResource#valid()} API.
        *
        * @return   Always true.
        */
       public static boolean valid()
       {
          return true;
       }

       /**
        * Implementation for the {@link WrappedResource#unknown()} API.
        *
        * @return   Always false.
        */
       public static boolean unknown()
       {
          return false;
       }

       /**
        * Getter for the INSTANTIATING-PROCEDURE attribute.
        *
        * @return   Always unknown value.
        */
       public static handle instantiatingProcedure()
       {
          return new handle();
       }

       /**
        * Get the VISIBLE writable attribute.
        *
        * @return   FWD must always return <code>false</code>.
        */
       public static logical isVisible()
       {
          return new logical(false);
       }

       /**
        * Set the VISIBLE writable attribute.
        *
        * @param    visible
        *           The new value for the VISIBLE attribute.
        */
       public static void setVisible(boolean visible)
       {
          // no-op
       }

       /**
        * Set the VISIBLE writable attribute.
        *
        * @param    visible
        *           The new value for the VISIBLE attribute.
        */
       public static void setVisible(logical visible)
       {
          // no-op
       }

       /**
        * Returns the resource to it's clear state.
        *
        * @return   FWD must always return <code>false</code>.
        */
       public static logical clear()
       {
          // no-op
          return new logical(false);
       }

       /**
        * Definition of the DEBUGGER:CANCEL-BREAK() method.
        *
        * @return   FWD must always return <code>false</code>.
        */
       public static logical cancelBreak()
       {
          // no-op
          return new logical(false);
       }

       /**
        * Definition of the DEBUGGER:CANCEL-BREAK() method.
        *
        * @param    procName
        *           The target procedure name.
        *
        * @return   FWD must always return <code>false</code>.
        */
       public static logical cancelBreak(character procName)
       {
          // no-op
          return new logical(false);
       }

       /**
        * Definition of the DEBUGGER:CANCEL-BREAK() method.
        *
        * @param    procName
        *           The target procedure name.
        *
        * @return   FWD must always return <code>false</code>.
        */
       public static logical cancelBreak(String procName)
       {
          // no-op
          return new logical(false);
       }

       /**
        * Definition of the DEBUGGER:CANCEL-BREAK() method.
        *
        * @param    procName
        *           The target procedure name.
        * @param    line
        *           The line number on which the breakpoint must be unset.
        *
        * @return   FWD must always return <code>false</code>.
        */
       public static logical cancelBreak(character procName, int64 line)
       {
          // no-op
          return new logical(false);
       }

       /**
        * Definition of the DEBUGGER:CANCEL-BREAK() method.
        *
        * @param    procName
        *           The target procedure name.
        * @param    line
        *           The line number on which the breakpoint must be unset.
        *
        * @return   FWD must always return <code>false</code>.
        */
       public static logical cancelBreak(character procName, long line)
       {
          // no-op
          return new logical(false);
       }

       /**
        * Definition of the DEBUGGER:CANCEL-BREAK() method.
        *
        * @param    procName
        *           The target procedure name.
        * @param    line
        *           The line number on which the breakpoint must be unset.
        *
        * @return   FWD must always return <code>false</code>.
        */
       public static logical cancelBreak(String procName, int64 line)
       {
          // no-op
          return new logical(false);
       }

       /**
        * Definition of the DEBUGGER:CANCEL-BREAK() method.
        *
        * @param    procName
        *           The target procedure name.
        * @param    line
        *           The line number on which the breakpoint must be unset.
        *
        * @return   FWD must always return <code>false</code>.
        */
       public static logical cancelBreak(String procName, long line)
       {
          // no-op
          return new logical(false);
       }

       /**
        * Definition of the DEBUGGER:DEBUG() method.
        *
        * @return   FWD must always return <code>false</code>.
        */
       public static logical debug()
       {
          // no-op
          return new logical(false);
       }

       /**
        * Definition of the DEBUGGER:DISPLAY-MESSAGE() method.
        *
        * @param    msg
        *           The message to be shown.
        *
        * @return   FWD must always return <code>false</code>.
        */
       public static logical displayMessage(character msg)
       {
          // no-op
          return new logical(false);
       }

       /**
        * Definition of the DEBUGGER:DISPLAY-MESSAGE() method.
        *
        * @param    msg
        *           The message to be shown.
        *
        * @return   FWD must always return <code>false</code>.
        */
       public static logical displayMessage(String msg)
       {
          // no-op
          return new logical(false);
       }

       /**
        * Definition of the DEBUGGER:INITIATE() method.
        *
        * @return   FWD must always return <code>false</code>.
        */
       public static logical initiate()
       {
          // no-op
          return new logical(false);
       }

       /**
        * Definition of the DEBUGGER:SET-BREAK() method.
        *
        * @return   FWD must always return <code>false</code>.
        */
       public static logical setBreak()
       {
          // no-op
          return new logical(false);
       }

       /**
        * Definition of the DEBUGGER:SET-BREAK() method.
        *
        * @param    procName
        *           The target procedure name.
        *
        * @return   FWD must always return <code>false</code>.
        */
       public static logical setBreak(character procName)
       {
          // no-op
          return new logical(false);
       }

       /**
        * Definition of the DEBUGGER:SET-BREAK() method.
        *
        * @param    procName
        *           The target procedure name.
        *
        * @return   FWD must always return <code>false</code>.
        */
       public static logical setBreak(String procName)
       {
          // no-op
          return new logical(false);
       }

       /**
        * Definition of the DEBUGGER:SET-BREAK() method.
        *
        * @param    procName
        *           The target procedure name.
        * @param    line
        *           The line number on which the breakpoint must be set.
        *
        * @return   FWD must always return <code>false</code>.
        */
       public static logical setBreak(character procName, int64 line)
       {
          // no-op
          return new logical(false);
       }

       /**
        * Definition of the DEBUGGER:SET-BREAK() method.
        *
        * @param    procName
        *           The target procedure name.
        * @param    line
        *           The line number on which the breakpoint must be set.
        *
        * @return   FWD must always return <code>false</code>.
        */
       public static logical setBreak(character procName, long line)
       {
          // no-op
          return new logical(false);
       }

       /**
        * Definition of the DEBUGGER:SET-BREAK() method.
        *
        * @param    procName
        *           The target procedure name.
        * @param    line
        *           The line number on which the breakpoint must be set.
        *
        * @return   FWD must always return <code>false</code>.
        */
       public static logical setBreak(String procName, int64 line)
       {
          // no-op
          return new logical(false);
       }

       /**
        * Definition of the DEBUGGER:SET-BREAK() method.
        *
        * @param    procName
        *           The target procedure name.
        * @param    line
        *           The line number on which the breakpoint must be set.
        *
        * @return   FWD must always return <code>false</code>.
        */
       public static logical setBreak(String procName, long line)
       {
          // no-op
          return new logical(false);
       }

       /**
        * API needed to implement read-only attribute assignment (a 4GL "feature").
        *
        * @param    attribute
        *           The attribute's name.
        *
        * @see      handle#readOnlyError(handle, String)
        */
       public static void readOnlyError(String attribute)
       {
          // the error message for session read-only attributes is different
          // from the one emitted by handle.readOnlyError() - settable is spelled with
          // two 't' and there is no word 'widget' at the end of the message.
          final String msg = "**%s is not a settable attribute for %s";
          String err = String.format(msg,
                                     attribute.toUpperCase(),
                                     asHandle().unwrapType().resourceType().toStringMessage());
          ErrorManager.recordOrShowError(4052, err, false, false, false);
       }

       /**
        * API needed to implement read-only attribute assignment (a 4GL "feature").
        *
        * @param    attribute
        *           The attribute's name.
        * @param    expr
        *           The value which is attempted to be assigned to the read-only attribute.
        *
        * @see      handle#readOnlyError(handle, String, Object)
        */
       public static void readOnlyError(String attribute, Object expr)
       {
          readOnlyError(attribute);
       }

       /**
        * Stores global data relating to the state of the current context.
        */
       private static class WorkArea
       {
          private Long id = null;
       }
    }