Task 1 2

homework-g595-ferenets/pom.xml

@@ -0,0 +1,28 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+         xmlns="http://maven.apache.org/POM/4.0.0"
+         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
+    <parent>
+        <artifactId>mipt-java-2016</artifactId>
+        <groupId>ru.mipt.java2016</groupId>
+        <version>1.0.0</version>
+    </parent>
+    <modelVersion>4.0.0</modelVersion>
+
+    <artifactId>homework-g595-ferenets</artifactId>
+    <version>1.0.0</version>
+    <dependencies>
+        <dependency>
+            <groupId>ru.mipt.java2016</groupId>
+            <artifactId>homework-base</artifactId>
+            <version>1.0.0</version>
+        </dependency>
+        <dependency>
+            <groupId>ru.mipt.java2016</groupId>
+            <artifactId>homework-tests</artifactId>
+            <version>1.0.0</version>
+        </dependency>
+    </dependencies>
+
+
+</project>

homework-g595-ferenets/src/main/java/ru/mipt/java2016/homework/g595/ferenets/task1/MyCalculator.java

@@ -0,0 +1,139 @@
+package ru.mipt.java2016.homework.g595.ferenets.task1;
+
+import ru.mipt.java2016.homework.base.task1.Calculator;
+import ru.mipt.java2016.homework.base.task1.ParsingException;
+
+import java.util.ArrayDeque;
+import java.util.Arrays;
+import java.util.HashSet;
+
+
+public class MyCalculator implements Calculator {
+
+    private static final HashSet<Character> ACCEPTABLE_SYMBOLS = new HashSet<>(
+            Arrays.asList('0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '.', '+', '-', '*', '/',
+                    '(', ')'));
+    private static final HashSet<Character> DIGITS =
+            new HashSet<>(Arrays.asList('0', '1', '2', '3', '4', '5', '6', '7', '8', '9'));
+    private static final HashSet<Character> OPERATORS =
+            new HashSet<>(Arrays.asList('+', '-', '*', '/'));
+    private static final HashSet<Character> SPACES = new HashSet<>(Arrays.asList(' ', '\n', '\t'));
+
+
+    @Override
+    public double calculate(String expression) throws ParsingException {
+        if (expression == null) {
+            throw new ParsingException("Null Expression");
+        }
+        int bracketsBalance = 0;
+        String expressionInBrackets = "";
+        String expressionOutOfBrackets = "";
+        for (char currentCharacter : expression.toCharArray()) {
+            if (!ACCEPTABLE_SYMBOLS.contains(currentCharacter) && !SPACES
+                    .contains(currentCharacter)) {
+                throw new ParsingException("Bad expression");
+            } else if (currentCharacter == '(') {
+                bracketsBalance += 1;
+            } else {
+                if (currentCharacter == ')') {
+                    bracketsBalance -= 1;
+                    if (bracketsBalance < 0) {
+                        throw new ParsingException("Bad Brackets Balance");
+                    }
+                    if (bracketsBalance == 0) {
+                        expressionOutOfBrackets += calculate(expressionInBrackets);
+                        expressionInBrackets = "";
+                    }
+                } else {
+                    if (bracketsBalance == 0) {
+                        expressionOutOfBrackets += currentCharacter;
+                    } else {
+                        expressionInBrackets += currentCharacter;
+                    }
+                }
+            }
+        }
+        if (bracketsBalance != 0) {
+            throw new ParsingException("Bad Brackets Balance");
+        }
+        ArrayDeque<Double> numberArrayDeque = new ArrayDeque<>();
+        ArrayDeque<Character> operatorArrayDeque = new ArrayDeque<>();
+        boolean isReadingNumber = false;
+        boolean isDotInNumber = false;
+        boolean wasOperator = true;
+        String number = "";
+        expression = expressionOutOfBrackets;
+        for (char currentCharacter : expression.toCharArray()) {
+            if (DIGITS.contains(currentCharacter) || currentCharacter == '.') {
+                wasOperator = false;
+                if (!isReadingNumber) {
+                    if (currentCharacter == '.') {
+                        throw new ParsingException("Dot is in the beginning of number");
+                    } else {
+                        number = "" + currentCharacter;
+                        isDotInNumber = false;
+                        isReadingNumber = true;
+                    }
+                } else {
+                    if (currentCharacter == '.') {
+                        if (isDotInNumber) {
+                            throw new ParsingException("Two Dots In Number");
+                        } else {
+                            isDotInNumber = true;
+                        }
+                    }
+                    number += currentCharacter;
+                }
+            } else if (OPERATORS.contains(currentCharacter)) {
+                if (wasOperator) {
+                    if (currentCharacter == '-') {
+                        if (number.equals("-")) {
+                            number = "";
+                        } else {
+                            number = "-";
+                        }
+                        isReadingNumber = true;
+                        isDotInNumber = false;
+                    } else {
+                        throw new ParsingException("Two Operators Together");
+                    }
+                    continue;
+                }
+                wasOperator = true;
+                numberArrayDeque.add(Double.valueOf(number));
+                isReadingNumber = false;
+                operatorArrayDeque.add(currentCharacter);
+            }
+        }
+        if (isReadingNumber) {
+            numberArrayDeque.add(Double.valueOf(number));
+        }
+        if (numberArrayDeque.isEmpty()) {
+            throw new ParsingException("Too Few Numbers");
+        }
+        ArrayDeque<Double> newNumberArrayDeque = new ArrayDeque<>();
+        ArrayDeque<Character> newOperatorArrayDeque = new ArrayDeque<>();
+        while (numberArrayDeque.size() > 1) {
+            char currentOperator = operatorArrayDeque.pop();
+            if (currentOperator == '+' || currentOperator == '-') {
+                newNumberArrayDeque.add(numberArrayDeque.pop());
+                newOperatorArrayDeque.add(currentOperator);
+            } else if (currentOperator == '*') {
+                numberArrayDeque.push(numberArrayDeque.pop() * numberArrayDeque.pop());
+            } else if (currentOperator == '/') {
+                numberArrayDeque.push(numberArrayDeque.pop() / numberArrayDeque.pop());
+            }
+        }
+        newNumberArrayDeque.add(numberArrayDeque.pop());
+        Double result = newNumberArrayDeque.pop();
+        while (!newNumberArrayDeque.isEmpty()) {
+            char currentOperator = newOperatorArrayDeque.pop();
+            if (currentOperator == '+') {
+                result += newNumberArrayDeque.pop();
+            } else if (currentOperator == '-') {
+                result -= newNumberArrayDeque.pop();
+            }
+        }
+        return result;
+    }
+}

