CIS501 Assignments 6 and 7 (Project 2)

You will design and implement a "file-explorer app" that might be used on a tablet or PC to access a file system saved in "cloud storage".

Here is some background: When you use a remote server to store your file system (it's a collection of nested folders and text files), the server actually encodes your file system as a single sequential text file with embedded XML tags. When you use an app on a tablet to login to the server and retrieve your file system, the server locates the text file, reads and decodes some small part of it, and returns to your app only the top-level folder of your file system. (The server won't decode and return the entire file system --- if you have, say, 10GB of data stored, it wastes time and bandwidth to decode and load everything, especially because you won't be looking at everything!)

As you open the top folder and examine its contents and then open other, nested folders, the app decodes and loads these folders as needed. You use your app make changes to your local copy of the file system, the one on your tablet, and when you logout, the app copies the local copy of your filesystem back to the server.

You will design and implement a system that works in this manner.

XML-like format for encoded, stored file system

XML is just "bracket language" --- HTML is an example of an XML language. We use a simple version here. Say we have this example file system, where

the Root folder holds files a.txt, b.txt, and folders F and G

folder F holds folder H and file c.txt

folder H holds file a.txt.

folder G is empty

<folder "">
<file "a.txt">
... lines of a.txt go here...
</file>
<file "b.txt">
... lines of b.txt go here...
</file>
<flink "F">
<flink "G">
</folder>
<folder "F">
<flink "H">
<file "c.txt">
... lines of c.txt go here...
</file>
</folder>
<folder "G">
</folder>
<folder "F/H">
<file "a.txt>"
... lines of a.txt go here...
</file>
</folder>

The syntax of the XML encoding should be easy to figure out, but here's a precise regular-expression definition of the format:

EncodedFileSystem = EncodedFolder+
EncodedFolder = <folder "FolderPath"> EncodedEntry* </folder>
EncodedEntry =  EncodedTextFile  ||  EncodedFolderLink
EncodedTextFile = <file "Name"> TextLine* </file>
EncodedFolderLink = <flink "Name">
FolderPath = ε  ||  Name(/Name)*
Name = sequence of letters, numerals, and periods
TextLine = string ended by "\r\n"

Part of your job is to write a subassembly that reads the text file from disk, one folder's-worth at a time, and rebuilds it into its tiered (tree) form, like we studied in class. Details are below.

Use cases

Here is a picture of how the app might be used. Here is the explanation:

• When the system starts, the user is presented with a ControlPanel (Form), which lets the user construct windows and terminate the entire system. The ControlPanel shows these two operations (buttons):
  1. Open: when this is selected, a new DirectoryForm is constructed and shown. The DirectoryForm shows the contents of the top-level ("Root") folder of the file system. (The folder is loaded from the XML-coded text file, filesIn.txt. Read the section at the end of the Assignment about this.)
  2. CloseAll: when this is selected, all the opened Forms close, and the current contents of the file system are converted into an XML-coded file and stored on disk as the file, filesOut.txt.

• Within a DirectoryForm, a user views the contents of a folder and can open its individual entries. (You can use a ListBox to show the contents.) The DirectoryForm has (at least) these operations (buttons):
  1. Open: the selected item is opened:

     -- If it's a text file, a new EditForm (Form) is constructed and shows the text lines in the file. The user can edit the contents; see below.

     -- If the selected item is a folder, the contents of the DirectoryForm are refreshed to show the contents of the selected, now opened, folder.

  2. NewFile: a dialog asks for a name, and an empty text file with the submitted name is added to the contents of the currently open folder.
  3. NewFolder: a dialog asks for a name, and an empty folder with the submitted name is added to the contents of the currently open folder.
  4. DeleteFile: the selected file in the DirectoryForm is removed from the file system.
  (There might be other useful operations, but we have enough already, so we stop here!)

• Within an EditForm, a text file's contents can be viewed and changed. (You can model the Form with a TextBox to view/change the file's contents.) The window has these two operations (buttons):
  1. Save: the edited text is written to the file system.
  2. Exit: the EditForm disappears.

