plglst.spb

Oracle PL/SQL procedure generator (second generator type)

   BEGIN
      WHILE no_match AND retval <= last_name  
      LOOP
         no_match := lists(retval).name != list_int;
         IF no_match 
         THEN 
            retval := lists.NEXT (retval); 
         END IF;
      END LOOP;

      IF no_match
      THEN
         RETURN NULL;
      ELSE
         RETURN retval;
      END IF;
   END;

   FUNCTION nitems (list_in IN VARCHAR2) RETURN PLS_INTEGER
   IS
      idx PLS_INTEGER;
   BEGIN
      validate_list (list_in, idx);
      RETURN lists(idx).num;
   END;

   FUNCTION nitems (list_in IN PLS_INTEGER, validate_in IN BOOLEAN := TRUE) 
   RETURN PLS_INTEGER
   IS
   BEGIN
      validate_listif (list_in, validate_in);
      RETURN lists(list_in).num;
   END;

   PROCEDURE appenditem (list_in IN VARCHAR2, item_in IN VARCHAR2)
   IS
      idx PLS_INTEGER;
   BEGIN
      validate_list (list_in, idx);
      appenditem (idx, item_in);
   END;

   PROCEDURE appenditem (list_in IN PLS_INTEGER, item_in IN VARCHAR2)
   IS
      v_row PLS_INTEGER;
   BEGIN
      /* Does the list exist and is there room? */
      validate_list (list_in);
      validate_space (list_in);

      v_row := nitems (list_in, FALSE) + 1;
      setitem (list_in, v_row, item_in);
      incrnum (list_in);
   END;

   PROCEDURE destroy (list_in IN VARCHAR2, keep_list_in IN BOOLEAN := FALSE) 
   IS
      idx PLS_INTEGER;
   BEGIN
      validate_list (list_in, idx);
      destroy (idx, keep_list_in);
   END;

   PROCEDURE destroy (list_in IN PLS_INTEGER, keep_list_in IN BOOLEAN := FALSE) 
   IS
      v_keep BOOLEAN := NVL (keep_list_in, FALSE);
   BEGIN
      validate_list (list_in);

      IF v_keep
      THEN
         /* Do a slow but smart delete, and then are done. */
         FOR v_item IN 1 .. nitems (list_in)
         LOOP
            deleteitem (list_in, 1);
         END LOOP;
      ELSE
         /* Wipe out the rows quickly and then get rid of the list pointer. */
         items2000.DELETE (liststart (list_in), listend (list_in));
         lists.DELETE (list_in);
      END IF;
   END;

   PROCEDURE deleteitem 
      (list_in IN VARCHAR2, 
       item_in IN VARCHAR2,
       all_in IN BOOLEAN := FALSE)
   IS
      idx PLS_INTEGER;
   BEGIN
      validate_list (list_in, idx);
      deleteitem (idx, item_in, all_in);
   END;

   PROCEDURE deleteitem 
      (list_in IN PLS_INTEGER, 
       item_in IN VARCHAR2,
       all_in IN BOOLEAN := FALSE)
   IS
      curind PLS_INTEGER;
      lastind PLS_INTEGER;
   BEGIN
      validate_list (list_in);

      curind := liststart (list_in);
      lastind := listend (list_in);

      LOOP
         IF itemmatch (list_in, curind, item_in)
         THEN
            remitem (list_in, curind, FALSE);
            EXIT WHEN NOT all_in;
         END IF;

         curind := nextitemrow (list_in, curind);
         EXIT WHEN curind IS NULL OR curind > lastind;         
      END LOOP;

      compresslist (list_in);
   END;

   PROCEDURE deleteitem (list_in IN VARCHAR2, pos_in IN PLS_INTEGER)
   IS
      idx PLS_INTEGER;
   BEGIN
      validate_list (list_in, idx);
      deleteitem (idx, pos_in);
   END;

   PROCEDURE deleteitem (list_in IN PLS_INTEGER, pos_in IN PLS_INTEGER)
   IS
   BEGIN
      validate_list (list_in);
      validate_range (list_in, pos_in);
      
      remitem (list_in, pos_in, FALSE);
      
      shiftlist (list_in, pos_in+1, -1);
      
      incrnum (list_in, -1);
      
      remtrailing (list_in);
   END;

   FUNCTION getitem (list_in IN VARCHAR2, pos_in IN PLS_INTEGER)
      RETURN VARCHAR2
   /* Return the item specified by the input position. */
   IS
      idx PLS_INTEGER;
   BEGIN
      validate_list (list_in, idx);
      RETURN (getitem (idx, pos_in));
   END;

   FUNCTION getitem (list_in IN PLS_INTEGER, pos_in IN PLS_INTEGER)
      RETURN VARCHAR2
   /* Return the item specified by the input position. */
   IS
      idx PLS_INTEGER;
   BEGIN
      validate_list (list_in);
      RETURN items2000 (itemrow (list_in, pos_in));
   END;

   FUNCTION getposition (list_in IN VARCHAR2, item_in IN VARCHAR2)
      RETURN PLS_INTEGER
   IS
      idx PLS_INTEGER;
   BEGIN
      validate_list (list_in, idx);
      RETURN (getposition (idx, item_in));
   END;
   
   FUNCTION getposition (list_in IN PLS_INTEGER, item_in IN VARCHAR2)
      RETURN PLS_INTEGER
   IS
      v_curr PLS_INTEGER;
      v_end PLS_INTEGER;
      retval PLS_INTEGER := 0;
   BEGIN
      validate_list (list_in);

      IF nitems (list_in) > 0
      THEN
         v_curr := liststart (list_in);
         v_end := listend (list_in);

         LOOP
            IF itemmatch (list_in, v_curr, item_in)
            THEN
               retval := v_curr;
               EXIT;
            ELSE
               v_curr := nextitemrow (list_in, v_curr); 
               EXIT WHEN v_curr IS NULL OR v_curr > v_end;
            END IF;        
         END LOOP;
      END IF;
      IF retval > 0
      THEN
         retval := PLGofst.unshifted (list_in, v_maxitems, retval, 1);
      END IF;
      RETURN retval;
   END;

   PROCEDURE insertitem 
      (list_in IN VARCHAR2, pos_in IN PLS_INTEGER, item_in IN VARCHAR2)
   IS
      idx PLS_INTEGER;
   BEGIN
      validate_list (list_in, idx);
      insertitem (idx, pos_in, item_in);
   END;

   PROCEDURE insertitem 
      (list_in IN PLS_INTEGER, pos_in IN PLS_INTEGER, item_in IN VARCHAR2)
   IS
   BEGIN
      validate_list (list_in);
      validate_space (list_in);
      validate_range (list_in, pos_in);

      shiftlist (list_in, pos_in, +1);
      setitem (list_in, pos_in, item_in);
      incrnum (list_in);
   END;

   PROCEDURE make 
      (list_in IN VARCHAR2,
       overwrite_in IN BOOLEAN := FALSE,
       maxlen_in IN PLS_INTEGER := PLGadmin.dbmax_len)
   IS
      idx PLS_INTEGER;
   BEGIN
      idx := make (list_in, overwrite_in, maxlen_in);
   END;

   FUNCTION make 
      (list_in IN VARCHAR2,
       overwrite_in IN BOOLEAN := FALSE,
       maxlen_in IN PLS_INTEGER := PLGadmin.dbmax_len)
   RETURN PLS_INTEGER
   IS
      makeit BOOLEAN := TRUE;
      retval PLS_INTEGER := id (list_in);
   BEGIN
      makeit := retval IS NULL;

      IF NOT makeit /* Already exists */
      THEN
         makeit := overwrite_in;
         IF makeit
         THEN
            PLGlst.destroy (retval);
         END IF;
      END IF;

      IF makeit
      THEN
         retval := NVL (lists.LAST, 0) + 1;

         lists(retval).name := UPPER (LTRIM (RTRIM(list_in)));
         lists(retval).num := 0;
         lists(retval).firstrow := (retval-1)*maxitems + 1;
      END IF;

      RETURN retval;
   END;

   FUNCTION make 
      (overwrite_in IN BOOLEAN := FALSE,
       maxlen_in IN PLS_INTEGER := PLGadmin.dbmax_len)
   RETURN PLS_INTEGER
   IS
   BEGIN
      RETURN make (NULL, overwrite_in, maxlen_in);
   END;

   PROCEDURE prependitem (list_in IN VARCHAR2, item_in IN VARCHAR2)
   IS
   BEGIN
      insertitem (list_in, 1, item_in);
   END;

   PROCEDURE prependitem (list_in IN PLS_INTEGER, item_in IN VARCHAR2)
   IS
   BEGIN
      insertitem (list_in, 1, item_in);
   END;

   PROCEDURE replaceitem 
      (list_in IN VARCHAR2, pos_in IN PLS_INTEGER, item_in IN VARCHAR2)
   IS
      idx PLS_INTEGER;
   BEGIN
      validate_list (list_in, idx);
      replaceitem (idx, pos_in, item_in);
   END;

   PROCEDURE replaceitem 
      (list_in IN PLS_INTEGER, pos_in IN PLS_INTEGER, item_in IN VARCHAR2)
   IS
   BEGIN
      validate_list (list_in);
      validate_range (list_in, pos_in);
      setitem (list_in, pos_in, item_in);
   END;

   PROCEDURE display (list_in IN VARCHAR2) 
   IS
      idx PLS_INTEGER;
   BEGIN
      validate_list (list_in, idx);
      display (idx);
   END;

   PROCEDURE display (list_in IN PLS_INTEGER) 
   IS
   BEGIN
      validate_list (list_in);
      DBMS_OUTPUT.PUT_LINE ('Contents of "' || name (list_in) || '"');

      FOR rowind IN 1 .. nitems (list_in)
      LOOP
         DBMS_OUTPUT.PUT_LINE (
            TO_CHAR (rowind) || ' = ' || getitem (list_in, rowind));
      END LOOP;
   END;

   PROCEDURE show (list_in IN VARCHAR2) 
   IS
      idx PLS_INTEGER;
   BEGIN
      validate_list (list_in, idx);
      show (idx, list_in);
   END;

   PROCEDURE show (list_in IN PLS_INTEGER, name_in IN VARCHAR2 := NULL)
   IS
   BEGIN
      validate_list (list_in);
      DBMS_OUTPUT.PUT_LINE ('Structure of ' || 
           NVL (name_in, NVL (name(list_in), 'Anonymous')) ||
           ' - ID = ' || TO_CHAR (list_in));
      DBMS_OUTPUT.PUT_LINE ('Num ' || lists(list_in).num); 
      DBMS_OUTPUT.PUT_LINE ('Max Starts at ' || liststart(list_in)); 
      DBMS_OUTPUT.PUT_LINE ('Max Ends at ' || listend(list_in)); 
      DBMS_OUTPUT.PUT_LINE ('Actual Starts at ' || liststart(list_in, TRUE)); 
      DBMS_OUTPUT.PUT_LINE ('Actual Ends at ' || listend(list_in, 1, TRUE)); 
   END;

   PROCEDURE showall 
   IS
      v_row PLS_INTEGER := lists.FIRST;
   BEGIN
      IF lists.COUNT = 0
      THEN
         DBMS_OUTPUT.PUT_LINE ('No lists defined.');
      ELSE
         LOOP
            EXIT WHEN v_row IS NULL;
            show (lists(v_row).name);
            v_row := lists.NEXT (v_row);
         END LOOP;
      END IF;
   END;
END PLGlst;
/
rem show errors