init: Chicken barn initial commit

.gitignore

+### IntelliJ IDEA ###
+out/
+!**/src/main/**/out/
+!**/src/test/**/out/
+.idea
+
+### Eclipse ###
+.apt_generated
+.classpath
+.factorypath
+.project
+.settings
+.springBeans
+.sts4-cache
+bin/
+!**/src/main/**/bin/
+!**/src/test/**/bin/
+
+### NetBeans ###
+/nbproject/private/
+/nbbuild/
+/dist/
+/nbdist/
+/.nb-gradle/
+
+### VS Code ###
+.vscode/
+
+### Mac OS ###
+.DS_Store
\ No newline at end of file

chicken-barn.iml

+<?xml version="1.0" encoding="UTF-8"?>
+<module type="JAVA_MODULE" version="4">
+  <component name="NewModuleRootManager" inherit-compiler-output="true">
+    <exclude-output />
+    <content url="file://$MODULE_DIR$">
+      <sourceFolder url="file://$MODULE_DIR$/src" isTestSource="false" />
+    </content>
+    <orderEntry type="inheritedJdk" />
+    <orderEntry type="sourceFolder" forTests="false" />
+  </component>
+</module>
\ No newline at end of file

initial_chicken_ages.csv

+1
+0
+1
\ No newline at end of file

src/Main.java

+import abstractfactory.barn.Barn;
+import abstractfactory.barn.WeekType;
+import fileadapter.*;
+import fileadapter.dataparser.DataParser;
+import fileadapter.dataparser.IntegerDataParser;
+import fileadapter.dataparser.WeekTypeDataParser;
+import fileadapter.readers.CsvFileReader;
+
+import java.io.*;
+import java.util.List;
+import java.util.Map;
+
+public class Main {
+    public static void main(String[] args) {
+        DataParser<Integer> integerDataParser = new IntegerDataParser();
+        DataParser<WeekType> weekTypeDataParser = new WeekTypeDataParser();
+
+        FileReaderAdapter<Integer> integerFileReader = new CsvFileReader<>(integerDataParser);
+        FileReaderAdapter<WeekType> weekTypeFileReader = new CsvFileReader<>(weekTypeDataParser);
+
+        String initialChickenAgesFile = "initial_chicken_ages.csv";
+        String weekTypesFile = "week_types.csv";
+
+        List<Integer> initialChickenAgesInWeeks = integerFileReader.readData(initialChickenAgesFile);
+        List<WeekType> weekTypes = weekTypeFileReader.readData(weekTypesFile);
+        Barn barn = new Barn(initialChickenAgesInWeeks);
+
+        try (PrintStream consoleFile = new PrintStream(new FileOutputStream("simulation_results.csv"))) {
+            System.setOut(consoleFile);
+
+            barn.printStatus();
+
+            for (int i = 0; i < weekTypes.size(); i++) {
+                System.out.println((i + 1) + "-week simulation:");
+                barn.updateStatus(weekTypes.get(i));
+                barn.printStatus();
+            }
+        } catch (FileNotFoundException e) {
+            e.printStackTrace();
+        }
+    }
+}
\ No newline at end of file

src/abstractfactory/barn/Barn.java

