XML support added

resources/validator.xsd

@@ -0,0 +1,18 @@
+<xs:schema elementFormDefault="qualified" xmlns:xs="http://www.w3.org/2001/XMLSchema">
+    <xs:element name="Shapes">
+        <xs:complexType>
+            <xs:sequence>
+                <xs:element name="Shape" maxOccurs="unbounded" minOccurs="0">
+                    <xs:complexType>
+                        <xs:simpleContent>
+                            <xs:extension base="xs:string">
+                                <xs:attribute type="xs:float" name="edge" use="required"/>
+                                <xs:attribute type="xs:string" name="name" use="required"/>
+                            </xs:extension>
+                        </xs:simpleContent>
+                    </xs:complexType>
+                </xs:element>
+            </xs:sequence>
+        </xs:complexType>
+    </xs:element>
+</xs:schema>

src/containers/Backpack.java

@@ -0,0 +1,68 @@
+package containers;
+
+import data.Shape;
+import exception.BackpackOverflow;
+
+import java.util.ArrayList;
+import java.util.Iterator;
+import java.util.Spliterator;
+import java.util.function.Consumer;
+
+public class Backpack<T extends Shape> implements Iterable<T> {
+    private ArrayList<T> elements;
+    private final int n;
+
+    public Backpack(int n) {
+        this.n = n;
+        try {
+            elements = new ArrayList<>();
+        } catch (NegativeArraySizeException e) {
+            System.out.println("NegativeArraySize");
+        }
+    }
+
+    public int add(T element) {
+        if (elements.size() == n) {
+            throw new BackpackOverflow();
+        } else {
+            elements.add(element);
+            sort();
+            return elements.indexOf(element);
+        }
+    }
+
+    public void remove(int i) {
+        if (elements.size() != 0) {
+            elements.remove(i);
+        }
+    }
+
+    public int size() {
+        return elements.size();
+    }
+
+    public void sort() {
+        elements.sort((a, b) -> (int) (b.getVolume() - a.getVolume()));
+    }
+
+    public void createFromArrayList(ArrayList<T> arrayList) {
+        elements = arrayList;
+    }
+
+    @Override
+    public Iterator<T> iterator() {
+        return elements.iterator();
+    }
+
+    @Override
+    public void forEach(Consumer<? super T> consumer) {
+        for (T element : elements) {
+            consumer.accept(element);
+        }
+    }
+
+    @Override
+    public Spliterator<T> spliterator() {
+        return null;
+    }
+}

src/controller/Controller.java

@@ -0,0 +1,115 @@
+package controller;
+
+import containers.Backpack;
+import data.Ball;
+import data.Cube;
+import data.Shape;
+import data.Tetrahedron;
+import gui.GUI;
+import org.w3c.dom.*;
+import org.xml.sax.SAXException;
+
+import javax.xml.XMLConstants;
+import javax.xml.parsers.DocumentBuilderFactory;
+import javax.xml.parsers.ParserConfigurationException;
+import javax.xml.transform.Transformer;
+import javax.xml.transform.TransformerException;
+import javax.xml.transform.TransformerFactory;
+import javax.xml.transform.dom.DOMSource;
+import javax.xml.transform.stream.StreamResult;
+import javax.xml.transform.stream.StreamSource;
+import javax.xml.validation.Schema;
+import javax.xml.validation.SchemaFactory;
+import javax.xml.validation.Validator;
+import java.io.File;
+import java.io.FileNotFoundException;
+import java.io.FileOutputStream;
+import java.io.IOException;
+import java.util.ArrayList;
+
+public class Controller {
+    private final int BACKPACK_CAPACITY = 100;
+    private final Backpack<Shape> backpack = new Backpack<>(BACKPACK_CAPACITY);
+    private final File xsdFile;
+
+    public Controller() {
+        GUI app = new GUI(this);
+        app.setVisible(true);
+        xsdFile = new File("resources/validator.xsd");
+    }
+
+    public String backpackStat() {
+        return "Backpack Size: " + backpack.size() + ", Backpack Capacity: " + BACKPACK_CAPACITY;
+    }
+
+    public int addElementToBackpack(Shape new_element) {
+        return backpack.add(new_element);
+    }
+
+    public void remove(int i) {
+        backpack.remove(i);
+    }
+
+    public void saveToXML(File file) throws TransformerException, FileNotFoundException, ParserConfigurationException {
+        Document document = DocumentBuilderFactory.newInstance().newDocumentBuilder().newDocument();
+
+        Element root = document.createElement("Shapes");
+        for (Shape shape : backpack) {
+            Element xml_shape = document.createElement("Shape");
+            xml_shape.setAttribute("name", shape.getType());
+            xml_shape.setAttribute("edge", String.valueOf(shape.getEdge()));
+            root.appendChild(xml_shape);
+        }
+        document.appendChild(root);
+
+        Transformer transformer = TransformerFactory.newInstance().newTransformer();
+        DOMSource source = new DOMSource(document);
+        StreamResult result = new StreamResult(new FileOutputStream(file.getAbsolutePath()));
+        transformer.transform(source, result);
+    }
+
+    public void validateXMLSchema(File xmlFile) throws SAXException, IOException {
+        SchemaFactory factory =
+                SchemaFactory.newInstance(XMLConstants.W3C_XML_SCHEMA_NS_URI);
+        Schema schema = factory.newSchema(xsdFile);
+        Validator validator = schema.newValidator();
+        validator.validate(new StreamSource(xmlFile));
+    }
+
+    public ArrayList<Shape> loadFromXML(File file) throws IOException, SAXException, ParserConfigurationException {
+        validateXMLSchema(file);
+
+        Document document = DocumentBuilderFactory.newInstance().newDocumentBuilder().parse(file);
+        NodeList nodeList = document.getElementsByTagName("Shape");
+        ArrayList<Shape> arrayList = new ArrayList<>();
+
+        for (int i = 0; i < nodeList.getLength(); i++) {
+            Node node = nodeList.item(i);
+            if (node.getNodeType() == Node.ELEMENT_NODE) {
+                NamedNodeMap nodeMap = node.getAttributes();
+                String shapeType = nodeMap.getNamedItem("name").getNodeValue();
+                double edge = Double.parseDouble(nodeMap.getNamedItem("edge").getNodeValue());
+
+                Shape shape;
+                switch (shapeType) {
+                    case "Ball":
+                        shape = new Ball(edge);
+                        break;
+                    case "Cube":
+                        shape = new Cube(edge);
+                        break;
+                    case "Tetrahedron":
+                        shape = new Tetrahedron(edge);
+                        break;
+                    default:
+                        throw new IllegalStateException("Unexpected value: " + shapeType);
+                }
+                arrayList.add(shape);
+            }
+        }
+
+        backpack.createFromArrayList(arrayList);
+        return arrayList;
+    }
+}
+

