Inheritance in Java

ski_doosh41
inventory_java_1.zip
Home>Computer Science homework help>Inheritance in Java

gradlew

#!/usr/bin/env bash ############################################################################## ## ## Gradle start up script for UN*X ## ############################################################################## # Attempt to set APP_HOME # Resolve links: $0 may be a link PRG="$0" # Need this for relative symlinks. while [ -h "$PRG" ] ; do ls=`ls -ld "$PRG"` link=`expr "$ls" : '.*-> \(.*\)$'` if expr "$link" : '/.*' > /dev/null; then PRG="$link" else PRG=`dirname "$PRG"`"/$link" fi done SAVED="`pwd`" cd "`dirname \"$PRG\"`/" >/dev/null APP_HOME="`pwd -P`" cd "$SAVED" >/dev/null APP_NAME="Gradle" APP_BASE_NAME=`basename "$0"` # Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script. DEFAULT_JVM_OPTS="" # Use the maximum available, or set MAX_FD != -1 to use that value. MAX_FD="maximum" warn ( ) { echo "$*" } die ( ) { echo echo "$*" echo exit 1 } # OS specific support (must be 'true' or 'false'). cygwin=false msys=false darwin=false nonstop=false case "`uname`" in CYGWIN* ) cygwin=true ;; Darwin* ) darwin=true ;; MINGW* ) msys=true ;; NONSTOP* ) nonstop=true ;; esac CLASSPATH=$APP_HOME/gradle/wrapper/gradle-wrapper.jar # Determine the Java command to use to start the JVM. if [ -n "$JAVA_HOME" ] ; then if [ -x "$JAVA_HOME/jre/sh/java" ] ; then # IBM's JDK on AIX uses strange locations for the executables JAVACMD="$JAVA_HOME/jre/sh/java" else JAVACMD="$JAVA_HOME/bin/java" fi if [ ! -x "$JAVACMD" ] ; then die "ERROR: JAVA_HOME is set to an invalid directory: $JAVA_HOME Please set the JAVA_HOME variable in your environment to match the location of your Java installation." fi else JAVACMD="java" which java >/dev/null 2>&1 || die "ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH. Please set the JAVA_HOME variable in your environment to match the location of your Java installation." fi # Increase the maximum file descriptors if we can. if [ "$cygwin" = "false" -a "$darwin" = "false" -a "$nonstop" = "false" ] ; then MAX_FD_LIMIT=`ulimit -H -n` if [ $? -eq 0 ] ; then if [ "$MAX_FD" = "maximum" -o "$MAX_FD" = "max" ] ; then MAX_FD="$MAX_FD_LIMIT" fi ulimit -n $MAX_FD if [ $? -ne 0 ] ; then warn "Could not set maximum file descriptor limit: $MAX_FD" fi else warn "Could not query maximum file descriptor limit: $MAX_FD_LIMIT" fi fi # For Darwin, add options to specify how the application appears in the dock if $darwin; then GRADLE_OPTS="$GRADLE_OPTS \"-Xdock:name=$APP_NAME\" \"-Xdock:icon=$APP_HOME/media/gradle.icns\"" fi # For Cygwin, switch paths to Windows format before running java if $cygwin ; then APP_HOME=`cygpath --path --mixed "$APP_HOME"` CLASSPATH=`cygpath --path --mixed "$CLASSPATH"` JAVACMD=`cygpath --unix "$JAVACMD"` # We build the pattern for arguments to be converted via cygpath ROOTDIRSRAW=`find -L / -maxdepth 1 -mindepth 1 -type d 2>/dev/null` SEP="" for dir in $ROOTDIRSRAW ; do ROOTDIRS="$ROOTDIRS$SEP$dir" SEP="|" done OURCYGPATTERN="(^($ROOTDIRS))" # Add a user-defined pattern to the cygpath arguments if [ "$GRADLE_CYGPATTERN" != "" ] ; then OURCYGPATTERN="$OURCYGPATTERN|($GRADLE_CYGPATTERN)" fi # Now convert the arguments - kludge to limit ourselves to /bin/sh i=0 for arg in "$@" ; do CHECK=`echo "$arg"|egrep -c "$OURCYGPATTERN" -` CHECK2=`echo "$arg"|egrep -c "^-"` ### Determine if an option if [ $CHECK -ne 0 ] && [ $CHECK2 -eq 0 ] ; then ### Added a condition eval `echo args$i`=`cygpath --path --ignore --mixed "$arg"` else eval `echo args$i`="\"$arg\"" fi i=$((i+1)) done case $i in (0) set -- ;; (1) set -- "$args0" ;; (2) set -- "$args0" "$args1" ;; (3) set -- "$args0" "$args1" "$args2" ;; (4) set -- "$args0" "$args1" "$args2" "$args3" ;; (5) set -- "$args0" "$args1" "$args2" "$args3" "$args4" ;; (6) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" ;; (7) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" "$args6" ;; (8) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" "$args6" "$args7" ;; (9) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" "$args6" "$args7" "$args8" ;; esac fi # Split up the JVM_OPTS And GRADLE_OPTS values into an array, following the shell quoting and substitution rules function splitJvmOpts() { JVM_OPTS=("$@") } eval splitJvmOpts $DEFAULT_JVM_OPTS $JAVA_OPTS $GRADLE_OPTS JVM_OPTS[${#JVM_OPTS[*]}]="-Dorg.gradle.appname=$APP_BASE_NAME" # by default we should be in the correct project dir, but when run from Finder on Mac, the cwd is wrong if [[ "$(uname)" == "Darwin" ]] && [[ "$HOME" == "$PWD" ]]; then cd "$(dirname "$0")" fi exec "$JAVACMD" "${JVM_OPTS[@]}" -classpath "$CLASSPATH" org.gradle.wrapper.GradleWrapperMain "$@"

gradlew.bat

@if "%DEBUG%" == "" @echo off @rem ########################################################################## @rem @rem Gradle startup script for Windows @rem @rem ########################################################################## @rem Set local scope for the variables with windows NT shell if "%OS%"=="Windows_NT" setlocal set DIRNAME=%~dp0 if "%DIRNAME%" == "" set DIRNAME=. set APP_BASE_NAME=%~n0 set APP_HOME=%DIRNAME% @rem Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script. set DEFAULT_JVM_OPTS= @rem Find java.exe if defined JAVA_HOME goto findJavaFromJavaHome set JAVA_EXE=java.exe %JAVA_EXE% -version >NUL 2>&1 if "%ERRORLEVEL%" == "0" goto init echo. echo ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH. echo. echo Please set the JAVA_HOME variable in your environment to match the echo location of your Java installation. goto fail :findJavaFromJavaHome set JAVA_HOME=%JAVA_HOME:"=% set JAVA_EXE=%JAVA_HOME%/bin/java.exe if exist "%JAVA_EXE%" goto init echo. echo ERROR: JAVA_HOME is set to an invalid directory: %JAVA_HOME% echo. echo Please set the JAVA_HOME variable in your environment to match the echo location of your Java installation. goto fail :init @rem Get command-line arguments, handling Windows variants if not "%OS%" == "Windows_NT" goto win9xME_args :win9xME_args @rem Slurp the command line arguments. set CMD_LINE_ARGS= set _SKIP=2 :win9xME_args_slurp if "x%~1" == "x" goto execute set CMD_LINE_ARGS=%* :execute @rem Setup the command line set CLASSPATH=%APP_HOME%\gradle\wrapper\gradle-wrapper.jar @rem Execute Gradle "%JAVA_EXE%" %DEFAULT_JVM_OPTS% %JAVA_OPTS% %GRADLE_OPTS% "-Dorg.gradle.appname=%APP_BASE_NAME%" -classpath "%CLASSPATH%" org.gradle.wrapper.GradleWrapperMain %CMD_LINE_ARGS% :end @rem End local scope for the variables with windows NT shell if "%ERRORLEVEL%"=="0" goto mainEnd :fail rem Set variable GRADLE_EXIT_CONSOLE if you need the _script_ return code instead of rem the _cmd.exe /c_ return code! if not "" == "%GRADLE_EXIT_CONSOLE%" exit 1 exit /b 1 :mainEnd if "%OS%"=="Windows_NT" endlocal :omega

