plgiseg.spb

Oracle PL/SQL procedure generator (second generator type)

CREATE OR REPLACE PACKAGE BODY PLGiseg   
IS
/*----------------------------------------------------------------
||                PL/Vision Professional 
||----------------------------------------------------------------
||    File: PLGiseg.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
||
-----------------------------------------------------------------*/
/***************** Modification History **************************
|| Date     By     Description
|| -------- ------ -----------------------------------------------
|| 10/98    SEF    Problem with INSTR
|| 7/98     SEF    Remove clearstg
|| 1/97     SEF    1997Q1 Release
******************************************************************/
   c_pkg PLGadmin.identifier := 'PLGiseg';

   g_itemdelim VARCHAR2(20) := c_itemdelim;
   g_segdelim VARCHAR2(20) := c_segdelim;
  
   seglens PLGadmin.integer_tabtype;
      
   --seglist seglist_rectype;
   --nullseglist seglist_rectype;
   
/* Private Programs */

   PROCEDURE set_counts (seglist IN OUT seglist_rectype,
      items IN INTEGER, segs IN INTEGER := NULL)
   IS
   BEGIN
      seglist.numitems := items;
      IF items = 1 THEN setitem (seglist, 1); END IF;
      
      IF segs IS NOT NULL
      THEN
         seglist.numsegs := segs;
      ELSE         
         seglist.numsegs := 
            (PLGprs.numinstr (seglist.string, seglist.segdelim)
             / seglist.numitems) + 1;
      END IF;
   END;
      
   PROCEDURE set_start_end 
      (seglist IN OUT seglist_rectype, pos IN INTEGER, st OUT INTEGER, nd OUT INTEGER)
   IS
   BEGIN
      IF seglist.fixedlen
      THEN
         st := PLGofst.first (pos, seglist.itemlen, 1);
         nd := PLGofst.last (pos, seglist.itemlen, 1);
      ELSE
         st := INSTR (seglist.string, seglist.itemdelim, 1, pos) + 
            LENGTH(seglist.itemdelim);
         nd := INSTR (seglist.string, seglist.itemdelim, 1, pos+1) - 1;
      END IF;
   END;

/* Public Programs */

   PROCEDURE setdelims
      (item IN VARCHAR2 := NULL, seg IN VARCHAR2 := NULL)
   IS
   BEGIN
      g_itemdelim := PLGadmin.ifelse (item IS NULL, g_itemdelim, item);
      g_segdelim := PLGadmin.ifelse (seg IS NULL, g_segdelim, seg);
   END;

   FUNCTION defitemdelim RETURN VARCHAR2
   IS BEGIN RETURN g_itemdelim; END;

   FUNCTION defsegdelim RETURN VARCHAR2
   IS BEGIN RETURN g_segdelim; END;
  
   PROCEDURE loadstg 
      (string IN VARCHAR2,
       itemdelim IN VARCHAR2 := defitemdelim,
       segdelim IN VARCHAR2 := defsegdelim,
       numsegs IN INTEGER := NULL,
       seglist IN OUT seglist_rectype)
   IS
   BEGIN
      PLGerr.assert (NVL (numsegs, 1) > 0, 'Number of segments must be > 0.');
         
      seglist.oneitem := FALSE;
      seglist.fixedlen := FALSE;
      seglist.curritem := NULL;
      seglist.startitem := NULL;
      seglist.enditem := NULL;
      
      seglist.itemdelim := itemdelim;
      seglist.segdelim := segdelim;
         
      /* Is it just a single item? */
      seglist.string := PLGstr.lstrip 
         (PLGstr.rstrip (string, seglist.itemdelim, 1), seglist.itemdelim, 1);
      
      IF INSTR (seglist.string, seglist.itemdelim) = 0 OR seglist.itemdelim IS NULL
      THEN
         loaditem (seglist.string, segdelim, numsegs, seglist=>seglist);
      ELSE
         /* Make sure string is surrounded by item delimiter. */
         seglist.string :=  
            PLGadmin.surrounded (seglist.string, seglist.itemdelim, FALSE);
         set_counts  
            (seglist,
             PLGprs.numinstr (seglist.string, seglist.itemdelim) - 1, numsegs);
      END IF;
   END;

   PROCEDURE loaditem 
      (item IN VARCHAR2,
       segdelim IN VARCHAR2 := defsegdelim,
       numsegs IN INTEGER := NULL,
       seglist IN OUT seglist_rectype)
   IS
   BEGIN
      PLGerr.assert (NVL (numsegs, 1) > 0, 'Number of segments must be > 0.');
         
      seglist.fixedlen := FALSE;
      seglist.oneitem := TRUE;
      seglist.itemdelim := NULL;
      seglist.segdelim := segdelim;
         
      IF seglist.segdelim IS NOT NULL
      THEN
         seglist.string := LTRIM (RTRIM (item, seglist.segdelim), seglist.segdelim);
      ELSE 
         seglist.string := item;
      END IF;
      
      seglist.startitem := 1;
      seglist.enditem := LENGTH (item);
      set_counts (seglist, 1, numsegs);
   END;

   FUNCTION numsegs (seglist IN OUT seglist_rectype) RETURN INTEGER IS
   BEGIN
      RETURN seglist.numsegs;
   END;

   FUNCTION itemdelim (seglist IN OUT seglist_rectype) RETURN VARCHAR2 IS
   BEGIN
      RETURN seglist.itemdelim;
   END;
      
   FUNCTION segdelim (seglist IN OUT seglist_rectype) RETURN VARCHAR2 IS
   BEGIN
      RETURN seglist.segdelim;
   END;
   
   FUNCTION itemlen (seglist IN OUT seglist_rectype) RETURN INTEGER IS
   BEGIN
      RETURN seglist.itemlen;
   END;
   