+package abstractfactory.barn;
+
+import abstractfactory.chicken.Chicken;
+import abstractfactory.entity.Entity;
+import abstractfactory.entity.EntityFactory;
+
+import java.util.ArrayList;
+import java.util.List;
+
+import static java.util.List.copyOf;
+
+public class Barn implements IBarn{
+    private static final int MAX_AGE = 6;
+    private final List<Entity> entityLinkedList;
+    private WeekType weekType;
+    private int eggCount;
+
+    public Barn(List<Integer> initialChickenAgesInWeeks) {
+        this.entityLinkedList = new ArrayList<>();
+        this.eggCount = 0;
+
+        for (int ageInWeeks : initialChickenAgesInWeeks) {
+            Entity chicken = new Chicken("Chicken", ageInWeeks, null, this);
+            entityLinkedList.add(chicken);
+        }
+    }
+
+    @Override
+    public int getWeekTypeValue(){
+        return weekType.getEggsToLay();
+    }
+
+    public void setWeekType(WeekType weekType) {
+        this.weekType = weekType;
+    }
+
+    @Override
+    public void incrementEggCount(int eggs){
+        eggCount += eggs;
+    }
+
+    @Override
+    public void decrementEggCount(){
+        eggCount--;
+    }
+
+    @Override
+    public void addEntity(EntityFactory factory){
+        Entity entity = factory.createEntity();
+        entityLinkedList.add(entity);
+    }
+    @Override
+    public void updateStatus(WeekType weekType){
+        setWeekType(weekType);
+        List<Entity> copy = copyOf(entityLinkedList);
+
+        for (Entity entity : copy) {
+            entity.evolve();
+        }
+    }
+
+    @Override
+    public void printStatus() {
+
+        for (Entity entity : entityLinkedList) {
+            if (entity.entityExists().isEmpty() || entity.getName().contains("egg")) {
+                continue;
+            }
+
+            printEntityStatus(entity);
+            System.out.println();
+        }
+
+        System.out.println("Eggs: " + eggCount);
+        System.out.println();
+    }
+
+    private void printEntityStatus(Entity entity) {
+        String age = entity.getAgeInWeeks() >= MAX_AGE ? "x" : String.valueOf(entity.getAgeInWeeks());
+
+        if (entity.containParent().isPresent()) {
+            Entity newParent = getUpdatedParent(entity.getParent());
+            entity.updateParent(newParent);
+            printEntityStatus(newParent);
+
+            System.out.print("/");
+        }
+
+        System.out.print(enhanceEntityName(entity) + "{" + age + "}");
+    }
+
+    private Entity getUpdatedParent(Entity parent) {
+        for (Entity entity : entityLinkedList) {
+            String entityName = enhanceEntityName(entity);
+            String parentName = enhanceEntityName(parent);
+
+            if (entityName.equals(parentName)) {
+                return entity;
+            }
+        }
+
+        return parent;
+    }
+
+    private String enhanceEntityName(Entity entity){
+        return entity.getName() + entityLinkedList.indexOf(entity);
+    }
+}

src/abstractfactory/barn/IBarn.java

+package abstractfactory.barn;
+
+import abstractfactory.entity.EntityFactory;
+
+public interface IBarn {
+
+    int getWeekTypeValue();
+    void decrementEggCount();
+    void incrementEggCount(int eggs);
+    void addEntity(EntityFactory entityFactory);
+    void printStatus();
+    void updateStatus(WeekType weekType);
+}

src/abstractfactory/barn/WeekType.java

+package abstractfactory.barn;
+
+public enum WeekType {
+    GOOD(3),
+    NORMAL(1),
+    BAD(0);
+
+    private final int eggsToLay;
+
+    WeekType(int eggsToLay) {
+        this.eggsToLay = eggsToLay;
+    }
+
+    public int getEggsToLay() {
+        return eggsToLay;
+    }
+}

src/abstractfactory/chicken/Chicken.java