src/main/java/edu/odu/cs/cs330/Storage.java

src/main/java/edu/odu/cs/cs330/Storage.java

package  edu . odu . cs . cs330 ;

import  java . io . FileReader ;
import  java . io . BufferedReader ;
import  java . io . IOException ;
import  java . util . Scanner ;

import  edu . odu . cs . cs330 . items . * ;

public   class   Storage   {
     /**
     * This is the first Java Assignment, Item Storage in Java.
     *
     *  @param  argv[1] items filename
     *  @param  argv[2] inventories filename
     */
     public   static   void  main ( String []  argv )
     {
         BufferedReader  infile  =   null ;
         Inventory  inv  =   null ;
         int  invSize  =   10 ;

         if   ( argv . length  <   1 )   {
             System . err . println ( "Usage: java -jar Storage.jar items-file" );
             System . exit ( 1 );
         }

         // If an inventory size was specified, parse it.
         try   {
            invSize  =   Integer . parseInt ( argv [ 1 ]);
         }
         catch   ( IndexOutOfBoundsException  e )   {
             // pass
            invSize  =   10 ;   //default to 10
         }
         catch   ( NumberFormatException  e )   {
             System . err . println ( "Inventory size must be an integer" );
             System . exit ( 2 );
         }

         // Default to 10 if invSize is invalid--i.e., <= 0
         if   ( invSize  <   1 )   {
            invSize  =   10 ;
         }

         try   {
            infile  =   new   BufferedReader ( new   FileReader ( argv [ 0 ]));
            inv  =  createInventory ( infile ,  invSize );
            infile . close ();

         }
         catch   ( IOException  e )   {
             System . err . println ( "Error: "   +  argv [ 0 ]   +   " could not be opened or read" );
             System . exit ( 3 );
         }

         // Print the Inventory
        printInventorySummary ( inv );
     }

     /**
     * Read an input stream and generate an Inventory.
     *
     *  @param  ins source from which to read Items
     *  @param  size desired number of Inventory slots
     *
     *  @return  initialized Inventory
     *
     *  @throws  IOException if an input error occurs
     */
     public   static   Inventory  createInventory ( BufferedReader  ins ,   int  size )
         throws   IOException
     {
         Scanner    scanner    =   new   Scanner ( ins );
         Inventory  inventory  =   new   Inventory ( size );

         System . out . println ( "Processing Log:" );

         while   ( scanner . hasNext ())   {
             Item  item  =   ItemFactory . parseItemLine ( scanner );

             if   ( item  !=   null )   {
                 boolean  success  =  inventory . addItems ( new   ItemStack ( item ));

                 if   ( success )   {
                     System . out . println ( " (S) "   +  item . getName ());
                 }
                 else   {
                    System . out . println ( " (D) "   +  item . getName ());
                 }
             }
         }
         System . out . println ();

         return  inventory ;
     }

     /**
     * Print the final Inventory summary.
     *
     *  @param  inv Inventory to print
     */
     public   static   void  printInventorySummary ( Inventory  inv )
     {
         System . out . println ( "Player Storage Summary:" );
         System . out . println ( inv );
     }
}

src/main/java/edu/odu/cs/cs330/items/Armour.java

src/main/java/edu/odu/cs/cs330/items/Armour.java

package  edu . odu . cs . cs330 . items ;

import  java . util . Scanner ;

/**
 * This class represents one piece of armour--as found in most video games.
 * This includes boots and helmets.
 *
 * Armour may not be stacked. All Constructors must initialize Item::stackable
 * to false.
 */
public   class   Armour   extends   Item   {

     protected   int     durability ;     ///< decreases each time the armour is used
     protected   int     defense ;        ///< damage that is blocked
     protected   String  material ;       ///< material out of which the armour is composed
     protected   String  modifier ;       ///< one of protection, feather_falling, or unbreaking
     protected   int     modiferLevel ;   ///< modifier level in the range 1 to 3
     protected   String  element ;        ///< associated element--e.g., ice, fire, and lightning.

     /**
     * Default to a armour with an empty name.
     */
     public   Armour ()
     {
         // Make the necessary call to super(...)

         this . durability    =   0 ;
         this . defense       =   0 ;
         this . material      =   "" ;
         this . modifier      =   "" ;
         this . modiferLevel  =   1 ;
         this . element       =   "" ;
     }

     /**
     * This is the Copy Constructor.
     */
     public   Armour ( Armour  src )
     {
         // Make the necessary call to super(...)

         this . durability    =  src . durability ;
         this . defense       =  src . defense ;
         this . material      =  src . material ;
         this . modifier      =  src . modifier ;
         this . modiferLevel  =  src . modiferLevel ;
         this . element       =  src . element ;
     }

     /**
     * Retrieve armour durability.
     */
     public   int  getDurability ()
     {
         return   this . durability ;
     }

     /**
     * Set armour durability.
     */
     public   void  setDurability ( int  durability )
     {
         this . durability  =  durability ;
     }

     /**
     * Retrieve armour defense.
     */
     public   int  getDefense ()
     {
         return   this . defense ;
     }

     /**
     * Set armour defense.
     */
     public   void  setDefense ( int  defense )
     {
         this . defense  =  defense ;
     }

     /**
     * Retrieve armour Material.
     */
     public   String  getMaterial ()
     {
         return   this . material ;
     }

     /**
     * Set armour Material.
     */
     public   void  setMaterial ( String  m )
     {
         this . material  =  m ;
     }

     /**
     * Retrieve armour Modifier.
     */
     public   String  getModifier ()
     {
         return   this . modifier ;
     }

     /**
     * Set armour Modifier.
     */
     public   void  setModifier ( String  m )
     {
         this . modifier  =  m ;
     }

     /**
     * Retrieve armour Modifier Level.
     */
     public   int  getModifierLevel ()
     {
         return   this . modiferLevel ;
     }

     /**
     * Set armour Modifier Level.
     */
     public   void  setModifierLevel ( int  level )
     {
         this . modiferLevel  =  level ;
     }

     /**
     * Retrieve armour Element.
     */
     public   String  getElement ()
     {
         return   this . element ;
     }

     /**
     * Set armour Element.
     */
     public   void  setElement ( String  e )
     {
         this . element  =  e ;
     }

     /**
     * Read Armour attributes.
     */
    @ Override
     public   void  read ( Scanner  s )
     {
         super . name    =  s . next ();

         // Read in the remaining values
     }

     /**
     * Clone--i.e., copy--this Armour.
     */
    @ Override
     public   Item  clone ()
     {
         return   null ;
     }

     /**
     * *Print* one Armour.
     */
    @ Override
     public   String  toString ()
     {
         return   "This Is A Placeholder" ;
     }
}




src/main/java/edu/odu/cs/cs330/items/Consumable.java

src/main/java/edu/odu/cs/cs330/items/Consumable.java

package  edu . odu . cs . cs330 . items ;

import  java . util . Scanner ;

/**
 * This class represents one Consumable Item--as found in most video games. This includes
 * food.
 *
 * Consumable Items must be stackable. All Constructors must initialize Item::stackable
 * to true.
 */
