Java family tree

src/ru/gb/family_tree/Main.java

@@ -0,0 +1,8 @@
+import view.*;
+
+public class Main {
+ public static void main(String[] args) {
+ View view = new ConsoleView();
+ view.start();
+ }
+}

src/ru/gb/family_tree/model/builders/HumanBuilder.java

@@ -0,0 +1,15 @@
+package model.builders;
+
+import java.time.LocalDate;
+
+import model.human.Human;
+
+public class HumanBuilder {
+ private int genId;
+ public Human build(String name){
+ return new Human(genId++, name, LocalDate.now());
+ }
+ public Human build(String name, Human mother, Human father){
+ return new Human(genId++, name, LocalDate.now(), mother, father);
+ }
+}

src/ru/gb/family_tree/model/familyTree/FamilyTree.java

@@ -0,0 +1,52 @@
+package model.familyTree;
+import java.io.Serializable;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.Iterator;
+
+import model.human.comparators.NameComparator;
+
+public class FamilyTree<T extends FamilyTreeItem<T>> implements Serializable, Iterable<T> {
+ private ArrayList<T> tree;
+ public FamilyTree() {
+ tree = new ArrayList<T>();
+ }
+ public FamilyTree(ArrayList<T> tree) {
+ this.tree = tree;
+ }
+ public ArrayList<T> tree(){
+ return tree;
+ }
+ public Boolean add(T el){
+ if (tree.contains(el)) return false;
+ return tree.add(el);
+ }
+ public T remove(int index){
+ return tree.remove(index);
+ }
+ public T getFirst(){
+ return tree.getFirst();
+ }
+ @Override
+ public String toString(){
+ StringBuilder sb = new StringBuilder();
+ sb.append("FamilyTree:\n");
+ if (tree == null) sb.append("Empty\n");
+ for(var el : tree)
+ sb.append(el.toString() + "\n");
+ return sb.toString();
+ }
+ @Override
+ public Iterator<T> iterator() {
+ return new FamilyTreeIterator<T>(tree);
+ }
+ public void sort() {
+ Collections.sort(tree);
+ }
+ public void sortByName(){
+ tree.sort(new NameComparator<T>());
+ }
+ public T get(int id) {
+ return tree.get(id);
+ }
+}

src/ru/gb/family_tree/model/familyTree/FamilyTreeItem.java

@@ -0,0 +1,8 @@
+package model.familyTree;
+
+import java.io.Serializable;
+
+public interface FamilyTreeItem<T> extends Comparable<T>,Serializable {
+ String getName();
+ String toString();
+}

src/ru/gb/family_tree/model/familyTree/FamilyTreeIterator.java

@@ -0,0 +1,21 @@
+package model.familyTree;
+
+import java.util.Iterator;
+import java.util.List;
+
+public class FamilyTreeIterator<T extends FamilyTreeItem<T>> implements Iterator<T>{
+ private int index;
+ private List<T> tree;
+ public FamilyTreeIterator(List<T> list) {
+ tree = list;
+ }
+ @Override
+ public boolean hasNext() {
+ return tree.size() > index;
+ }
+ @Override
+ public T next() {
+ return tree.get(index++);
+ }
+
+}

src/ru/gb/family_tree/model/familyTree/FamilyTreeSerializer.java

@@ -0,0 +1,40 @@
+package model.familyTree;
+import java.io.FileInputStream;
+import java.io.FileOutputStream;
+import java.io.IOException;
+import java.io.ObjectInputStream;
+import java.io.ObjectOutputStream;
+
+public class FamilyTreeSerializer<T extends FamilyTreeItem<T>> {
+ public void write(String path, FamilyTree<T> obj){
+ try {
+ var outputStream = new ObjectOutputStream(new FileOutputStream(path));
+ outputStream.writeObject(obj);
+ outputStream.close();
+ }
+ catch (IOException e){
+ System.out.println("File not exist or wrong path!");
+ }
+ }
+ public FamilyTree<T> read(String path){
+ try{
+ var inputStream = new ObjectInputStream(new FileInputStream(path));
+ @SuppressWarnings("unchecked")
+ FamilyTree<T> ft = (FamilyTree<T>)inputStream.readObject();
+ inputStream.close();
+ return ft;
+ }
+ catch (IOException e){
+ System.out.println("File not exist or wrong path!");
+ return null;
+ }
+ catch (ClassCastException e){
+ System.out.println("Enable to cast object!");
+ return null;
+ }
+ catch (ClassNotFoundException e){
+ System.out.println("Can't find class library!");
+ return null;
+ }
+ }
+}

src/ru/gb/family_tree/model/human/Gender.java

@@ -0,0 +1,5 @@
+package model.human;
+
+public enum Gender {
+ Male, Female
+}

src/ru/gb/family_tree/model/human/Human.java

