Question

1. A bounded string list has an upper limit on its size, which is set when the list is created. The size limit specifies the maximum number of strings that can be stored in a bounded string list. String lists are mutable and allow random accesses to their elements using indexes. The list operations include

BoundedStringList(int sizeLimit);

void insert(String newString, int index);

void delete(int index);

String get(int index);

The constructor creates an empty list with a maximum size of sizeLimit. The method insert inserts a new element newString at the position index in the list and shifts the original string at index (and all the subsequent strings) forward by one position. The method delete removes the string at the position index in the list and shifts all the subsequent strings backward by one position. The method get returns the string at the position index in the list.

Provide a specification of BoundedStringList, including additional operations as needed for adequacy. Implement your specification. Give the rep invariant and abstraction function of your implementation and implement repOk and toString accordingly.

Hint: In your specification, consider edge cases such as a full list, index out of range, etc.

You may need to define new exception types for the specification and the implementation.

2. Discuss how the implementation of the bounded string list described in Question 1 should deal with the methods equals and clone. Implement these operations based on your discussion.

Note: You are required to add the implementations of clone and equals in your source code solution for Question 1.

3. Explain the concept of benevolent side effects. Give an example that illustrates the concept. To receive credits for this question, do not use the rat/rational example given in the textbook.

Note: You are not required to provide a comprehensive example. It is good to use one that can just illustrate the concept clear enough.

4. We propose a new data type Project with operations such as changing the project’s name and returning the project’s budget. Should Project be a mutable or immutable type? Justify your decision.

Answer 1

Implementation in Java:

class LengthException extends Throwable //custom exception to handle deletion/insertion errors and edge cases
{
   LengthException(String Message)
   {
       super(Message);
   }
}

class BoundedStringList implements Cloneable
{
   String[] list;
   int sizeLimit;
   int flag=0, count=0; //flag used to mark deletions, count for length check
  
   BoundedStringList(int sizeLimit) //constructor
   {
       this.sizeLimit = sizeLimit;
       list= new String [sizeLimit];
   }
  
   void insert(String newString, int index) throws LengthException
   {
       checkLength(-10); //-10 is code for insertion, in case error is required for insertion
       for(int i=list.length-1; i > index; i--)
       {
           list[i] = list[i-1];
       }
       list[index] = newString;
       count = count+1; //to check number of insertions done
   }
  
   void delete(int index) throws LengthException
   {
       flag=1; //marking flag as active since deletion is required.
       checkLength(index);
       for(int i = index; i < list.length -1; i++)
       {
           list[i] = list[i + 1];
       }
       flag=0; //setting flag back to 0 since deletion is complete
   }
  
   String get(int index)
   {
       return list[index];
   }
  
   void show()
   {
       System.out.println(" " + Arrays.toString(list)); //toString method usage
   }
  
   void checkLength(int index) throws LengthException
   {
       if(count == sizeLimit && index==-10)
       {
           throw new LengthException("Cannot insert more elements in list.");
       }
      
       if(flag==1)
       {
           int check = 0;
           for (int i = 0; i < list.length; i ++)
           if (list[i] != null)
               check ++;
           if(check==0) //check if list is empty
               throw new LengthException("Cannot delete from list, no elements present");
       }
      
       if(flag==1 && list[index]==null) //check if list is not empty but has null at the index mentioned for deletion
       {
           throw new LengthException("Cannot delete from list, no element at index");
       }
   }
  
   public Object clone() throws CloneNotSupportedException //clone override
   {
       return super.clone();
   }
  
}

public class HelloWorld
{
   public static void main(String [] args) throws LengthException, CloneNotSupportedException
   {
       BoundedStringList ls = new BoundedStringList(5);
       ls.insert("Hello", 1);
       ls.insert("World", 2);
       ls.insert("How", 2);
       ls.insert("Are", 2);
       ls.insert("You", 2);
       //ls.insert("Doing", 2);//throws custom exception, since list is full now.
       ls.show();
       ls.delete(2);
       ls.show();
       System.out.println(ls.get(1));
       ls.delete(1);
       ls.delete(1); //throws custom exception : Cannot delete from list, no elements present
       BoundedStringList cloned_ls = (BoundedStringList) ls.clone();
       cloned_ls.show(); //using clone
   }
}

Equals and Clone: Equals method cannot be overriden for arrays in a direct manner, since arrays are rimitive datatypes, hence we will have to use the pre built Arrays.equals(arr1[], arr2[]), when it comes to comparing two arrays. Hence implemtation will not be possible.

Clone can be used s expected, and impleemtd in the code above, to clone the object that we desire and make a similar replica of the same.

Benevolent side effects : The user of an abstraction will be unable to see a side effect if that particular side effect doesnt affect the abstract value of a mutable object. Since they are more private/internal, they do not affect the abstraction or destroy it in any manner.

Example: reduction is a benevolent side effect. The same can be exemplified with the help of rational numbers/division/GCD and so forth, or any other reduction process.