Object Oriented Systems Analysis and Design
Case
A hopeful (and slightly behind the times) startup company is pinning its hopes on a multiplatform distributed text-based chat application.
Signed up members connect to a server using their logonid and password, and are placed in public lobby. Their client is notified of all other currently connected members, and immediately starts receiving messages posted in the public lobby from other members. They continue receiving messages in that public area until they log out. All connected clients are notified whenever a member either connects or disconnects from the service.
While connected, members can also select a subset of other currently connected members and start private chat sessions with them. Messages sent between participants in private chat sessions appear only to those participants. Members can leave private chat sessions whenever they like, but the remaining members can continue chatting, until only one participant is left. Members can also be invited to join a private chat session that has already started.
Implement the message handling aspect of the server. You may assume that the networking aspects of the client are handled internally by the client object. Your job is to implement those aspects of the client that interface with the message handling system, and the server side message handling system itself.
In essence, you are allowed to assume that remote clients are represented by local Client objects, and you only need to organize calling methods on those objects and having those objects call methods in the message handling system. How you simulate new clients connecting and existing clients disconnecting is up to you. How you simulate clients is up to you.
Here is a list of the messages that need to be exchanged between client and server: your job is to make sure those messages get to the right chat session of the right client.
CONNECT(logonid) DISCONNECT(logonid) MEMBER_CONNECTED(logonid) MEMBER_DISCONNECTED(logonid)
SEND_MESG(chat_id, sender_id, message) RECEIVE_MESG(chat_id, sender_id, message) chat_id = NEW_CHAT(initiator_id, logonid_list) REQUEST_CHAT(initiator_id, logonid_list) INVITE_CHAT(target_id, chat_id) JOIN_CHAT(logon_id, chat_id) LEAVE_CHAT(logon_id, chat_id)
These messages are indicative only. You are not bound to implement this exact interface. You do need to implement the functionality as stated.
Luigi's Pizza makes pizzas. They make a variety of pizza bases, and cover them with a variety of sauces. They then add cheese, and a variety of toppings. Luigi's ‘schtick' is that all pizzas are customizable: customers order a pizza by ordering a base type, selecting a sauce, selecting a cheese, then selecting all the toppings they want. Each base type, sauce, cheese, and topping has its own cost, and the charge for a pizza is calculated by adding up all the component costs.
You job is to write a program that allows customers to order any combination of base, sauce, and whatever and as many toppings as they like, and to produce an itemized receipt with the correct cost for each pizza.
Here are the different bases, sauces and toppings that are available. Remember a pizza consists of 1 base type, one sauce, a particular type of cheese, and whatever toppings the customer wants.
Here are the different types of each component and their costs:
|
Bases:
|
|
|
|
Thin and Crispy
|
2.00
|
|
|
Regular
|
2.50
|
|
|
Deep Pan
|
3.00
|
|
|
Cheese Filled
|
4.00
|
|
Sauces
|
|
|
|
|
Tomato
|
1.00
|
|
|
Barbeque
|
1.50
|
|
|
Marinara
|
2.00
|
|
Cheeses
|
|
Mozarella
|
1.00
|
|
Buffalo
|
2.00
|
|
Goat
|
2.50
|
|
Cheddar
|
1.00
|
|
Toppings
|
|
Salami
|
1.00
|
|
Pepperoni
|
1.25
|
|
Ham
|
0.75
|
|
Bacon
|
1.00
|
|
Chicken
|
0.80
|
|
Ground Beef
|
1.20
|
|
Prawns
|
2.00
|
|
Dried Tomato
|
0.50
|
|
Capsicum
|
0.50
|
|
Olives
|
0.75
|
|
Jalapenos
|
0.75
|
|
Pineapple
|
0.50
|
|
Onion
|
0.50
|
|
Artichoke
|
1.00
|
|
Anchovies
|
1.50
|
|
Parmesan Cheese
|
1.00
|
|
Baby Spinach
|
0.75
|
Task
For each of the two small case studies provided, decide on an appropriate pattern or patterns to support, and explain that decision. Then, come up with a design to implement that solution and document your solution with a class diagram. Finally, implement a small test application to demonstrate your solution. Show how your solution works to support the described use case with a sequence diagram.
Deliverables
For each case study:
1. A paragraph explaining what pattern or patterns you have decided are appropriate for the solution in a Word compatible word processed document.
2. A class diagram showing your intended implementation classes
3. A ZIP file containing all your implementation source code arranged in the appropriate package hierarchy.
4. A text file containing output demonstrating how your solution supports the described use case.
Rationale
This assignment relates to the following learning outcomes:
- be able to evaluate and choose appropriate software design patterns to compose the design of a software system;
- be able to demonstrate use of a Computer Aided Software Engineering (CASE) tool to document the models in a system
Demonstrates an ability to evaluate a problem and choose an appropriate software design pattern.
Demonstrates a sound understanding of the chosen software pattern.
Demonstrates an ability to verify a design through implementation and testing.
Demonstrates an ability to document a design using a CASE package.
Presentation
Any text documents must be either in Word compatible Word processed documents, or standard ASCII text files.
Class diagrams should be saved as high resolution PNG files (NOT JPG) and included in a word processed document or submitted as a separate file. Do NOT submit Visual Paradigm project (*.vpp) files.
Source code should be packaged into a ZIP file that unpacks into the appropriate package structure.
Attachment:- object.zip