DataMuseum.dk

top - download

    Length: 6431 (0x191f)
    Types: TextFile
    Names: »V«

└─⟦a7d1ea751⟧ Bits:30000550 8mm tape, Rational 1000, !users!projects 94_04_11
    └─ ⟦129cab021⟧ »DATA« 
        └─⟦bb25a46d4⟧ 
└─⟦f64eaa120⟧ Bits:30000752 8mm tape, Rational 1000, !projects 93 02 16
    └─ ⟦6f12a12be⟧ »DATA« 
        └─⟦bb25a46d4⟧ 
└─⟦2f6cfab89⟧ Bits:30000547 8mm tape, Rational 1000, !projects 94-01-04
    └─ ⟦d65440be7⟧ »DATA« 
        └─⟦bb25a46d4⟧ 
            └─⟦this⟧ 

TextFile

with ACTION;
pragma PRIVATE_EYES_ONLY;
with DIRECTORY;
with SIMPLE_STATUS;
package REQUIREMENTS is

   subtype COUNT is NATURAL range 0 .. 127;

   type REQUIREMENT_KIND is (NOT_A_REQUIREMENT,

                             FUNCTIONAL,

                             PERFORMANCE,  
                             EXTERNAL_INTERFACE,  
                             OPERATIONAL,  
                             RESOURCE,  
                             QUALIFICATION_TESTING,  
                             ACCEPTANCE_TESTING,  
                             DOCUMENTATION,  
                             QUALITY,  
                             SAFETY,  
                             RELIABILITY,  
                             MAINTAINABILITY,  
                             DEVELOPMENT_AND_VERIFICATION,  
                             DESIGN_AND_PROGRAMMING,  
                             REUSE_AND_COMMONALITY);

   subtype NON_FUNCTIONAL is
      REQUIREMENT_KIND range REQUIREMENT_KIND'SUCC (FUNCTIONAL) ..
                                REQUIREMENT_KIND'LAST;

   subtype VERIFICATION is REQUIREMENT_KIND
                              range QUALIFICATION_TESTING .. ACCEPTANCE_TESTING;

   subtype DEPENDABILITY is REQUIREMENT_KIND range QUALITY .. MAINTAINABILITY;

   subtype IMPLEMENTATION is
      REQUIREMENT_KIND range DEVELOPMENT_AND_VERIFICATION ..
                                REUSE_AND_COMMONALITY;

   type REQUIREMENT_NUMBER is new POSITIVE;
   subtype FUNCTIONAL_REQUIREMENT_NUMBER is
      REQUIREMENT_NUMBER range REQUIREMENT_NUMBER'FIRST .. 9;
   subtype NON_FUNCTIONAL_REQUIREMENT_NUMBER is
      REQUIREMENT_NUMBER range FUNCTIONAL_REQUIREMENT_NUMBER'LAST + 1 ..
                                  REQUIREMENT_NUMBER'LAST;


   --                    ---------------------------
   --                    ( ) Individual requirements
   --                    ---------------------------


   type REQUIREMENT (KIND : REQUIREMENT_KIND := NOT_A_REQUIREMENT) is private;
   subtype FUNCTIONAL_REQUIREMENT is REQUIREMENT (FUNCTIONAL);


   function RESOLVE (MODEL_GATEWAY_NAME : in STRING;
                     MODULE_ID : in POSITIVE;  
                     REQUIREMENT_ID : in REQUIREMENT_NUMBER;
                     ACTION_ID : in ACTION.ID) return REQUIREMENT;

   function COMMENT (ASA_GATEWAY_NAME : in STRING;  
                     ACTION_ID : in ACTION.ID) return STRING;

   function DIAGNOSIS (REQ : in REQUIREMENT) return STRING;
   function GATEWAY_FULL_NAME (REQ : in REQUIREMENT) return STRING;
   function UNIQUE_ID (REQ : in REQUIREMENT) return STRING;
   function TEXT (REQ : in REQUIREMENT) return STRING;

   type PERMANENT_REPRESENTATION is array (POSITIVE range 1 .. 4) of INTEGER;

   function CONVERT (REQ : in REQUIREMENT) return PERMANENT_REPRESENTATION;
   function CONVERT (REP : in PERMANENT_REPRESENTATION;
                     ACTION_ID : in ACTION.ID) return REQUIREMENT;


   --                    --------------------------
   --                    ( ) Requirements hierarchy
   --                    --------------------------


   type REQUIREMENT_ITERATOR (SIZE : COUNT := 0) is private;

   function RESOLVE (ASA_GATEWAY_NAME : in STRING;
                     KIND : in REQUIREMENT_KIND;
                     ACTION_ID : ACTION.ID) return REQUIREMENT_ITERATOR;

   function VALUE (REQS : in REQUIREMENT_ITERATOR) return REQUIREMENT;
   function DONE (REQS : in REQUIREMENT_ITERATOR) return BOOLEAN;
   procedure NEXT (REQS : in out REQUIREMENT_ITERATOR);

   procedure ADD (REQ : in REQUIREMENT; REQS : in out REQUIREMENT_ITERATOR);
   procedure REMOVE (REQ : in REQUIREMENT; REQS : in out REQUIREMENT_ITERATOR);


   --                    ----------------
   --                    ( ) Dependencies
   --                    ----------------


   type DEPENDENTS (IS_BAD : BOOLEAN) is private;

   function GET_DEPENDENTS (REQ : in REQUIREMENT) return DEPENDENTS;

   procedure SET_DEPENDENTS (REQ : in REQUIREMENT;  
                             DEP : in DEPENDENTS);

   procedure ADD (DEP : in out DEPENDENTS;  
                  ONTO : in STRING);

   procedure REMOVE (DEP : in out DEPENDENTS;  
                     ONTO : in STRING);

   function DIAGNOSIS (DEP : in DEPENDENTS) return STRING;


   --                    --------------
   --                    ( ) Exceptions
   --                    --------------


   DEPENDENT_ERROR : exception;
   REQUIREMENT_ERROR : exception;