/* Get and set list information */
      
   PROCEDURE setitem (seglist IN OUT seglist_rectype,
       pos IN INTEGER) IS
   BEGIN
      PLGerr.assert
        (pos BETWEEN 1 AND seglist.numitems,
         'Item specified at position ' || pos || ' is out of range.');

      seglist.curritem := pos;

      IF NOT seglist.oneitem
      THEN
         set_start_end (seglist, pos, seglist.startitem, seglist.enditem);
      END IF;
   END;
   
   FUNCTION item (seglist IN OUT seglist_rectype,
       pos IN INTEGER := NULL) RETURN VARCHAR2
   IS
      v_start INTEGER := seglist.startitem;
      v_end INTEGER := seglist.enditem;
   BEGIN
      IF pos IS NOT NULL AND NOT seglist.oneitem
      THEN
         PLGerr.assert
           (pos BETWEEN 1 AND seglist.numitems,
            'Item specified is out of range.');
         set_start_end (seglist, pos, v_start, v_end);
      ELSE
         PLGerr.assert 
            (seglist.curritem IS NOT NULL,
             'You must set a current item.');
      END IF;
      
      RETURN PLGstr.betwn (seglist.string, v_start, v_end);
   END;

   FUNCTION itempos (seglist IN OUT seglist_rectype) RETURN INTEGER IS 
   BEGIN
      RETURN seglist.curritem;
   END;

   FUNCTION numitems (seglist IN OUT seglist_rectype) RETURN INTEGER IS
   BEGIN
      RETURN seglist.numitems;
   END;

   /* Gets Nth segment value from current item */

   FUNCTION val (seglist IN OUT seglist_rectype,
       item IN INTEGER, seg IN INTEGER) RETURN VARCHAR2
   IS
      v_changing_item BOOLEAN := 
         item != seglist.curritem OR seglist.curritem IS NULL;
      v_old INTEGER := seglist.curritem; 
      v_start INTEGER;
      v_end INTEGER;
   BEGIN
      PLGerr.assert
         (seg BETWEEN 1 AND seglist.numsegs, 'Segment number out of range.');
      
      PLGerr.assert 
         (item BETWEEN 1 AND seglist.numitems, 'Item specified is out of range.');

      IF seglist.fixedlen
      THEN
         v_start := PLGofst.first (item, seglist.itemlen, 1);
         FOR segind IN 1 .. seg - 1
         LOOP 
            v_start := v_start + seglens (segind) + seglist.spacing;
         END LOOP;
         v_end := v_start + seglens(seg) - 1;
      ELSE
         IF v_changing_item
         THEN
            setitem (seglist, item);
         END IF;
         
         /* 10/28/98 Don't use PLGadmin.ifelse */
         IF seg = 1
         THEN
            v_start := seglist.startitem;
         ELSE
            v_start := 
               INSTR (seglist.string, seglist.segdelim, 
                   seglist.startitem, seg - 1)+LENGTH(seglist.segdelim);
         END IF;
         
         v_end := 
            PLGadmin.ifelse 
               (seg = seglist.numsegs, seglist.enditem, 
                INSTR (seglist.string, seglist.segdelim, 
                   seglist.startitem, seg)-1);
                   
         IF v_changing_item	AND v_old IS NOT NULL
         THEN
            setitem (seglist, v_old);
         END IF;         
      END IF;
      RETURN PLGstr.betwn (seglist.string, v_start, v_end);
   EXCEPTION
      WHEN NO_DATA_FOUND
      THEN
         DBMS_OUTPUT.PUT_LINE ('PLGiseg: segment lengths table is not valid.');
   END;

   FUNCTION val (seglist IN OUT seglist_rectype,
       pos IN INTEGER) RETURN VARCHAR2
   IS
      v_start INTEGER;
      v_end INTEGER;
   BEGIN
      PLGerr.assert (seglist.curritem IS NOT NULL, 'You must set a current item.');
      RETURN val (seglist, seglist.curritem, pos);
   END;

END PLGiseg;
/
rem show errors