homework-g595-ferenets/src/main/java/ru/mipt/java2016/homework/g595/ferenets/task2/DoubleSerializationStrategy.java

@@ -0,0 +1,17 @@
+package ru.mipt.java2016.homework.g595.ferenets.task2;
+
+import java.io.IOException;
+import java.io.RandomAccessFile;
+
+
+public class DoubleSerializationStrategy implements SerializationStrategy<Double> {
+    @Override
+    public Double read(RandomAccessFile file) throws IOException {
+        return file.readDouble();
+    }
+
+    @Override
+    public void write(RandomAccessFile file, Double value) throws IOException {
+        file.writeDouble(value);
+    }
+}

homework-g595-ferenets/src/main/java/ru/mipt/java2016/homework/g595/ferenets/task2/IntegerSerializationStrategy.java

@@ -0,0 +1,18 @@
+package ru.mipt.java2016.homework.g595.ferenets.task2;
+
+import java.io.IOException;
+import java.io.RandomAccessFile;
+
+
+public class IntegerSerializationStrategy implements SerializationStrategy<Integer> {
+
+    @Override
+    public Integer read(RandomAccessFile file) throws IOException {
+        return file.readInt();
+    }
+
+    @Override
+    public void write(RandomAccessFile file, Integer value) throws IOException {
+        file.writeInt(value);
+    }
+}

homework-g595-ferenets/src/main/java/ru/mipt/java2016/homework/g595/ferenets/task2/MyKeyValueStorage.java