public   class   Consumable   extends   Item   {
     protected   String  effect ;   ///< effect recieved by using the Item
     protected   int  uses ;        ///< number of times this Item can be used

     /**
     * Default to a Comsumable Item with an empty name
     */
     public   Consumable ()
     {
         // Make the necessary call to super(...)

         this . effect  =   "" ;
         this . uses    =   0 ;
     }

     /**
     * Copy Constructor
     */
     public   Consumable ( Consumable  src )
     {
         super ( src . name ,   true );   // Is this a hint???

         this . effect  =  src . effect ;
         this . uses   =  src . uses ;
     }

     /**
     * Retrieve effect
     */
     public   String  getEffect ()
     {
         return   this . effect ;
     }

     /**
     * Set effect
     */
     public   void  setEffect ( String  effect )
     {
         this . effect  =  effect ;
     }

     /**
     * Retrieve number of uses
     */
     public   int  getNumberOfUses ()
     {
         return   this . uses ;
     }

     /**
     * Set number of uses
     */
     public   void  setNumberOfUses ( int  u )
     {
         this . uses  =  u ;
     }

     /**
     * Read Consumable Item attributes
     */
    @ Override
     public   void  read ( Scanner  s )
     {
         super . name  =  s . next ();

         // Read in the remaining values

     }

     /**
     * Clone--i.e., copy--this Consumable Item
     */
    @ Override
     public   Item  clone ()
     {
         return   null ;
     }

     /**
     * *Print* the Consumable Item
     */
    @ Override
     public   String  toString ()
     {
         return   "This is a Placeholder" ;
     }
}

src/main/java/edu/odu/cs/cs330/items/Inventory.java

src/main/java/edu/odu/cs/cs330/items/Inventory.java

package  edu . odu . cs . cs330 . items ;

import  java . util . List ;
import  java . util . ArrayList ;

/**
 * An Inventory is composed of n slots. Each slot may store only
 * one type of item--specified by *slots*.
 * <p>
 * Once all slots are filled, no additional Item types may be
 * stored. Individual slots may contain any number of the same
 * Item--if the Item is stackable.
 */
public   class   Inventory   {
     private   List < ItemStack >  slots ;    ///< Individual item slots--each ItemStack represents one slot
     private   int  capacity ;             ///< Maximum inventory size

     /**
     * Default to 10 slots
     */
     public   Inventory ()
     {
         this . slots     =   new   ArrayList < ItemStack > ();
         this . capacity  =   10 ;
     }

     /**
     * Create an inventory with n slots
     *
     *  @param  desiredCapacity size of the new Inventory
     */
     public   Inventory ( int  desiredCapacity )
     {
         this . slots     =   new   ArrayList < ItemStack > ();
         this . capacity  =  desiredCapacity ;
     }

     /**
     * Add one or more items to the inventory list
     *
     *  @return  true if *stack* was added and false otherwise
     */
     public   boolean  addItems ( ItemStack  stack )
     {
         int  loc  =  slots . indexOf ( stack );

         // if a match was found
         if   ( loc  >=   0 )   {
             // If the Item is stackable, add it to the ItemStack
             if   ( slots . get ( loc ). permitsStacking ())   {
                slots . get ( loc ). addItems ( stack . size ());

                 return   true ;
             }
         }

         if   ( slots . size ()   <  capacity )   {
            slots . add ( stack );
             return   true ;
         }

         return   false ;
     }

     /**
     * *Print* a Summary of the Inventory and all Items contained within.
     */
    @ Override
     public   String  toString ()
     {
         StringBuilder  strBld  =   new   StringBuilder ();

         // Compute % full rounded to nearest whole number
         int  percentFilled  =   ( int )   Math . round ( 100.0   *  slots . size ()   /  capacity );

         // Print the usage summary
        strBld . append ( String . format ( " -Used %3d%% of %d slots%n" ,
                                     percentFilled ,  capacity ));

         // Print the Items
         for   ( ItemStack  slot  :  slots )   {
            strBld . append ( slot  +   "\n" );
         }

         return  strBld . toString ();
     }
};

src/main/java/edu/odu/cs/cs330/items/Item.java

src/main/java/edu/odu/cs/cs330/items/Item.java

package  edu . odu . cs . cs330 . items ;

import  java . util . Scanner ;

/**
 * Item represents an individual Item in an inventory.
 * This includes items such as potions, building materials, and food.
 *
 * Only one of each item can exist--i.e., no two items share the
 * same numeric id.
 */
public   abstract   class   Item   implements   Cloneable   {
     /**
     * Indicates whether this Item can placed in an ItemStack larger than 1.
     */
     private   boolean  stackable ;

     /**
     * Short title--e.g., HP Potion
        */
     protected   String  name ;

     /**
     * Default to name = Air and stackable = true
     */
     public   Item ()
     {
         this . name       =   "Air" ;
         this . stackable  =   true ;
     }

     /**
     * Create an Item with a specified and name
     *
     *  @param  name desired name
     *
     *  @pre
     *  - all items that share a name are of the same type
     *  - differences in capitalization denote different items
     */
     public   Item ( String  name )
     {
         this . name       =  name ;
         this . stackable  =   true ;
     }

     /**
     * Create an Item with a specified id and name
     *
     *  @param  name desired name
     *  @param  stackable flag that indicates whether duplicates
     *      of this item can be stacked
     *
     *  @pre
     *  - all items that share a name are of the same type
     *  - differences in capitalization denote different items
     */
     public   Item ( String  name ,   boolean  stackable )
     {
         this . name       =  name ;
         this . stackable  =  stackable ;
     }

     /**
     * Retrieve name
     */
     public   String  getName ()
     {
         return   this . name ;
     }

     /**
     * Update name
     */
     public   void  setName ( String  n )
     {
         this . name  =  n ;
     }

     /**
     * Check for logical equivalence--based on name
     */
    @ Override
     public   boolean  equals ( Object  rhs )
     {
         Item  r  =   ( Item )  rhs ;

         return   this . name . equals ( r . name );
     }

     /**
     * Generate a hash code based on name
     */
    @ Override
     public   int  hashCode ()
     {
         return   this . name . hashCode ();
     }

     /**
     * Can this item be placed in a stack?
     */
     public   boolean  isStackable ()
     {
         return   this . stackable ;
     }

     /**
     * Read the item from an input array
     */
     public   abstract   void  read ( Scanner  s );

     /**
     * Duplicate this item
     */
    @ Override
     public   abstract   Item  clone ();

     /**
     * *Print* an Item
     */
    @ Override
     public   String  toString ()
     {
         return   " "   +   this . name ;
     }
}


src/main/java/edu/odu/cs/cs330/items/ItemFactory.java

src/main/java/edu/odu/cs/cs330/items/ItemFactory.java

package  edu . odu . cs . cs330 . items ;

import  java . util . Scanner ;

/**
 * The Item Creating Wizard
 */
public   class   ItemFactory   {

     /**
     * Name Item Pair 2-tuple(type, model)
     *
     * Simulate a c++ struct by making all attributes public
     */
     private   static   class   ItemPair   {
         public   String  type ;    ///< Name of the item to clone
         public   Item    model ;   ///< Model of the item to clone

         /**
         * Default Constructor - Used as sentinel
         */
         public   ItemPair ()
         {
            type   =   null ;
            model  =   null ;
         }

         /**
         * Non-Default Constructor
         *
         *  @param  type the type of anqq item
         *  @param  item a cloneable item
         */
         public   ItemPair ( String  theType ,   Item  theItem )
         {
            type   =  theType ;
            model  =  theItem ;
         }
     }