src/data/Ball.java

@@ -0,0 +1,29 @@
+package data;
+
+public class Ball extends Shape {
+    double radius;
+
+    public Ball(double radius) {
+        this.radius = radius;
+    }
+
+    @Override
+    public double getVolume() {
+        return 4.0 / 3 * Math.PI * Math.pow(radius, 3);
+    }
+
+    @Override
+    public String toString() {
+        return "Ball with radius " + radius + " and Volume " + RoundAvoid(getVolume(), 4);
+    }
+
+    @Override
+    public String getType() {
+        return "Ball";
+    }
+
+    @Override
+    public double getEdge() {
+        return radius;
+    }
+}

src/data/Cube.java

@@ -0,0 +1,29 @@
+package data;
+
+public class Cube extends Shape {
+    double edge;
+
+    public Cube(double edge) {
+        this.edge = edge;
+    }
+
+    @Override
+    public double getVolume() {
+        return Math.pow(edge, 3);
+    }
+
+    @Override
+    public String toString() {
+        return "Cube with edge " + edge + " and Volume " + RoundAvoid(getVolume(), 4);
+    }
+
+    @Override
+    public String getType() {
+        return "Cube";
+    }
+
+    @Override
+    public double getEdge() {
+        return edge;
+    }
+}

src/data/Shape.java

@@ -0,0 +1,13 @@
+package data;
+
+public abstract class Shape {
+    public abstract double getEdge();
+    public abstract double getVolume();
+    public abstract String getType();
+
+    protected double RoundAvoid(double value, int places) {
+        double scale = Math.pow(10, places);
+        return Math.round(value * scale) / scale;
+    }
+}
+

src/data/Tetrahedron.java

@@ -0,0 +1,29 @@
+package data;
+
+public class Tetrahedron extends Shape {
+    double edge;
+
+    public Tetrahedron(double edge) {
+        this.edge = edge;
+    }
+
+    @Override
+    public double getVolume() {
+        return Math.pow(edge, 3) / (6 * Math.sqrt(2));
+    }
+
+    @Override
+    public String toString() {
+        return "Tetrahedron with edge " + edge + " and Volume " + RoundAvoid(getVolume(), 4);
+    }
+
+    @Override
+    public String getType() {
+        return "Tetrahedron";
+    }
+
+    @Override
+    public double getEdge() {
+        return edge;
+    }
+}

src/exception/BackpackOverflow.java

@@ -0,0 +1,7 @@
+package exception;
+
+public class BackpackOverflow extends RuntimeException {
+    public BackpackOverflow() {
+        super("Can`t add anymore to backpack");
+    }
+}