• For certain, you must remember which Forms must be gracefully closed when the user presses the CloseAll button on the Control Panel. (I have included a small demo VS solution that should give you an idea about how to construct and close Forms.) Perhaps you use a technique with delegates or Observers or perhaps you do this like my demo VS solution. It's up to you.
• As you see fit, use Observers to remember which DirectoryForms must be repainted when the user creates or deletes a file. (Remember --- it is possible to have two distinct DirectoryForms that appear and show the contents of one and the same Folder. So, if one directory form deletes a file from a folder, then the other form must repaint to show that the file has disappeared.)

NO REMOTE PROXIES: Don't implement the Remote Proxy design pattern. It is true that a remote proxy should be added for deployment on a tablet that connects to cloud storage, but that step can be implemented later. We have enough to do already.

NO NEED FOR THREADS AND LOCKS: we won't accommodate multiple users --- so, no multiple threads nor locks are needed --- this Assignment is about a single-user file system and not about a file system that is shared by multiple users.

What you must do

• Study the use-cases above, study my use-case diagram, write down some use-case realizations, and draw an object diagram. Think about which objects do which activities. Remember the required design patterns --- they give hints how the system will fit together. Review your experiences with Models, Controllers, and Views.

• Based on the object diagram, use Nclass to draw a class diagram of the system. Remember the design patterns, and ensure that they are present in the class diagram. You might need to update your object diagram after you draw your class diagram.

• Start coding in Visual Studio:

  1. It works best to program a system from the "back end" to the "front end". You should first code the part that reads the XML-coded file from disk and constructs folder objects, which are then assembled, one by one, into the file system. Do some simple unit tests that read the input file, "filesIn.txt" (see below), and build the file system. Include the unit tests in a separate VS Project in your VS Solution.
  2. Now, code the forms and their controllers:

     (a) Implement Open on the ControlPanel first, so that a new DirectoryForm appears that shows the contents of the Root folder.

     (b) Now work on the DirectoryForm: get Open (file) working first -- that generates a new EditForm for a text file.

     (c) Next, get the EditForm working so that it can Save an edited file and can Exit.

     (d) Then get Open (folder) working next --- this shows the contents of a subfolder in the DirectoryForm.

     (e) Get CloseAll working on the ControlPanel -- This closes all DirectoryForms and EditForms and writes the contents of the file system to the textfile, filesOut.txt.

     (f) Finally, if time allows, implement NewFile and NewFolder. Implement DeleteFile.

I have included a small demo VS solution that should give you some ideas about how to construct and link Forms. Unit tests are not required for the Forms --- just connect them to your already tested "back end" and run the system.

You can read about reading/writing disk files in the reference notes I wrote: Textfile I/O and String manipulation. You will also see there how to use pattern matching on strings to process the XML tags. Study also the in-class exercises we did with virtual proxies and the file system.

When you use the ControlPanel to CloseAll the system and write the contents of the file-system tree to a sequential file, you must do a tree traversal in breadth-first order. To do this, you use a helper data structure, a queue. If you don't remember how to use a queue to do a breadth-first traversal of tree, ask me or the T.A.

Test data

When you use the file, please place it inside the VS Solution Folder, at the very top level, so that it is referenced in your code with this path: "..\\..\\..\\filesIn.txt". (This is 3 levels up from where the exe files are saved --- see how I did this in the in-class exercise we did with virtual proxies.)

When your system shuts down, it writes the updated file to this path: "..\\..\\..\\filesOut.txt".

What you submit for Assignment 6

• Prepare an object diagram that shows the objects that are alive when the system executes the use case I gave you at usecase.jpg.
• Prepare a class diagram for the system, drawn with Nclass. Submit as a .ncp file.
• Place the object diagram and class diagram in a folder named MyLastName.MyFirstName.Assn6.
• Zip the folder and upload to K-State Online.

Design-review meeting the week of April 27

What you submit for Assignment 7

• the final class diagram of the entire system, drawn with Nclass. Submit as a .ncp file.
• the VS Solution of your implementation. This folder should also contain the two text files, filesIn.txt and filesOut.txt.

This assignment is a bit more challenging than the banking project, so you must start working early if you want to finish the entire system by the deadline. In any case, design and build as much as you can, working on the implementation in the steps listed above in the section, "What you must do".

This is individual work