     /**
     * Listing of known items
     */
     private   static   ItemPair []  knownItems  =   {
         new   ItemPair ( "Armour" ,   new   Armour ()),
         new   ItemPair ( "Armor" ,   new   Armour ()),
         //new ItemPair("Tool", new Tool()),
         new   ItemPair ( "Food" ,   new   Consumable ()),
         new   ItemPair ( "Potion" ,   new   Consumable ()),
         new   ItemPair ( "Disposable" ,   new   Consumable ()),
     };

     /**
     * Create a Item
     *
     *  @param  type the item to be created
     *
     *  @return  A item with the specified type
     *     or nullptr if no matching item is found
     */
     public   static   Item  createItem ( String  type )
     {
         for   ( ItemPair  pair  :  knownItems )   {
             if   ( pair . type . equals ( type ))   {
                 return  pair . model . clone ();
             }
         }

         return   null ;
     }

     /**
     * Determine whether a given item is known
     *
     *  @param  type the item for which to query
     */
     public   static   boolean  isKnown ( String  type )
     {
         for   ( ItemPair  pair  :  knownItems )   {
             if   ( pair . type . equals ( type ))   {
                 return   true ;
             }
         }

         return   false ;
     }

     /**
     * Create the appropriate Item class--e.g., Tool, Armour or Consumable.
     *
     * How is **inheritance** used?
     */
     public   static   Item  parseItemLine ( Scanner  s )
     {
         String  keyword  =  s . next ();
         Item  item  =  createItem ( keyword );

         // Parse the remainder of the line
         if   ( item  !=   null )   {
            item . read ( s );
         }
         else   {
            s . nextLine ();
         }

         return  item ;
     }

}



src/main/java/edu/odu/cs/cs330/items/ItemStack.java

src/main/java/edu/odu/cs/cs330/items/ItemStack.java

package  edu . odu . cs . cs330 . items ;

/**
 * A Homogeneous--i.e., uniform--stack of Items.
 */
public   class   ItemStack   {
     private   Item  item ;     ///< Item out of which the stack is composed
     private   int  quantity ;   ///< Number of items in the stack

     /**
     * Default to an empty stack composed of Air
     */
     public   ItemStack ()
     {
         this . item      =   null ;
         this . quantity  =   0 ;
     }

     /**
     * Create a stack of type *item*
     *
     *  @param  item Item out of which the stack is composed
     */
     public   ItemStack ( Item  item )
     {
         this . item      =  item . clone ();
         this . quantity  =   1 ;
     }

     /**
     * Copy Constructor - Why is this necessary?
     */
     public   ItemStack ( ItemStack  src )
     {
         this . item      =  src . item . clone ();
         this . quantity  =  src . quantity ;
     }

     /**
     * Retrieve the Item out of which the stack is composed
     */
     public   Item  getItem ()
     {
         return   this . item ;
     }

     /**
     * Retrieve the size of the stack
     */
     public   int  size ()
     {
         return   this . quantity ;
     }

     /**
     * Increase the size of the stack
     *
     *  @param  a number of items to add
     */
     public   void  addItems ( int  a )
     {
         // Add *a* items if stacking is permitted
         // otherwise, silently discard *a* items
         if   ( item . isStackable ())   {
             this . quantity  +=  a ;
         }
     }

     /**
     * Does that Item contained in this stack permit stacking?
     *
     * This can be less formally phrased, is this a stackable ItemStack?
     */
     public   boolean  permitsStacking ()
     {
         return  item . isStackable ();
     }

     /**
     * Consider two stacks to be the same if
     * they contain the same type of Item
     */
    @ Override
     public   boolean  equals ( Object  rhs )
     {
         if   ( ! ( rhs  instanceof   ItemStack ))   {
             return   false ;
         }

         ItemStack  r  =   ( ItemStack ) rhs ;

         return   this . item . equals ( r . item );
     }

     /**
     * Generate a hash code based on item
     */
    @ Override
     public   int  hashCode ()
     {
         return   this . item . hashCode ();
     }

     /**
     * Order stacks based on Item name
     */
     //boolean operator<(ItemStack rhs);

     /**
     * Print the ItemStack directly
     */
    @ Override
     public   String  toString ()
     {
         String  outs  =   this . item . toString ();

         if   ( this . permitsStacking ())   {
            outs  +=   "  Qty: "   +   this . quantity  +   "\n" ;
         }

         return  outs ;
     }
}

src/main/java/edu/odu/cs/cs330/items/package-info.java

src/main/java/edu/odu/cs/cs330/items/package-info.java

/**
 * All item and inventory classes and code are contained in this package.
 */
package  edu . odu . cs . cs330 . items ;

src/main/java/edu/odu/cs/cs330/package-info.java

src/main/java/edu/odu/cs/cs330/package-info.java

/**
 * The set of all CS 330 Code.
 */
package  edu . odu . cs . cs330 ;

src/main/resources/items-01.txt

Tool Pickaxe Diamond 100 1 Fortune 5 LOLNOTAVALIDITEM potato 7 Tool Shovel Gold 20 3 Unbreaking 2 Tool Pickaxe Diamond 100 1 Fortune 5 Potion Speed-II-Potion Spd*2 1 Food Tomato Hunger-10 2 Disposable PotatoCamera ImageQuality-97% 5 Disposable PotatoCamera ImageQuality-97% 5 Tool Axe Stone 10 2 Unbreaking 2 Armour Boots Diamond 100 10 Protection 3 lightning Armor Boots Diamond 100 10 FeatherFalling 4 lightning

src/main/resources/items-02.txt

Tool Pickaxe Diamond 100 1 Fortune 5 LOLNOTAVALIDITEM potato 7 Disposable PotatoCamera ImageQuality-97% 5 Tool Shovel Gold 20 3 Unbreaking 2 Tool Pickaxe Diamond 100 1 Fortune 5 Potion Speed-II-Potion Spd*2 1 Food Tomato Hunger-10 2 Disposable PotatoCamera ImageQuality-97% 5 Tool Axe Stone 10 2 Unbreaking 2 Armour Boots Diamond 100 10 Protection 3 lightning Armor Boots Diamond 100 10 FeatherFalling 4 lightning Armour ChestPlate Diamond 100 10 Defense 9 light Potion Speed-II-Potion Spd*2 1

src/test/java/edu/odu/cs/cs330/items/TestArmour.java

src/test/java/edu/odu/cs/cs330/items/TestArmour.java

package  edu . odu . cs . cs330 . items ;

import  org . junit . FixMethodOrder ;
import  org . junit . runners . MethodSorters ;
import  org . junit . Test ;
import  org . junit . Before ;

import   static  org . junit . Assert . * ;

import   static  org . hamcrest . CoreMatchers . * ;
import  org . hamcrest . core . IsNull ;

import  java . io . StringReader ;
import  java . util . Scanner ;

/**
 * 1 - Does this piece of code perform the operations
 *     it was designed to perform?
 *
 * 2 - Does this piece of code do something it was not
 *     designed to perform?
 *
 * 1 Test per mutator
 */
@ FixMethodOrder ( MethodSorters . NAME_ASCENDING )
public   class   TestArmour
{
    @ Test
     public   void  testDefaultConstructor ()
     {
         Armour  genericArmour  =   new   Armour ();
         Item   genericRef  =   ( Item )  genericArmour ;

        assertFalse ( genericArmour . isStackable ());
        assertFalse ( genericRef . isStackable ());

         // I should really complete this unit test with calls to each of the
         // accessors. However, I will forgo the remaining checks for this test

         // I should really check display() and/or operator<< here. However, I
         // will do that in a separate `testDisplay` function
     }

