plglst.spb

Oracle PL/SQL procedure generator (second generator type)

CREATE OR REPLACE PACKAGE BODY PLGlst 
IS
/*----------------------------------------------------------------
||                  PL/Vision Professional 
||----------------------------------------------------------------
||    File: plglst.spb
||  Author: Steven Feuerstein
||
|| This is a part of the PL/Vision Professional Code library.
|| Copyright (C) 1996-99 Quest Software, Inc.
|| All rights reserved.
||
|| For more information, call Quest Software at 1-800-REVEAL4
|| or check out our Web page: www.Quest Software.com
||
-----------------------------------------------------------------*/
   c_pkg CONSTANT PLGadmin.identifier := 'plglst';

   /* The maximum number of items allowed in a list. */
   v_maxitems PLS_INTEGER := c_maxitems;

   /* Maximum length of an item in the list. */
   maxlen CONSTANT PLS_INTEGER := PLGadmin.dbmax_len;

   /* All the list items, segmented by v_maxitems. */
   items2000 PLGadmin.vc2000_tabtype;
   
   TYPE listhdr_type IS RECORD
      (name PLGadmin.identifier,
       type VARCHAR(30), 
       firstrow PLS_INTEGER := 0,
       num PLS_INTEGER := 0);

   TYPE list_tabtype IS TABLE OF listhdr_type INDEX BY BINARY_INTEGER;
   lists list_tabtype;