+package abstractfactory.chicken;
+
+import abstractfactory.barn.IBarn;
+import abstractfactory.egg.EggFactory;
+import abstractfactory.entity.Entity;
+
+import java.util.Optional;
+
+public class Chicken implements Entity {
+    private final static int MAX_AGE = 6;
+    private final String name;
+    private int ageInWeeks;
+    private Entity parent;
+    private final IBarn barn;
+
+    public Chicken(String name, int ageInWeeks, Entity parent, IBarn barn) {
+        this.name = name;
+        this.ageInWeeks = ageInWeeks;
+        this.parent = parent;
+        this.barn = barn;
+    }
+
+    @Override
+    public String getName() {
+        return name;
+    }
+
+    @Override
+    public int getAgeInWeeks() {
+        return ageInWeeks;
+    }
+
+    @Override
+    public void incrementAge() {
+        if(!isDead()){
+            this.ageInWeeks++;
+        }
+    }
+
+    public Entity getParent(){
+        return parent;
+    }
+
+    @Override
+    public void updateParent(Entity updatedParent) {
+        this.parent = updatedParent;
+    }
+
+    @Override
+    public void evolve() {
+        incrementAge();
+        layEggs();
+    }
+
+    @Override
+    public Optional<Entity> entityExists() {
+        return Optional.of(this);
+    }
+
+    @Override
+    public Optional<Entity> containParent() {
+        return Optional.ofNullable(getParent());
+    }
+
+    private void layEggs(){
+        if (ageInWeeks >= 2 && ageInWeeks <= 4){
+            int eggsToLay = barn.getWeekTypeValue();
+
+            barn.incrementEggCount(eggsToLay);
+            for(int i = 0; i < eggsToLay; i++){
+                barn.addEntity(new EggFactory(this, barn));
+            }
+        }
+    }
+
+    public boolean isDead(){
+        return this.ageInWeeks >= MAX_AGE;
+    }
+}

src/abstractfactory/chicken/ChickenFactory.java

+package abstractfactory.chicken;
+
+import abstractfactory.barn.IBarn;
+import abstractfactory.entity.Entity;
+import abstractfactory.entity.EntityFactory;
+
+public class ChickenFactory implements EntityFactory {
+    private final String name;
+    private final int ageInWeeks;
+    private final Entity parent;
+    private final IBarn barn;
+
+    public ChickenFactory(String name, int ageInWeeks, Entity parent, IBarn barn) {
+        this.name = name;
+        this.ageInWeeks = ageInWeeks;
+        this.parent = parent;
+        this.barn = barn;
+    }
+
+    @Override
+    public Entity createEntity() {
+        return new Chicken(name, ageInWeeks, parent, barn);
+    }
+}

src/abstractfactory/egg/Egg.java

+package abstractfactory.egg;
+
+import abstractfactory.barn.IBarn;
+import abstractfactory.chicken.ChickenFactory;
+import abstractfactory.entity.Entity;
+
+import java.util.Optional;
+
+public class Egg implements Entity {
+    private Entity mother;
+    private final IBarn barn;
+    private int ageInWeeks;
+
+    public Egg(Entity mother, IBarn barn, int ageInWeeks) {
+        this.mother = mother;
+        this.barn = barn;
+        this.ageInWeeks = ageInWeeks;
+    }
+
+    @Override
+    public String getName() {
+        return "egg";
+    }
+    @Override
+    public int getAgeInWeeks() {
+        return 0;
+    }
+    @Override
+    public void incrementAge() {
+        this.ageInWeeks++;
+    }
+    @Override
+    public Entity getParent(){
+        return mother;
+    }
+
+    @Override
+    public void updateParent(Entity updatedParent) {
+        this.mother = updatedParent;
+    }
+
+    @Override
+    public void evolve() {
+        incrementAge();
+        hatch();
+    }
+
+    @Override
+    public Optional<Entity> entityExists() {
+        return Optional.of(this);
+    }
+
+    @Override
+    public Optional<Entity> containParent() {
+        return Optional.ofNullable(getParent());
+    }
+
+    private void hatch(){
+        if(this.ageInWeeks == 2){
+            barn.decrementEggCount();
+            barn.addEntity(new ChickenFactory("Chicken", 0, mother, barn));
+        }
+    }
+
+}

src/abstractfactory/egg/EggFactory.java

+package abstractfactory.egg;
+
+import abstractfactory.barn.IBarn;
+import abstractfactory.entity.Entity;
+import abstractfactory.entity.EntityFactory;
+
+public class EggFactory implements EntityFactory {
+    private final Entity mother;
+    private final IBarn barn;
+
+    public EggFactory(Entity mother, IBarn barn) {
+        this.mother = mother;
+        this.barn = barn;
+    }
+
+    @Override
+    public Entity createEntity() {
+        return new Egg(mother, barn, 0);
+    }
+}