    @ Test
     public   void  testCopyConstructor ()
     {
         Armour  fancyArmour  =   new   Armour ();

        fancyArmour . setName ( "Fancy" );
        fancyArmour . setDurability ( 9001 );
        fancyArmour . setDefense ( 62 );
        fancyArmour . setMaterial ( "Vibranium" );
        fancyArmour . setModifier ( "ProcrastinationReduction" );
        fancyArmour . setModifierLevel ( 999999 );
        fancyArmour . setElement ( "H20" );

         Armour  copy  =   new   Armour ( fancyArmour );

         // Checks
        assertThat ( copy . getName (),  equalTo ( "Fancy" ));
        assertFalse ( copy . isStackable ());
        assertThat ( copy . getDurability (),  equalTo ( 9001 ));
        assertThat ( copy . getDefense (),  equalTo ( 62 ));
        assertThat ( copy . getMaterial (),  equalTo ( "Vibranium" ));
        assertThat ( copy . getModifier (),  equalTo ( "ProcrastinationReduction" ));
        assertThat ( copy . getModifierLevel (),  equalTo ( 999999 ));
        assertThat ( copy . getElement (),  equalTo ( "H20" ));

         // I should really check display() and/or operator<< here. However, I will
         // do that in a separate `testDisplay` function
     }

    @ Test
     public   void  testClone ()
     {
         Armour  fancyArmour  =   new   Armour ();

        fancyArmour . setName ( "Fancy" );
        fancyArmour . setDurability ( 9001 );
        fancyArmour . setDefense ( 62 );
        fancyArmour . setMaterial ( "Vibranium" );
        fancyArmour . setModifier ( "ProcrastinationReduction" );
        fancyArmour . setModifierLevel ( 999999 );
        fancyArmour . setElement ( "H20" );

         Armour  copy  =   ( Armour )  fancyArmour . clone ();

         // Checks
        assertThat ( copy . getName (),  equalTo ( "Fancy" ));
        assertFalse ( copy . isStackable ());
        assertThat ( copy . getDurability (),  equalTo ( 9001 ));
        assertThat ( copy . getDefense (),  equalTo ( 62 ));
        assertThat ( copy . getMaterial (),  equalTo ( "Vibranium" ));
        assertThat ( copy . getModifier (),  equalTo ( "ProcrastinationReduction" ));
        assertThat ( copy . getModifierLevel (),  equalTo ( 999999 ));
        assertThat ( copy . getElement (),  equalTo ( "H20" ));

         // I should really check display() and/or operator<< here. However, I will
         // do that in a separate `testDisplay` function
     }

    @ Test
     public   void  testToString ()
     {
         Armour  fancyArmour  =   new   Armour ();

        fancyArmour . setName ( "Fancy" );
        fancyArmour . setDurability ( 9001 );
        fancyArmour . setDefense ( 62 );
        fancyArmour . setMaterial ( "Vibranium" );
        fancyArmour . setModifier ( "ProcrastinationReduction" );
        fancyArmour . setModifierLevel ( 999999 );
        fancyArmour . setElement ( "H20" );

         String  expected  =   "  Nme: Fancy\n"
                         +   "  Dur: 9001\n"
                         +   "  Def: 62\n"
                         +   "  Mtl: Vibranium\n"
                         +   "  Mdr: ProcrastinationReduction (Lvl 999999)\n"
                         +   "  Emt: H20\n" ;

        assertThat ( fancyArmour . toString (),  equalTo ( expected ));
     }

    @ Test
     public   void  testRead ()
     {
         Armour  fancyArmour  =   new   Armour ();

         String  inputStr  =   "Fancy Vibranium 9001 62 ProcrastinationReduction 999999 H20" ;
         Scanner  ins  =   new   Scanner ( new   StringReader ( inputStr ));

        fancyArmour . read ( ins );

         // Checks
        assertThat ( fancyArmour . getName (),  equalTo ( "Fancy" ));
        assertFalse ( fancyArmour . isStackable ());
        assertThat ( fancyArmour . getDurability (),  equalTo ( 9001 ));
        assertThat ( fancyArmour . getDefense (),  equalTo ( 62 ));
        assertThat ( fancyArmour . getMaterial (),  equalTo ( "Vibranium" ));
        assertThat ( fancyArmour . getModifier (),  equalTo ( "ProcrastinationReduction" ));
        assertThat ( fancyArmour . getModifierLevel (),  equalTo ( 999999 ));
        assertThat ( fancyArmour . getElement (),  equalTo ( "H20" ));
     }
}

src/test/java/edu/odu/cs/cs330/items/TestConsumable.java

src/test/java/edu/odu/cs/cs330/items/TestConsumable.java

package  edu . odu . cs . cs330 . items ;

import  org . junit . FixMethodOrder ;
import  org . junit . runners . MethodSorters ;
import  org . junit . Test ;
import  org . junit . Before ;

import   static  org . junit . Assert . * ;

import   static  org . hamcrest . CoreMatchers . * ;
import  org . hamcrest . core . IsNull ;

import  java . io . StringReader ;
import  java . util . Scanner ;

/**
 * 1 - Does this piece of code perform the operations
 *     it was designed to perform?
 *
 * 2 - Does this piece of code do something it was not
 *     designed to perform?
 *
 * 1 Test per mutator
 */
@ FixMethodOrder ( MethodSorters . NAME_ASCENDING )
public   class   TestConsumable
{
    @ Test
     public   void  testDefaultConstructor ()
     {
         Consumable  imagination  =   new   Consumable ();

         Item   genericRef  =   ( Item )  imagination ;

        assertTrue ( imagination . isStackable ());
        assertTrue ( genericRef . isStackable ());

         // I should really complete this unit test with calls to each of the
         // accessors. However, I will forgo the remaining checks for this test

         // I should really check display() and/or operator<< here. However, I will
         // do that in a separate `testDisplay` function
     }

    @ Test
     public   void  testCopyConstructor ()
     {
         Consumable  tea  =   new   Consumable ();
        tea . setName ( "Green Tea" );
        tea . setEffect ( "Wake Up" );
        tea . setNumberOfUses ( 10 );

         Consumable  moreTea  =   new   Consumable ( tea );

        assertThat ( moreTea . isStackable (),  is ( true ));
        assertThat ( moreTea . getName (),  equalTo ( "Green Tea" ));
        assertThat ( moreTea . getEffect (),  equalTo ( "Wake Up" ));
        assertThat ( moreTea . getNumberOfUses (),  is ( 10 ));

         // I should really complete this unit test with calls to each of the
         // accessors. However, I will forgo the remaining checks for this test

         // I should really check display() and/or operator<< here. However, I
         // will do that in a separate `testDisplay` function
     }

    @ Test
     public   void  testClone ()
     {
         Consumable  tea  =   new   Consumable ();
        tea . setName ( "Green Tea" );
        tea . setEffect ( "Wake Up" );
        tea . setNumberOfUses ( 10 );

         Consumable  moreTea  =   ( Consumable )  tea . clone ();

        assertThat ( moreTea . isStackable (),  is ( true ));
        assertThat ( moreTea . getName (),  equalTo ( "Green Tea" ));
        assertThat ( moreTea . getEffect (),  equalTo ( "Wake Up" ));
        assertThat ( moreTea . getNumberOfUses (),  is ( 10 ));

         // I should really complete this unit test with calls to each of the
         // accessors. However, I will forgo the remaining checks for this test

         // I should really check display() and/or operator<< here. However, I
         // will do that in a separate `testDisplay` function
     }

    @ Test
     public   void  testToString ()
     {
         Consumable  tea  =   new   Consumable ();
        tea . setName ( "Green Tea" );
        tea . setEffect ( "Wake Up" );
        tea . setNumberOfUses ( 10 );

         String  expected  =   "  Nme: Green Tea\n"
                         +   "  Eft: Wake Up\n"
                         +   "  Use: 10\n" ;

        assertThat ( tea . toString (),  equalTo ( expected ));
     }