/*--------------- Private Modules --------------*/
   /* List-level Modules */

   FUNCTION vc2000_table (list_in IN PLS_INTEGER) RETURN BOOLEAN
   IS
   BEGIN
      RETURN TRUE;
   END;

   FUNCTION vc30_table (list_in IN PLS_INTEGER) RETURN BOOLEAN
   IS
   BEGIN
      RETURN FALSE;
   END;

   PROCEDURE validate_list (list_in IN VARCHAR2, row_out IN OUT PLS_INTEGER)
   IS
   BEGIN
      row_out := id (list_in);
      IF row_out = 0
      THEN
         DBMS_OUTPUT.PUT_LINE ('PLGlst: list ' || list_in || ' is undefined.');
         RAISE list_undefined;
      END IF;
   END;

   PROCEDURE validate_list (list_in IN PLS_INTEGER)
   IS
   BEGIN
      IF NOT lists.EXISTS (list_in) 
      THEN
         DBMS_OUTPUT.PUT_LINE ('PLGlst: list #' || list_in || ' is undefined.');
         RAISE list_undefined;
      END IF;
   END;

   PROCEDURE validate_listif (list_in IN VARCHAR2, validate_in IN  BOOLEAN)
   IS
   BEGIN
      IF validate_in
      THEN
         validate_list (list_in);
      END IF;
   END;

   PROCEDURE validate_space (list_in IN PLS_INTEGER)
   IS
   BEGIN
      IF nitems (list_in, FALSE) = maxitems
      THEN
         RAISE list_full;
      END IF;
   END;

   PROCEDURE validate_range
      (list_in IN PLS_INTEGER, pos_in IN PLS_INTEGER)
   IS
   BEGIN
      IF NOT pos_in BETWEEN 1 AND nitems (list_in, FALSE)
      THEN
         RAISE out_of_bounds;
      END IF;
   END;

   /* An honest to goodness forward reference! */
   FUNCTION liststart
     (list_in IN PLS_INTEGER, actual_in IN BOOLEAN := FALSE) 
      RETURN PLS_INTEGER;

   FUNCTION listend
     (list_in IN PLS_INTEGER, shift_in IN PLS_INTEGER := 1,
      actual_in IN BOOLEAN := FALSE) 
   RETURN PLS_INTEGER
   IS
      retval PLS_INTEGER;
   BEGIN
      IF actual_in
      THEN
         retval := PLGofst.last (list_in, v_maxitems, 1);
            retval := items2000.PRIOR (retval+1);
         IF retval < liststart (list_in, FALSE)
         THEN
            retval := NULL;
         END IF;
      ELSE
         retval :=  
            (liststart (list_in, FALSE) + 
             nitems (list_in, FALSE) - 
             shift_in);
      END IF;
      RETURN retval;
   END;

   FUNCTION liststart
     (list_in IN PLS_INTEGER, actual_in IN BOOLEAN := FALSE) 
      RETURN PLS_INTEGER
   IS
      retval PLS_INTEGER;
   BEGIN
      retval := lists(list_in).firstrow;
      IF actual_in
      THEN
            retval := items2000.NEXT (retval-1);
         IF retval > listend (list_in)
         THEN
            retval := NULL;
         END IF;
      END IF;
      RETURN retval;
   END;

   /* Item-level Modules */

   FUNCTION itemrow (list_in IN PLS_INTEGER, pos_in IN PLS_INTEGER) 
      RETURN PLS_INTEGER
   IS
      retval PLS_INTEGER := NULL;
   BEGIN
      IF pos_in > 0 
      THEN
         retval := PLGofst.shifted  (list_in, v_maxitems, pos_in, 1);
         -- retval := lists(list_in).firstrow + pos_in - 1;

      ELSIF pos_in < 0
      THEN
         retval := listend (list_in, -1 * pos_in);
      END IF;

      RETURN retval;
   END;

   FUNCTION nextitemrow (list_in IN PLS_INTEGER, row_in IN PLS_INTEGER) 
   RETURN PLS_INTEGER
   IS
      retval PLS_INTEGER := NULL;
   BEGIN
      IF row_in > 0 
      THEN
         IF vc2000_table (list_in)
         THEN
            retval := items2000.NEXT (row_in);
         END IF;

         IF retval > listend (list_in)
         THEN
            retval := NULL;
         END IF;

      ELSIF row_in < 0
      THEN
         /* ? Not yet implemented. Not sure if needed. */
         retval := NULL; -- listend (list_in, -1 * pos_in);
      END IF;

      RETURN retval;
   END;

   FUNCTION itemexists (list_in IN PLS_INTEGER, row_in IN PLS_INTEGER)
     RETURN BOOLEAN
   IS
   BEGIN
      RETURN 
         (vc2000_table (list_in) AND NOT items2000.EXISTS (row_in));
   END;

   FUNCTION itemmatch
      (list_in IN PLS_INTEGER, 
       row_in IN PLS_INTEGER,
       item_in IN VARCHAR2)
   RETURN BOOLEAN
   IS
      v_row PLS_INTEGER := row_in /* itemrow (list_in, row_in) */;
      retval BOOLEAN := FALSE;
   BEGIN
      IF v_row IS NOT NULL
      THEN
         IF vc2000_table (list_in)
         THEN
            retval := items2000 (v_row) = item_in;
         END IF;
      END IF;
      RETURN retval;
   END;

   PROCEDURE setitem 
      (list_in IN PLS_INTEGER, 
       pos_in IN PLS_INTEGER,
       item_in IN VARCHAR2)
   IS
      v_row PLS_INTEGER := itemrow (list_in, pos_in);
   BEGIN
      IF v_row IS NOT NULL
      THEN
         IF vc2000_table (list_in)
         THEN
            items2000 (v_row) := item_in;
         END IF;
      END IF;
   END;

   PROCEDURE incrnum 
      (list_in IN PLS_INTEGER, 
       incr_in IN PLS_INTEGER := +1)
   /* Sets the number of items in the list. */
   IS
   BEGIN
      lists(list_in).num := NVL (lists(list_in).num, 0) + incr_in;      
   END;

   PROCEDURE shiftlist
      (list_in IN PLS_INTEGER, 
       firstrow_in IN PLS_INTEGER,
       shiftby_in IN PLS_INTEGER := +1)
   /*
   If shiftby is negative, shifting down so shift from
   lowest to highest. Otherwise, shift from highest to lowest.
   */
   IS
      v_firstrow PLS_INTEGER;
      v_end PLS_INTEGER;
   BEGIN
      IF shiftby_in > 0
      THEN
         v_firstrow := listend (list_in);
         v_end := liststart (list_in) + firstrow_in - 1;
         FOR rowind IN REVERSE v_end .. v_firstrow
         LOOP
            items2000 (rowind+1) := items2000 (rowind);
         END LOOP;

      ELSIF shiftby_in < 0
      THEN
         v_end := listend (list_in);
         v_firstrow := liststart (list_in) + firstrow_in - 1;
         FOR rowind IN v_firstrow .. v_end
         LOOP
            items2000 (rowind-1) := items2000 (rowind);
         END LOOP;
      END IF;
   END;

   PROCEDURE remitem 
      (list_in IN PLS_INTEGER, 
       item_in IN PLS_INTEGER, 
       decr_in IN BOOLEAN := TRUE, 
       last_item_in IN PLS_INTEGER := NULL)
   IS
      v_last PLS_INTEGER := NVL (last_item_in, item_in);
   BEGIN
      items2000.DELETE (item_in, v_last);
      
      IF decr_in
      THEN
         incrnum (list_in, -1); 
      END IF;
   END;
      
   PROCEDURE remtrailing (list_in IN PLS_INTEGER)
   IS
   BEGIN
      remitem 
         (list_in, listend (list_in) + 1, FALSE, 
          PLGofst.last (list_in, v_maxitems, 1));
   END;
   
   PROCEDURE compresslist (list_in IN PLS_INTEGER)
   IS
      v_new PLS_INTEGER := liststart (list_in, FALSE);
      v_row PLS_INTEGER := liststart (list_in, TRUE);
      v_last PLS_INTEGER := listend (list_in, 1, TRUE);
      nextrow PLS_INTEGER;
   BEGIN
      WHILE v_row <= v_last
      LOOP
            items2000 (v_new) := items2000 (v_row);
         v_row := nextitemrow (list_in, v_row);
         v_new := v_new + 1;
      END LOOP;
      
      remtrailing (list_in);
      
      lists(list_in).num := 
         PLGofst.unshifted (list_in, v_maxitems, v_new-1, 1);
   END;