src/abstractfactory/entity/Entity.java

+package abstractfactory.entity;
+
+import java.util.Optional;
+
+public interface Entity {
+    String getName();
+    int getAgeInWeeks();
+    void incrementAge();
+    Entity getParent();
+    void updateParent(Entity updatedParent);
+    void evolve();
+    Optional<Entity> entityExists();
+    Optional<Entity> containParent();
+}

src/abstractfactory/entity/EntityFactory.java

+package abstractfactory.entity;
+
+public interface EntityFactory {
+    Entity createEntity();
+}

src/fileadapter/FileReaderAdapter.java

+package fileadapter;
+
+import java.util.List;
+import java.util.Map;
+
+public interface FileReaderAdapter<T> {
+    List<T> readData(String fileName);
+}

src/fileadapter/dataparser/DataParser.java

+package fileadapter.dataparser;
+
+public interface DataParser<T> {
+    T parseData(String line);
+}

src/fileadapter/dataparser/IntegerDataParser.java

+package fileadapter.dataparser;
+
+public class IntegerDataParser implements DataParser<Integer> {
+    @Override
+    public Integer parseData(String line) {
+        return Integer.parseInt(line);
+    }
+}

src/fileadapter/dataparser/WeekTypeDataParser.java

+package fileadapter.dataparser;
+
+import abstractfactory.barn.WeekType;
+
+public class WeekTypeDataParser implements DataParser<WeekType> {
+    @Override
+    public WeekType parseData(String line) {
+        return WeekType.valueOf(line.toUpperCase());
+    }
+}
\ No newline at end of file

src/fileadapter/readers/CsvFileReader.java

+package fileadapter.readers;
+
+import fileadapter.FileReaderAdapter;
+import fileadapter.dataparser.DataParser;
+
+import java.io.BufferedReader;
+import java.io.FileReader;
+import java.io.IOException;
+import java.util.ArrayList;
+import java.util.List;
+
+public class CsvFileReader<T> implements FileReaderAdapter<T> {
+    private final DataParser<T> dataParser;
+
+    public CsvFileReader(DataParser<T> dataParser) {
+        this.dataParser = dataParser;
+    }
+
+    @Override
+    public List<T> readData(String fileName) {
+        List<T> dataList = new ArrayList<>();
+        try (BufferedReader reader = new BufferedReader(new FileReader(fileName))) {
+            String line;
+            while ((line = reader.readLine()) != null) {
+                T dataValue = dataParser.parseData(line);
+                dataList.add(dataValue);
+            }
+        } catch (IOException e) {
+            e.printStackTrace();
+        }
+        return dataList;
+    }
+}
\ No newline at end of file

src/fileadapter/readers/TxtFileReader.java

+package fileadapter.readers;
+
+import abstractfactory.barn.IBarn;
+import abstractfactory.barn.WeekType;
+import fileadapter.FileReaderAdapter;
+import fileadapter.dataparser.DataParser;
+
+import java.io.*;
+import java.util.ArrayList;
+import java.util.List;
+
+public class TxtFileReader<T> implements FileReaderAdapter<T> {
+    private final DataParser<T> dataParser;
+
+    public TxtFileReader(DataParser<T> dataParser) {
+        this.dataParser = dataParser;
+    }
+
+    @Override
+    public List<T> readData(String fileName) {
+        List<T> dataList = new ArrayList<>();
+        try (BufferedReader reader = new BufferedReader(new FileReader(fileName))) {
+            String line;
+            while ((line = reader.readLine()) != null) {
+                T dataValue = dataParser.parseData(line);
+                dataList.add(dataValue);
+            }
+        } catch (IOException e) {
+            e.printStackTrace();
+        }
+        return dataList;
+    }
+}

week_types.csv

+good
+bad
+normal
+good
+normal
+good
+normal
\ No newline at end of file