    @ Test
     public   void  testRead ()
     {
         Consumable  tea  =   new   Consumable ();

         String  inputStr  =   "Green-Tea Wake-Up 5" ;
         Scanner  ins  =   new   Scanner ( new   StringReader ( inputStr ));

        tea . read ( ins );

        assertTrue ( tea . isStackable ());
        assertThat ( tea . getName (),  equalTo ( "Green-Tea" ));
        assertThat ( tea . getEffect (),  equalTo ( "Wake-Up" ));
        assertThat ( tea . getNumberOfUses (),  is ( 5 ));
     }
}

gradle/wrapper/gradle-wrapper.jar

META-INF/MANIFEST.MF

Manifest-Version: 1.0 Implementation-Title: Gradle Implementation-Version: 3.1

org/gradle/wrapper/Download$1.class

package org.gradle.wrapper;
synchronized class Download$1 {
}

org/gradle/wrapper/Download$SystemPropertiesProxyAuthenticator.class

package org.gradle.wrapper;
synchronized class Download$SystemPropertiesProxyAuthenticator extends java.net.Authenticator {
    private void Download$SystemPropertiesProxyAuthenticator();
    protected java.net.PasswordAuthentication getPasswordAuthentication();
}

org/gradle/wrapper/IDownload.class

package org.gradle.wrapper;
public abstract interface IDownload {
    public abstract void download(java.net.URI, java.io.File) throws Exception;
}

org/gradle/wrapper/GradleUserHomeLookup.class

package org.gradle.wrapper;
public synchronized class GradleUserHomeLookup {
    public static final String DEFAULT_GRADLE_USER_HOME;
    public static final String GRADLE_USER_HOME_PROPERTY_KEY = gradle.user.home;
    public static final String GRADLE_USER_HOME_ENV_KEY = GRADLE_USER_HOME;
    public void GradleUserHomeLookup();
    public static java.io.File gradleUserHome();
    static void <clinit>();
}

org/gradle/wrapper/ExclusiveFileAccessManager.class

package org.gradle.wrapper;
public synchronized class ExclusiveFileAccessManager {
    public static final String LOCK_FILE_SUFFIX = .lck;
    private final int timeoutMs;
    private final int pollIntervalMs;
    public void ExclusiveFileAccessManager(int, int);
    public Object access(java.io.File, java.util.concurrent.Callable) throws Exception;
    private static void maybeCloseQuietly(java.io.Closeable);
}

org/gradle/wrapper/WrapperConfiguration.class

package org.gradle.wrapper;
public synchronized class WrapperConfiguration {
    private java.net.URI distribution;
    private String distributionBase;
    private String distributionPath;
    private String distributionSha256Sum;
    private String zipBase;
    private String zipPath;
    public void WrapperConfiguration();
    public java.net.URI getDistribution();
    public void setDistribution(java.net.URI);
    public String getDistributionBase();
    public void setDistributionBase(String);
    public String getDistributionPath();
    public void setDistributionPath(String);
    public String getDistributionSha256Sum();
    public void setDistributionSha256Sum(String);
    public String getZipBase();
    public void setZipBase(String);
    public String getZipPath();
    public void setZipPath(String);
}

org/gradle/wrapper/SystemPropertiesHandler.class

package org.gradle.wrapper;
public synchronized class SystemPropertiesHandler {
    static final String SYSTEM_PROP_PREFIX = systemProp.;
    public void SystemPropertiesHandler();
    public static java.util.Map getSystemProperties(java.io.File);
}

org/gradle/wrapper/Logger.class

package org.gradle.wrapper;
public synchronized class Logger implements Appendable {
    private final boolean quiet;
    public void Logger(boolean);
    public void log(String);
    public Appendable append(CharSequence);
    public Appendable append(CharSequence, int, int);
    public Appendable append(char);
}

org/gradle/wrapper/PathAssembler.class

package org.gradle.wrapper;
public synchronized class PathAssembler {
    public static final String GRADLE_USER_HOME_STRING = GRADLE_USER_HOME;
    public static final String PROJECT_STRING = PROJECT;
    private java.io.File gradleUserHome;
    public void PathAssembler();
    public void PathAssembler(java.io.File);
    public PathAssembler$LocalDistribution getDistribution(WrapperConfiguration);
    private String rootDirName(String, WrapperConfiguration);
    private String getHash(String);
    private String removeExtension(String);
    private String getDistName(java.net.URI);
    private java.io.File getBaseDir(String);
}

org/gradle/wrapper/Install.class

package org.gradle.wrapper;
public synchronized class Install {
    public static final String DEFAULT_DISTRIBUTION_PATH = wrapper/dists;
    private final Logger logger;
    private final IDownload download;
    private final PathAssembler pathAssembler;
    private final ExclusiveFileAccessManager exclusiveFileAccessManager;
    public void Install(Logger, IDownload, PathAssembler);
    public java.io.File createDist(WrapperConfiguration) throws Exception;
    private String calculateSha256Sum(java.io.File) throws Exception;
    private java.io.File getAndVerifyDistributionRoot(java.io.File, String) throws Exception;
    private void verifyDownloadChecksum(String, java.io.File, String) throws Exception;
    private java.util.List listDirs(java.io.File);
    private void setExecutablePermissions(java.io.File);
    private boolean isWindows();
    private boolean deleteDir(java.io.File);
    private void unzip(java.io.File, java.io.File) throws java.io.IOException;
    private void copyInputStream(java.io.InputStream, java.io.OutputStream) throws java.io.IOException;
}

org/gradle/wrapper/BootstrapMainStarter.class

package org.gradle.wrapper;
public synchronized class BootstrapMainStarter {
    public void BootstrapMainStarter();
    public void start(String[], java.io.File) throws Exception;
    private java.io.File findLauncherJar(java.io.File);
}

org/gradle/wrapper/WrapperExecutor.class

package org.gradle.wrapper;
public synchronized class WrapperExecutor {
    public static final String DISTRIBUTION_URL_PROPERTY = distributionUrl;
    public static final String DISTRIBUTION_BASE_PROPERTY = distributionBase;
    public static final String DISTRIBUTION_PATH_PROPERTY = distributionPath;
    public static final String DISTRIBUTION_SHA_256_SUM = distributionSha256Sum;
    public static final String ZIP_STORE_BASE_PROPERTY = zipStoreBase;
    public static final String ZIP_STORE_PATH_PROPERTY = zipStorePath;
    private final java.util.Properties properties;
    private final java.io.File propertiesFile;
    private final WrapperConfiguration config;
    public static WrapperExecutor forProjectDirectory(java.io.File);
    public static WrapperExecutor forWrapperPropertiesFile(java.io.File);
    void WrapperExecutor(java.io.File, java.util.Properties);
    private java.net.URI prepareDistributionUri() throws java.net.URISyntaxException;
    private java.net.URI readDistroUrl() throws java.net.URISyntaxException;
    private static void loadProperties(java.io.File, java.util.Properties) throws java.io.IOException;
    public java.net.URI getDistribution();
    public WrapperConfiguration getConfiguration();
    public void execute(String[], Install, BootstrapMainStarter) throws Exception;
    private String getProperty(String);
    private String getProperty(String, String);
    private String getProperty(String, String, boolean);
    private String reportMissingProperty(String);
}

org/gradle/wrapper/GradleWrapperMain.class