@@ -0,0 +1,104 @@
+package ru.mipt.java2016.homework.g595.ferenets.task2;
+
+import ru.mipt.java2016.homework.base.task2.KeyValueStorage;
+
+import java.io.File;
+import java.io.FileNotFoundException;
+import java.io.IOException;
+import java.io.RandomAccessFile;
+import java.util.HashMap;
+import java.util.Iterator;
+
+public class MyKeyValueStorage<K, V> implements KeyValueStorage<K, V> {
+
+    private HashMap<K, V> map;
+    private SerializationStrategy<K> keySerializator;
+    private SerializationStrategy<V> valueSerializator;
+    private RandomAccessFile fileRA;
+    private boolean opened;
+
+
+    public MyKeyValueStorage(String path, SerializationStrategy argKeySerializator,
+                      SerializationStrategy argValueSerializator) throws IOException {
+        map = new HashMap<>();
+        keySerializator = argKeySerializator;
+        valueSerializator = argValueSerializator;
+        opened = true;
+        String pathToStorage = path + File.separator + "storage.txt";
+        try {
+            File file = new File(pathToStorage);
+            if (file.createNewFile()) {
+                fileRA = new RandomAccessFile(file.getPath(), "rw");
+            } else {
+                fileRA = new RandomAccessFile(file, "rw");
+                int elementsCount = fileRA.readInt();
+                for (int i = 0; i < elementsCount; ++i) {
+                    K currentKey = this.keySerializator.read(fileRA);
+                    V currentValue = this.valueSerializator.read(fileRA);
+                    map.put(currentKey, currentValue);
+                }
+            }
+        } catch (FileNotFoundException e) {
+            throw new FileNotFoundException("File is not found");
+        }
+    }
+
+    private void checkFileAccess() {
+        if (!opened) {
+            throw new IllegalStateException("The storage is closed");
+        }
+    }
+
+    @Override
+    public V read(K key) {
+        checkFileAccess();
+        return map.get(key);
+    }
+
+    @Override
+    public boolean exists(K key) {
+        checkFileAccess();
+        return map.containsKey(key);
+    }
+
+    @Override
+    public void write(K key, V value) {
+        checkFileAccess();
+        map.put(key, value);
+    }
+
+    @Override
+    public void delete(K key) {
+        checkFileAccess();
+        map.remove(key);
+    }
+
+    @Override
+    public Iterator readKeys() {
+        checkFileAccess();
+        return map.keySet().iterator();
+    }
+
+    @Override
+    public int size() {
+        checkFileAccess();
+        return map.size();
+    }
+
+    @Override
+    public void close() throws IOException {
+        try {
+            fileRA.setLength(0);
+            fileRA.seek(0);
+            fileRA.writeInt(map.size());
+            for (HashMap.Entry<K, V> entry : map.entrySet()) {
+                keySerializator.write(fileRA, entry.getKey());
+                valueSerializator.write(fileRA, entry.getValue());
+            }
+            fileRA.close();
+            opened = false;
+        } catch (IOException e) {
+            throw new IOException("Closed.");
+        }
+    }
+}

homework-g595-ferenets/src/main/java/ru/mipt/java2016/homework/g595/ferenets/task2/SerializationStrategy.java

@@ -0,0 +1,11 @@
+package ru.mipt.java2016.homework.g595.ferenets.task2;
+
+
+import java.io.IOException;
+import java.io.RandomAccessFile;
+
+public interface SerializationStrategy<T> {
+    T read(RandomAccessFile file) throws IOException;
+
+    void write(RandomAccessFile file, T value) throws IOException;
+}

homework-g595-ferenets/src/main/java/ru/mipt/java2016/homework/g595/ferenets/task2/StringSerializationStrategy.java

@@ -0,0 +1,17 @@
+package ru.mipt.java2016.homework.g595.ferenets.task2;
+
+import java.io.IOException;
+import java.io.RandomAccessFile;
+
+
+public class StringSerializationStrategy implements SerializationStrategy<String> {
+    @Override
+    public String read(RandomAccessFile file) throws IOException {
+        return file.readUTF();
+    }
+
+    @Override
+    public void write(RandomAccessFile file, String value) throws IOException {
+        file.writeUTF(value);
+    }
+}

homework-g595-ferenets/src/main/java/ru/mipt/java2016/homework/g595/ferenets/task2/StudentKeySerializationStrategy.java

@@ -0,0 +1,20 @@
+package ru.mipt.java2016.homework.g595.ferenets.task2;
+
+
+import ru.mipt.java2016.homework.tests.task2.StudentKey;
+
+import java.io.IOException;
+import java.io.RandomAccessFile;
+
+public class StudentKeySerializationStrategy implements SerializationStrategy<StudentKey> {
+    @Override
+    public StudentKey read(RandomAccessFile file) throws IOException {
+        return new StudentKey(file.readInt(), file.readUTF());
+    }
+
+    @Override
+    public void write(RandomAccessFile file, StudentKey value) throws IOException {
+        file.writeInt(value.getGroupId());
+        file.writeUTF(value.getName());
+    }
+}

homework-g595-ferenets/src/main/java/ru/mipt/java2016/homework/g595/ferenets/task2/StudentSerializationStrategy.java

@@ -0,0 +1,26 @@
+package ru.mipt.java2016.homework.g595.ferenets.task2;
+
+
+import ru.mipt.java2016.homework.tests.task2.Student;
+
+import java.io.IOException;
+import java.io.RandomAccessFile;
+import java.util.Date;
+
+public class StudentSerializationStrategy implements SerializationStrategy<Student> {
+    @Override
+    public Student read(RandomAccessFile file) throws IOException {
+        return new Student(file.readInt(), file.readUTF(), file.readUTF(),
+                new Date(file.readLong()), file.readBoolean(), file.readDouble());
+    }
+
+    @Override
+    public void write(RandomAccessFile file, Student value) throws IOException {
+        file.writeInt(value.getGroupId());
+        file.writeUTF(value.getName());
+        file.writeUTF(value.getHometown());
+        file.writeLong(value.getBirthDate().getTime());
+        file.writeBoolean(value.isHasDormitory());
+        file.writeDouble(value.getAverageScore());
+    }
+}