Updated Readme, added screenshots & sample outputs

Author: samujjwaal

README.md

@@ -1,6 +1,8 @@
 ## Object-oriented design and implementation of a Design Pattern Code Generator.
 This project is the implementation of a program that generates the implementation code of the 23 Gang of Four(GoF) design patterns, as presented in the book “Design Patterns: Elements of Reusable Object-Oriented Software”. 
 
+------
+
 ## Index
 
 1. About Design Patterns
@@ -45,6 +47,8 @@ The 23 Design Patterns are classified into 3 main categories:
   * Template
   * Visitor
 
+------
+
 #### 2. About JavaPoet
 
 [JavaPoet](https://github.com/square/javapoet), a successor to [JavaWriter](https://github.com/square/javapoet/tree/javawriter_2), is a Java API for generating .java source files. It can generate primitive types, reference types (like classes, interfaces, enumerated types, anonymous inner classes), fields, methods, parameters, annotations, and Javadocs. 
@@ -90,6 +94,8 @@ JavaPoet offers models for classes & interfaces (`TypeSpec`), fields (`FieldSpec
 
 The most recent version of JavaPoet available as of now is 1.12.1.
 
+------
+
 #### 3. Application Design
 
 To implement Design Pattern Code Generator(DePaCoG), I have employed the **Factory Method**, **Template Method** and **Singleton** design patterns.
@@ -244,6 +250,14 @@ public class DePaCoG {
   * Sometimes singleton pattern can hide bad code design
   * It requires modifications to be used in a multi threaded environment to make sure multiple instances are not created by multiple threads
 
+------
+
+The image below shows a class diagram for the complete application. For simplicity I have selected only 3 design pattern classes (each representing its category of design patterns) out of the 23.
+
+![](C:\Users\Samujjwaal Dey\Desktop\CS 474 OOLE\homework1\screenshots\DePaCoG.png)
+
+The class `DePaCoG` has the main() method in it. It creates an instance of class `Hw1DesignPatternGenerator` (concrete implementation of `DesignPatternGenerator` ). Methods here are for displaying menu of design patterns and getting choice of design pattern from user. Depending on user’s choice the corresponding design pattern generating class (implementation of ``DesignPattern`) is instantiated to generate the design pattern source code. 
+
 
 
 #### 4. Test Cases
@@ -256,7 +270,7 @@ There are 2 test classes `DesignPatternTest` and `Hw1DesignPatternGeneratorTest`
 * Test Case to verify  `generateCode()` returns `JavaFile[]` object
 * Test Case to verify the generated java files are written successfully in the output folder.
 
-
+------
 
 #### 5. Instructions to Execute
 
@@ -270,21 +284,27 @@ For command line execution, locate `hw1-assembly-0.1.jar` at `target\scala-2.13`
 
 On Windows, the command to run the jar file: `java -jar hw1-assembly-0.1.jar mode`
 
-* Executing using default config file, mode = 0: 
+* Executing using default config file, then `mode = 0`: 
+
   * run `java -jar hw1-assembly-0.1.jar 0`
 
-* Executing using custom inputs from user, mode = 1: 
+  ![](C:\Users\Samujjwaal Dey\Desktop\CS 474 OOLE\homework1\screenshots\Capture4.PNG)
+
+* Executing using custom inputs from user, then `mode = 1`: 
+
   * run `java -jar hw1-assembly-0.1.jar 1`
 
+  ![](C:\Users\Samujjwaal Dey\Desktop\CS 474 OOLE\homework1\screenshots\Capture2.PNG)
+
 For execution in IntelliJ, use `run 0` or `run 1` for the preferred way of execution (argument passed has similar purpose like in the command line method) 
 
 The output java files are saved under the package name provided in the config file (or as custom input) in a folder named `outputs`. The `outputs` folder is created in the current working directory during execution.
 
-
+------
 
 #### 6. Results of Execution
 
-While executing the Design Pattern Code Generator, the main() method in class DePaCoG is executed along with a command line argument (0 or 1). The command line argument is to select whether inputs will be entered via a configuration file or via inputs through the interactive environment.
+While executing the Design Pattern Code Generator, the main() method in class `DePaCoG` is executed along with a command line argument (`0` or `1`). The command line argument is to select whether inputs will be entered via a configuration file or via inputs through the interactive environment.
 
 Here is an example of config values to create Abstract Factory design pattern.
 
@@ -298,9 +318,17 @@ Here is an example of config values to create Abstract Factory design pattern.
 }
 ```
 
+For above config input, the output files will be saved at `outputs/com/laptopAbstractFactory`.
+
+The classes created are : `Processor.java, Intel.java, AMD.java, OperatingSystem.java, OS.java, ChromeOS.java, Ubuntu.java, LaptopFactory.java, ChromeBookFactory.java,LinuxLaptopFactory.java`
+
+The image below shows the class diagram of the classes generated after executing the config input values.
+
+![](C:\Users\Samujjwaal Dey\Desktop\CS 474 OOLE\homework1\screenshots\laptopFactory.png)
+
 In addition to Abstract Factory, the `default.conf` configuration file also contains inputs for Decorator, Adapter and Observer design patterns.
 
-For instance in above config input, the output files will be saved at `outputs/com/laptopAbstractFactory`. The `outputs` folder is created in the current working directory during execution.
+The `outputs` folder is created in the current working directory during execution.
 
-The classes created are : Processor.java, Intel.java, AMD.java, OperatingSystem.java, OS.java, ChromeOS.java, Ubuntu.java, LaptopFactory.java, ChromeBookFactory.java,LinuxLaptopFactory.java
+<img src="C:\Users\Samujjwaal Dey\Desktop\CS 474 OOLE\homework1\screenshots\Capture.PNG" style="zoom:75%;" />
 

outputs/com/coffeeDecorator/Beverage.java

@@ -0,0 +1,8 @@
+package com.coffeeDecorator;
+
+/**
+ * Component, defines interface for new features which will be added dynamically
+ */
+public interface Beverage {
+  void operation();
+}

outputs/com/coffeeDecorator/Coffee.java

@@ -0,0 +1,9 @@
+package com.coffeeDecorator;
+
+/**
+ * ConcreteComponent, define object where new features can be added
+ */
+public class Coffee implements Beverage {
+  public void operation() {
+  }
+}

outputs/com/coffeeDecorator/CondimentDecorator.java

@@ -0,0 +1,14 @@
+package com.coffeeDecorator;
+
+/**
+ * Decorator, keep reference to Component object
+ */
+abstract class CondimentDecorator implements Beverage {
+  protected Beverage component;
+
+  public abstract void operation();
+
+  public void setComponent(Beverage component) {
+    this.component = component;
+  }
+}

outputs/com/coffeeDecorator/Milk.java

@@ -0,0 +1,17 @@
+package com.coffeeDecorator;
+
+/**
+ * ConcreteDecoratorA, add features to component
+ */
+public class Milk extends CondimentDecorator {
+  private boolean state;
+
+  public void operation() {
+    state = true;
+    this.component.operation();
+  }
+
+  public boolean isState() {
+    return state;
+  }
+}

outputs/com/coffeeDecorator/WhipCream.java

@@ -0,0 +1,21 @@
+package com.coffeeDecorator;
+
+/**
+ * ConcreteDecoratorB, add features to component
+ */
+public class WhipCream extends CondimentDecorator {
+  private boolean behaviorMethodInvoked = false;
+
+  public void operation() {
+    this.component.operation();
+    addedBehavior();
+  }
+
+  private void addedBehavior() {
+    behaviorMethodInvoked = true;
+  }
+
+  protected boolean isBehaviorMethodInvoked() {
+    return behaviorMethodInvoked;
+  }
+}

outputs/com/laptopAbstractFactory/AMD.java

@@ -0,0 +1,7 @@
+package com.laptopAbstractFactory;
+
+/**
+ * ProductA2, implements AbstractProductA interface
+ */
+public class AMD implements Processor {
+}

outputs/com/laptopAbstractFactory/ChromeBookFactory.java

@@ -0,0 +1,14 @@
+package com.laptopAbstractFactory;
+
+/**
+ * ConcreteFactory2, implements creation of the concrete Product2 objects
+ */
+public class ChromeBookFactory implements Ubuntu {
+  public Processor createProcessor() {
+    return new AMD();
+  }
+
+  public OperatingSystem createOperatingSystem() {
+    return new ChromeOS();
+  }
+}

outputs/com/laptopAbstractFactory/ChromeOS.java

@@ -0,0 +1,7 @@
+package com.laptopAbstractFactory;
+
+/**
+ * ProductB1, implements AbstractProductB interface
+ */
+public class ChromeOS implements OperatingSystem {
+}

outputs/com/laptopAbstractFactory/Intel.java

@@ -0,0 +1,7 @@
+package com.laptopAbstractFactory;
+
+/**
+ * ProductA1, implements AbstractProductA interface
+ */
+public class Intel implements Processor {
+}

outputs/com/laptopAbstractFactory/LaptopFactory.java

@@ -0,0 +1,14 @@
+package com.laptopAbstractFactory;
+
+/**
+ * ConcreteFactory1, implements creation of the concrete Product1 objects
+ */
+public class LaptopFactory implements Ubuntu {
+  public Processor createProcessor() {
+    return new Intel();
+  }
+
+  public OperatingSystem createOperatingSystem() {
+    return new OS();
+  }
+}

outputs/com/laptopAbstractFactory/OS.java

@@ -0,0 +1,7 @@
+package com.laptopAbstractFactory;
+
+/**
+ * ProductB1, implements AbstractProductB interface
+ */
+public class OS implements OperatingSystem {
+}

outputs/com/laptopAbstractFactory/OperatingSystem.java

@@ -0,0 +1,7 @@
+package com.laptopAbstractFactory;
+
+/**
+ * AbstractProductB defines interface for ProductB objects
+ */
+public interface OperatingSystem {
+}

outputs/com/laptopAbstractFactory/Processor.java

@@ -0,0 +1,7 @@
+package com.laptopAbstractFactory;
+
+/**
+ * AbstractProductA defines interface for ProductA objects
+ */
+public interface Processor {
+}

outputs/com/laptopAbstractFactory/Ubuntu.java

@@ -0,0 +1,10 @@
+package com.laptopAbstractFactory;
+
+/**
+ * Abstract Factory, defines interface for creation of the abstract product objects
+ */
+public interface Ubuntu {
+  Processor createProcessor();
+
+  OperatingSystem createOperatingSystem();
+}

outputs/com/usbAdapter/MicroUSB.java

@@ -0,0 +1,10 @@
+package com.usbAdapter;
+
+/**
+ * Adaptee class, interface which will be adapted
+ */
+public class MicroUSB {
+  public String specialRequest() {
+    return "specialRequest";
+  }
+}

outputs/com/usbAdapter/TypeC.java

@@ -0,0 +1,8 @@
+package com.usbAdapter;
+
+/**
+ * Target interface, defines domain-specific interface to which Adaptee will be adapted
+ */
+public interface TypeC {
+  String request();
+}

outputs/com/usbAdapter/USBDongle.java

@@ -0,0 +1,16 @@
+package com.usbAdapter;
+
+/**
+ * Adapter class, adapts Adaptee to the Target interface
+ */
+public class USBDongle implements TypeC {
+  private MicroUSB adaptee;
+
+  public USBDongle(MicroUSB adaptee) {
+    this.adaptee = adaptee;
+  }
+
+  public String request() {
+    return adaptee.specialRequest();
+  }
+}

outputs/com/weatherObserver/AndroidPhone.java

@@ -0,0 +1,24 @@
+package com.weatherObserver;
+
+/**
+ * ConcreteObserver maintains a reference to a ConcreteSubject object, stores
+ * state that should stay consistent with the subject's, implements the Observer
+ * updating interface to keep its state consistent with the subject's.
+ */
+public class AndroidPhone implements SmartPhone {
+  private int observerState;
+
+  private DarkSkyServer subject;
+
+  public AndroidPhone(DarkSkyServer subject) {
+    this.subject = subject;
+  }
+
+  public void update() {
+    observerState = subject.getState();
+  }
+
+  protected int getObserverState() {
+    return observerState;
+  }
+}

outputs/com/weatherObserver/DarkSkyServer.java

@@ -0,0 +1,18 @@
+package com.weatherObserver;
+
+/**
+ * ConcreteSubject stores state of interest to ConcreteObserver objects, sends a notification to its observers
+ * when its state changes.
+ */
+public class DarkSkyServer extends WeatherServiceServer {
+  private int state;
+
+  public int getState() {
+    return state;
+  }
+
+  public void setState(int state) {
+    this.state = state;
+    this.notifyObservers();
+  }
+}

outputs/com/weatherObserver/SmartPhone.java

@@ -0,0 +1,8 @@
+package com.weatherObserver;
+
+/**
+ * Observer defines an updating interface for objects that should be notified of changes in a subject.
+ */
+public interface SmartPhone {
+  void update();
+}

outputs/com/weatherObserver/WeatherServiceServer.java

@@ -0,0 +1,27 @@
+package com.weatherObserver;
+
+import java.util.ArrayList;
+import java.util.Iterator;
+import java.util.List;
+
+/**
+ * Subject knows its observers. Any number of Observer objects may observe a subject.
+ */
+abstract class WeatherServiceServer {
+  private List<SmartPhone> observers = new ArrayList<SmartPhone>();
+
+  public void attach(SmartPhone observer) {
+    observers.add(observer);
+  }
+
+  public void detach(SmartPhone observer) {
+    observers.remove(observer);
+  }
+
+  public void notifyObservers() {
+    (Iterator iterator = observers.iterator(); iterator.hasNext();) {
+      SmartPhone observer = (SmartPhone) iterator.next();
+      observer.update();
+    }
+  }
+}