/*------------------ Public Modules--------------------*/

   /* Set max # of items in list */
   
   PROCEDURE set_maxitems (max_in IN PLS_INTEGER := c_maxitems)
   IS
   BEGIN
      v_maxitems := NVL (max_in, c_maxitems);
      /*
      || Should cause wipeout of existing lists!
      */
   END;

   FUNCTION maxitems RETURN PLS_INTEGER IS
   BEGIN
      RETURN v_maxitems;
   END;

   FUNCTION is_made (list_in IN VARCHAR2) RETURN BOOLEAN
   IS
      retval BOOLEAN;
   BEGIN
      retval := id (list_in) IS NOT NULL;
      RETURN retval;
   END;

   FUNCTION is_made (list_in IN PLS_INTEGER) RETURN BOOLEAN
   IS
      retval BOOLEAN;
   BEGIN
      retval := lists.EXISTS (list_in);
      RETURN retval;
   END;

   FUNCTION name (list_in IN PLS_INTEGER) RETURN VARCHAR2
   IS
   BEGIN
      IF is_made (list_in)
      THEN
         RETURN lists(list_in).name;
      ELSE
         RETURN NULL;
      END IF;
   END;

   FUNCTION id (list_in IN VARCHAR2) RETURN PLS_INTEGER
   IS
      no_match BOOLEAN := TRUE;
      list_int PLGadmin.identifier := 
         UPPER (LTRIM (RTRIM (list_in)));
      last_name PLS_INTEGER := lists.LAST;
      retval PLS_INTEGER := lists.FIRST;