@@ -0,0 +1,100 @@
+package model.human;
+import java.time.LocalDate;
+import java.time.Period;
+import java.util.ArrayList;
+import java.util.List;
+
+import model.familyTree.FamilyTreeItem;
+
+public class Human implements FamilyTreeItem<Human>{
+ private long id;
+ private String name;
+ private LocalDate birthDate;
+ private LocalDate deathDate = null;
+ private Gender gender;
+ private Human mother, father = null;
+ private ArrayList<Human> children = null;
+
+ public Human(long id, String name, LocalDate birthDate) {
+ this(id, name, birthDate, null, null, null);
+ }
+ public Human(long id, String name, LocalDate birthDate, Human mother, Human father) {
+ this(id, name, birthDate, mother, father, null);
+ }
+ public Human(long id, String name, LocalDate birthDate, Human mother,
+ Human father, ArrayList<Human> children) {
+ this.id = id;
+ this.name = name;
+ this.birthDate = birthDate;
+ this.gender = id % 2 == 0? Gender.Male : Gender.Female;
+ this.mother = mother;
+ if (this.mother != null) this.mother.children.add(this);
+ this.father = father;
+ if (this.father != null) this.father.children.add(this);
+ this.children = children == null? (new ArrayList<Human>()) : children;
+ }
+
+ public String getName(){
+ return name;
+ }
+ public LocalDate getBirthDate(){
+ return birthDate;
+ }
+ public Gender getGender(){
+ return gender;
+ }
+ public Human getMother(){
+ return mother;
+ }
+ public Human getFather(){
+ return father;
+ }
+ public List<Human> getChildren(){
+ return children;
+ }
+ public Boolean addChild(Human child){
+ if (children.contains(child)) return false;
+ return children.add(child);
+ }
+ public Boolean addChildren(ArrayList<Human> children){
+ return children.addAll(children);
+ }
+ public Boolean setDeathDate(LocalDate deathDate){
+ if (this.deathDate != null) return false;
+ this.deathDate = deathDate;
+ return true;
+ }
+ public LocalDate getDeathDate(){
+ return deathDate;
+ }
+ public int getAge(){
+ LocalDate d2 = LocalDate.now();
+ if (deathDate != null) d2 = deathDate;
+ return DiffBetween(deathDate,d2).getYears();
+ }
+ private Period DiffBetween(LocalDate d1, LocalDate d2){
+ return Period.between(d1, d2);
+ }
+ @Override
+ public String toString(){
+ return String.format("%d %s %s born: %s mother: %s father: %s", id, name,
+ gender, birthDate, mother != null? mother.name : "none", 
+ father != null? father.name : "none");
+ }
+ // public String FamilyTree(){
+ // return FamilyTree(0);
+ // }
+ // public String FamilyTree(int tabsCount){
+ // StringBuilder sb = new StringBuilder();
+ // sb.append(this.toString() + "\n");
+ // String tabs = "\t".repeat(tabsCount);
+ // tabsCount++;
+ // for(var child : children)
+ // sb.append(tabs + child.FamilyTree(tabsCount));
+ // return sb.toString();
+ // }
+ @Override
+ public int compareTo(Human o) {
+ return birthDate.compareTo(o.getBirthDate());
+ }
+}

src/ru/gb/family_tree/model/human/comparators/NameComparator.java

@@ -0,0 +1,13 @@
+package model.human.comparators;
+
+import java.util.Comparator;
+
+import model.familyTree.FamilyTreeItem;
+
+public class NameComparator<T extends FamilyTreeItem<T>> implements Comparator<T>{
+
+ @Override
+ public int compare(T o1, T o2) {
+ return o1.getName().compareTo(o2.getName());
+ }
+}

src/ru/gb/family_tree/model/services/Service.java

@@ -0,0 +1,38 @@
+package model.services;
+
+import model.builders.HumanBuilder;
+import model.familyTree.FamilyTree;
+import model.human.Human;
+
+public class Service {
+ private FamilyTree<Human> tree;
+ private HumanBuilder humanBuilder;
+ public Service() {
+ tree = new FamilyTree<>();
+ humanBuilder = new HumanBuilder();
+ }
+ public void addHuman(String name){
+ var human = humanBuilder.build(name);
+ tree.add(human);
+ }
+ public void addHuman(String name, int motherId, int fatherId){
+ var human = humanBuilder.build(name, getHuman(motherId), getHuman(fatherId));
+ tree.add(human);
+ }
+ public String getFamilyTree(){
+ StringBuilder sb = new StringBuilder();
+ sb.append("Family tree:\n");
+ for(Human human : tree)
+ sb.append(human + "\n");
+ return sb.toString();
+ }
+ public void sortByBirthDate(){
+ tree.sort();
+ }
+ public void sortByName(){
+ tree.sortByName();
+ }
+ public Human getHuman(int id) {
+ return tree.get(id);
+ }
+}

src/ru/gb/family_tree/presenter/Presenter.java

@@ -0,0 +1,45 @@
+package presenter;
+
+import model.familyTree.FamilyTreeItem;
+import model.human.Human;
+import model.services.Service;
+import view.View;
+
+public class Presenter {
+ private View view;
+ private Service service;
+
+ public Presenter(View view){
+ this.view = view;
+ this.service = new Service();
+ }
+
+ public void addTreeItem(String name) {
+ service.addHuman(name);
+ getFamilyTree();
+ }
+
+ public void addTreeItem(String name, int motherId, int fatherId){
+ service.addHuman(name, motherId, fatherId);
+ getFamilyTree();
+ }
+
+ public FamilyTreeItem<Human> getTreeItem(int id) {
+ return service.getHuman(id);
+ }
+
+ public void getFamilyTree() {
+ String answer = service.getFamilyTree();
+ view.printAnswer(answer);
+ }
+
+ public void sortByName() {
+ service.sortByName();
+ getFamilyTree();
+ }
+
+ public void sortByBirthDate() {
+ service.sortByBirthDate();
+ getFamilyTree();
+ }
+}