package org.gradle.wrapper;
public synchronized class GradleWrapperMain {
    public static final String GRADLE_USER_HOME_OPTION = g;
    public static final String GRADLE_USER_HOME_DETAILED_OPTION = gradle-user-home;
    public static final String GRADLE_QUIET_OPTION = q;
    public static final String GRADLE_QUIET_DETAILED_OPTION = quiet;
    public void GradleWrapperMain();
    public static void main(String[]) throws Exception;
    private static void addSystemProperties(java.io.File, java.io.File);
    private static java.io.File rootDir(java.io.File);
    private static java.io.File wrapperProperties(java.io.File);
    private static java.io.File wrapperJar();
    static String wrapperVersion();
    private static java.io.File gradleUserHome(org.gradle.cli.ParsedCommandLine);
    private static Logger logger(org.gradle.cli.ParsedCommandLine);
}

org/gradle/wrapper/Install$1.class

package org.gradle.wrapper;
synchronized class Install$1 implements java.util.concurrent.Callable {
    void Install$1(Install, java.io.File, java.io.File, java.net.URI, WrapperConfiguration, String);
    public java.io.File call() throws Exception;
}

org/gradle/wrapper/PathAssembler$LocalDistribution.class

package org.gradle.wrapper;
public synchronized class PathAssembler$LocalDistribution {
    private final java.io.File distZip;
    private final java.io.File distDir;
    public void PathAssembler$LocalDistribution(PathAssembler, java.io.File, java.io.File);
    public java.io.File getDistributionDir();
    public java.io.File getZipFile();
}

org/gradle/wrapper/Download.class

package org.gradle.wrapper;
public synchronized class Download implements IDownload {
    private static final int PROGRESS_CHUNK = 20000;
    private static final int BUFFER_SIZE = 10000;
    private final Logger logger;
    private final String applicationName;
    private final String applicationVersion;
    public void Download(Logger, String, String);
    private void configureProxyAuthentication();
    public void download(java.net.URI, java.io.File) throws Exception;
    private void downloadInternal(java.net.URI, java.io.File) throws Exception;
    private String calculateUserAgent();
}

gradle-wrapper-classpath.properties

projects=gradle-cli runtime=

build-receipt.properties

buildTimestamp=20160919105353+0000 commitId=13f38ba699afd86d7cdc4ed8fd7dd3960c0b1f97 isSnapshot=false versionBase=3.1 versionNumber=3.1

org/gradle/cli/AbstractCommandLineConverter.class

package org.gradle.cli;
public abstract synchronized class AbstractCommandLineConverter implements CommandLineConverter {
    public void AbstractCommandLineConverter();
    public Object convert(Iterable, Object) throws CommandLineArgumentException;
}

org/gradle/cli/CommandLineParser$1.class

package org.gradle.cli;
synchronized class CommandLineParser$1 {
}

org/gradle/cli/CommandLineParser$MissingOptionArgState.class

package org.gradle.cli;
synchronized class CommandLineParser$MissingOptionArgState extends CommandLineParser$ParserState {
    private final CommandLineParser$OptionParserState option;
    private void CommandLineParser$MissingOptionArgState(CommandLineParser$OptionParserState);
    public boolean maybeStartOption(String);
    public CommandLineParser$OptionParserState onStartOption(String, String);
    public CommandLineParser$ParserState onNonOption(String);
    public void onCommandLineEnd();
}

org/gradle/cli/CommandLineParser$OptionStringComparator.class

package org.gradle.cli;
final synchronized class CommandLineParser$OptionStringComparator implements java.util.Comparator {
    private void CommandLineParser$OptionStringComparator();
    public int compare(String, String);
}

org/gradle/cli/CommandLineArgumentException.class

package org.gradle.cli;
public synchronized class CommandLineArgumentException extends RuntimeException {
    public void CommandLineArgumentException(String);
    public void CommandLineArgumentException(String, Throwable);
}

org/gradle/cli/CommandLineParser$KnownOptionParserState.class

package org.gradle.cli;
synchronized class CommandLineParser$KnownOptionParserState extends CommandLineParser$OptionParserState {
    private final CommandLineParser$OptionString optionString;
    private final CommandLineOption option;
    private final ParsedCommandLine commandLine;
    private final CommandLineParser$ParserState state;
    private final java.util.List values;
    private void CommandLineParser$KnownOptionParserState(CommandLineParser, CommandLineParser$OptionString, CommandLineOption, ParsedCommandLine, CommandLineParser$ParserState);
    public CommandLineParser$ParserState onArgument(String);
    public CommandLineParser$ParserState onStartNextArg();
    public boolean getHasArgument();
    public CommandLineParser$ParserState onComplete();
}

org/gradle/cli/CommandLineParser$OptionComparator.class

package org.gradle.cli;
final synchronized class CommandLineParser$OptionComparator implements java.util.Comparator {
    private void CommandLineParser$OptionComparator();
    public int compare(CommandLineOption, CommandLineOption);
}

org/gradle/cli/CommandLineParser$UnknownOptionParserState.class

package org.gradle.cli;
synchronized class CommandLineParser$UnknownOptionParserState extends CommandLineParser$OptionParserState {
    private final CommandLineParser$ParserState state;
    private final String arg;
    private final ParsedCommandLine commandLine;
    private void CommandLineParser$UnknownOptionParserState(String, ParsedCommandLine, CommandLineParser$ParserState);
    public boolean getHasArgument();
    public CommandLineParser$ParserState onStartNextArg();
    public CommandLineParser$ParserState onArgument(String);
    public CommandLineParser$ParserState onComplete();
}

org/gradle/cli/CommandLineOption.class

package org.gradle.cli;
public synchronized class CommandLineOption {
    private final java.util.Set options;
    private Class argumentType;
    private String description;
    private String deprecationWarning;
    private boolean incubating;
    private final java.util.Set groupWith;
    public void CommandLineOption(Iterable);
    public java.util.Set getOptions();
    public CommandLineOption hasArgument(Class);
    public CommandLineOption hasArgument();
    public CommandLineOption hasArguments();
    public String getDescription();
    public CommandLineOption hasDescription(String);
    public boolean getAllowsArguments();
    public boolean getAllowsMultipleArguments();
    public CommandLineOption deprecated(String);
    public CommandLineOption incubating();
    public String getDeprecationWarning();
    java.util.Set getGroupWith();
    void groupWith(java.util.Set);
}

org/gradle/cli/CommandLineParser$OptionParserState.class

package org.gradle.cli;
abstract synchronized class CommandLineParser$OptionParserState {
    private void CommandLineParser$OptionParserState();
    public abstract CommandLineParser$ParserState onStartNextArg();
    public abstract CommandLineParser$ParserState onArgument(String);
    public abstract boolean getHasArgument();
    public abstract CommandLineParser$ParserState onComplete();
}

org/gradle/cli/ParsedCommandLine.class

package org.gradle.cli;
public synchronized class ParsedCommandLine {
    private final java.util.Map optionsByString;
    private final java.util.Set presentOptions;
    private final java.util.Set removedOptions;
    private final java.util.List extraArguments;
    void ParsedCommandLine(Iterable);
    public String toString();
    private String quoteAndJoin(Iterable);
    public boolean hasOption(String);
    public boolean hadOptionRemoved(String);
    public boolean hasAnyOption(java.util.Collection);
    public ParsedCommandLineOption option(String);
    public java.util.List getExtraArguments();
    void addExtraValue(String);
    ParsedCommandLineOption addOption(String, CommandLineOption);
    void removeOption(CommandLineOption);
}

org/gradle/cli/ProjectPropertiesCommandLineConverter.class

package org.gradle.cli;
public synchronized class ProjectPropertiesCommandLineConverter extends AbstractPropertiesCommandLineConverter {
    public void ProjectPropertiesCommandLineConverter();
    protected String getPropertyOption();
    protected String getPropertyOptionDetailed();
    protected String getPropertyOptionDescription();
}