private

   package DIR renames DIRECTORY;
   package DNA renames DIRECTORY.NAMING;

   type STATUS_KIND is (MODULE_ID_ERROR,  
                        DIRECTORY_ERROR,  
                        DIRECTORY_NAMING_ERROR,  
                        GENERAL_ERROR);

   type STATUS (KIND : STATUS_KIND := GENERAL_ERROR) is
      record  
         case KIND is

            when MODULE_ID_ERROR =>
               null;

            when DIRECTORY_ERROR =>
               ERROR_STATUS : DIR.ERROR_STATUS;

            when DIRECTORY_NAMING_ERROR =>
               NAME_STATUS : DNA.NAME_STATUS;

            when GENERAL_ERROR =>
               CONDITION : SIMPLE_STATUS.CONDITION;
         end case;
      end record;

   type REQUIREMENT (KIND : REQUIREMENT_KIND := NOT_A_REQUIREMENT) is
      record
         case KIND is

            when NOT_A_REQUIREMENT =>
               ERROR : STATUS;

            when FUNCTIONAL | NON_FUNCTIONAL =>
               ACTION_ID : ACTION.ID;
               OBJECT : DIR.OBJECT;
               case KIND is

                  when NOT_A_REQUIREMENT =>
                     null;

                  when FUNCTIONAL =>
                     ID : FUNCTIONAL_REQUIREMENT_NUMBER;

                  when NON_FUNCTIONAL =>
                     null;
               end case;
         end case;
      end record;

   type REQUIREMENT_LIST is array (COUNT range <>) of REQUIREMENT;

   type REQUIREMENT_ITERATOR (SIZE : COUNT := 0) is
      record
         POS : COUNT := 1;
         CONTENTS : REQUIREMENT_LIST (1 .. SIZE);
      end record;

   type OBJECT_LIST is array (COUNT range <>) of DIR.OBJECT;

   type OBJECT_LIST_ACCESS is access OBJECT_LIST;
   pragma SEGMENTED_HEAP (OBJECT_LIST_ACCESS);

   type DEPENDENTS (IS_BAD : BOOLEAN) is
      record
         case IS_BAD is

            when FALSE =>
               OBJECTS : OBJECT_LIST_ACCESS;

            when TRUE =>
               ERROR : STATUS;
         end case;
      end record;

end REQUIREMENTS;