org/gradle/cli/CommandLineParser$CaseInsensitiveStringComparator.class

package org.gradle.cli;
final synchronized class CommandLineParser$CaseInsensitiveStringComparator implements java.util.Comparator {
    private void CommandLineParser$CaseInsensitiveStringComparator();
    public int compare(String, String);
}

org/gradle/cli/CommandLineParser.class

package org.gradle.cli;
public synchronized class CommandLineParser {
    private static final java.util.regex.Pattern OPTION_NAME_PATTERN;
    private java.util.Map optionsByString;
    private boolean allowMixedOptions;
    private boolean allowUnknownOptions;
    private final java.io.PrintWriter deprecationPrinter;
    public void CommandLineParser();
    public void CommandLineParser(java.io.Writer);
    public transient ParsedCommandLine parse(String[]) throws CommandLineArgumentException;
    public ParsedCommandLine parse(Iterable) throws CommandLineArgumentException;
    public CommandLineParser allowMixedSubcommandsAndOptions();
    public CommandLineParser allowUnknownOptions();
    public transient CommandLineParser allowOneOf(String[]);
    public void printUsage(Appendable);
    private static String join(java.util.Collection, String);
    public transient CommandLineOption option(String[]);
    static void <clinit>();
}

org/gradle/cli/CommandLineParser$AfterOptions.class

package org.gradle.cli;
synchronized class CommandLineParser$AfterOptions extends CommandLineParser$ParserState {
    private final ParsedCommandLine commandLine;
    private void CommandLineParser$AfterOptions(ParsedCommandLine);
    public boolean maybeStartOption(String);
    public CommandLineParser$OptionParserState onStartOption(String, String);
    public CommandLineParser$ParserState onNonOption(String);
}

org/gradle/cli/CommandLineParser$OptionString.class

package org.gradle.cli;
synchronized class CommandLineParser$OptionString {
    private final String arg;
    private final String option;
    private void CommandLineParser$OptionString(String, String);
    public String getDisplayName();
    public String toString();
}

org/gradle/cli/AbstractPropertiesCommandLineConverter.class

package org.gradle.cli;
public abstract synchronized class AbstractPropertiesCommandLineConverter extends AbstractCommandLineConverter {
    public void AbstractPropertiesCommandLineConverter();
    protected abstract String getPropertyOption();
    protected abstract String getPropertyOptionDetailed();
    protected abstract String getPropertyOptionDescription();
    public void configure(CommandLineParser);
    public java.util.Map convert(ParsedCommandLine, java.util.Map) throws CommandLineArgumentException;
}

org/gradle/cli/ParsedCommandLineOption.class

package org.gradle.cli;
public synchronized class ParsedCommandLineOption {
    private final java.util.List values;
    public void ParsedCommandLineOption();
    public String getValue();
    public java.util.List getValues();
    public void addArgument(String);
    public boolean hasValue();
}

org/gradle/cli/CommandLineParser$OptionAwareParserState.class

package org.gradle.cli;
abstract synchronized class CommandLineParser$OptionAwareParserState extends CommandLineParser$ParserState {
    protected final ParsedCommandLine commandLine;
    protected void CommandLineParser$OptionAwareParserState(CommandLineParser, ParsedCommandLine);
    public boolean maybeStartOption(String);
    public CommandLineParser$ParserState onNonOption(String);
}

org/gradle/cli/CommandLineConverter.class

package org.gradle.cli;
public abstract interface CommandLineConverter {
    public abstract Object convert(Iterable, Object) throws CommandLineArgumentException;
    public abstract Object convert(ParsedCommandLine, Object) throws CommandLineArgumentException;
    public abstract void configure(CommandLineParser);
}

org/gradle/cli/CommandLineParser$BeforeFirstSubCommand.class

package org.gradle.cli;
synchronized class CommandLineParser$BeforeFirstSubCommand extends CommandLineParser$OptionAwareParserState {
    private void CommandLineParser$BeforeFirstSubCommand(CommandLineParser, ParsedCommandLine);
    public CommandLineParser$OptionParserState onStartOption(String, String);
}

org/gradle/cli/SystemPropertiesCommandLineConverter.class

package org.gradle.cli;
public synchronized class SystemPropertiesCommandLineConverter extends AbstractPropertiesCommandLineConverter {
    public void SystemPropertiesCommandLineConverter();
    protected String getPropertyOption();
    protected String getPropertyOptionDetailed();
    protected String getPropertyOptionDescription();
}

org/gradle/cli/CommandLineParser$ParserState.class

package org.gradle.cli;
abstract synchronized class CommandLineParser$ParserState {
    private void CommandLineParser$ParserState();
    public abstract boolean maybeStartOption(String);
    boolean isOption(String);
    public abstract CommandLineParser$OptionParserState onStartOption(String, String);
    public abstract CommandLineParser$ParserState onNonOption(String);
    public void onCommandLineEnd();
}

org/gradle/cli/CommandLineParser$AfterFirstSubCommand.class

package org.gradle.cli;
synchronized class CommandLineParser$AfterFirstSubCommand extends CommandLineParser$OptionAwareParserState {
    private void CommandLineParser$AfterFirstSubCommand(CommandLineParser, ParsedCommandLine);
    public CommandLineParser$OptionParserState onStartOption(String, String);
}

gradle-cli-classpath.properties

projects= runtime=

gradle/wrapper/gradle-wrapper.properties

#Wed Feb 22 15:34:37 EST 2017 distributionBase=GRADLE_USER_HOME distributionPath=wrapper/dists zipStoreBase=GRADLE_USER_HOME zipStorePath=wrapper/dists distributionUrl=https\://services.gradle.org/distributions/gradle-5.6.1-all.zip

config/checkstyle/checkstyle.xml

build.gradle

buildscript { repositories { jcenter() } } plugins { id "java" id "application" id "eclipse" id "checkstyle" id "com.github.spotbugs" version "2.0.0" id "project-report" id "jacoco" id "pmd" } sourceCompatibility = 1.8 targetCompatibility = 1.8 repositories { jcenter() } dependencies { testCompile "junit:junit:4.12" testCompile "org.hamcrest:hamcrest-library:1.3" } jar { baseName = "Storage" manifest { attributes( "Main-Class": "edu.odu.cs.cs330.Storage" ) } } application { mainClassName = "edu.odu.cs.cs330.Storage" } run { main = "edu.odu.cs.cs330.Storage" args = ["src/main/resources/items-01.txt"] } test { reports { html.enabled = true } ignoreFailures = true testLogging { events "passed", "skipped", "failed", "standardOut", "standardError" } } javadoc { failOnError false } //------------------------------------------------------------------------------ // Analysis Tools //------------------------------------------------------------------------------ // SpotBugs spotbugsMain { ignoreFailures = true effort = "max" reportLevel = "medium" reports { xml.enabled = false html.enabled = true } } spotbugsTest.enabled = false // End SpotBugs config jacoco { toolVersion = "0.8.5" } jacocoTestReport { reports { html.enabled true xml.enabled true csv.enabled true } } // Check Style Config checkstyle { ignoreFailures = true showViolations = false configFile = "checkstyle.xml" as File } tasks.withType(Checkstyle) { reports { html.destination project.file("build/reports/checkstyle/main.html") } } checkstyleTest.enabled = false // End Checkstyle config pmd { ignoreFailures = true ruleSets = [ "category/java/bestpractices.xml", "category/java/codestyle.xml", "category/java/design.xml", "category/java/errorprone.xml", "category/java/performance.xml" ] }

gradle.properties

org.gradle.daemon=false