Merge pull request #5 from Pyrokines17/lab2

Lab2

Author: Pyrokines17

lab2/.gitignore

@@ -0,0 +1,38 @@
+target/
+!.mvn/wrapper/maven-wrapper.jar
+!**/src/main/**/target/
+!**/src/test/**/target/
+
+### IntelliJ IDEA ###
+.idea/modules.xml
+.idea/jarRepositories.xml
+.idea/compiler.xml
+.idea/libraries/
+*.iws
+*.iml
+*.ipr
+
+### Eclipse ###
+.apt_generated
+.classpath
+.factorypath
+.project
+.settings
+.springBeans
+.sts4-cache
+
+### NetBeans ###
+/nbproject/private/
+/nbbuild/
+/dist/
+/nbdist/
+/.nb-gradle/
+build/
+!**/src/main/**/build/
+!**/src/test/**/build/
+
+### VS Code ###
+.vscode/
+
+### Mac OS ###
+.DS_Store

lab2/pom.xml

@@ -0,0 +1,25 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project xmlns="http://maven.apache.org/POM/4.0.0"
+         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
+    <modelVersion>4.0.0</modelVersion>
+
+    <groupId>ru.nsu.gunko</groupId>
+    <artifactId>lab2</artifactId>
+    <version>1.0-SNAPSHOT</version>
+
+    <properties>
+        <maven.compiler.source>17</maven.compiler.source>
+        <maven.compiler.target>17</maven.compiler.target>
+        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
+    </properties>
+    <dependencies>
+        <dependency>
+            <groupId>org.junit.jupiter</groupId>
+            <artifactId>junit-jupiter</artifactId>
+            <version>RELEASE</version>
+            <scope>test</scope>
+        </dependency>
+    </dependencies>
+
+</project>

lab2/readme.md

@@ -0,0 +1,29 @@
+
+# Задача 2. Стековый калькулятор
+
+Написать стековый калькулятор, который принимает в качестве аргумента командой строки имя файла, содержащего команды. Если аргумента нет, то использовать стандартный поток ввода для чтения команд. Использовать вещественные числа.
+
+Реализовать следующий набор команд:
+1. `#` - строка с комментарием.
+2. `POP, PUSH` - снять/положить число со/на стек(а).
+3. `+ , - , * , /, SQRT` - арифметические операции. Используют один или два верхних элемента стека, изымают их из стека, помещая результат назад.
+4. `PRINT` - печать верхнего элемента стека (без удаления).
+5. `DEFINE` - задать значение параметра. В дальнейшем везде использовать вместо параметра это значение.
+
+Пример (должно вывести 2):
+```
+DEFINE a 4
+PUSH a
+SQRT
+PRINT
+```
+
+## Технические требования
+
+1. Создание команд реализуйте с помощью шаблона проектирования [«фабричный метод»](https://ru.wikipedia.org/wiki/%D0%A4%D0%B0%D0%B1%D1%80%D0%B8%D1%87%D0%BD%D1%8B%D0%B9_%D0%BC%D0%B5%D1%82%D0%BE%D0%B4_(%D1%88%D0%B0%D0%B1%D0%BB%D0%BE%D0%BD_%D0%BF%D1%80%D0%BE%D0%B5%D0%BA%D1%82%D0%B8%D1%80%D0%BE%D0%B2%D0%B0%D0%BD%D0%B8%D1%8F)). Реализация команд не зависит от остальной системы. Остальной код работает только с фабрикой команд и интерфейсами, про конкретные команды ничего не знает.
+2. Разбор текстового файла с командами и их аргументами реализуйте отдельным классом, который не зависит от остальной системы.
+3. Загрузку классов команд при создании в фабрике осуществляйте по полному квалифицированному имени класса (включая имя пакета) посредством `Class.forName()` с последующим созданием объектов команд методом `Class.newInstance()`. Фабрика конфигурируется с помощью файла содержащего соответствия между именами команд и классами, реализующими эти команды. Зависимости фабрики от конкретных классов команд (кроме корневого-абстрактного) быть не должно. Файл конфигурации должен храниться рядом с файлом класса-фабрики.
+4. Содержимое стека и именованные параметры передавать команде в виде специального объекта - контекста исполнения. При желании, аргументы команды тоже можно брать из контекста.
+5. Разработать иерархию исключений, которые будут выбрасывать команды при исполнении. В случае возникновения исключения — выводить информацию об ошибке
+   и продолжать исполнение программы (из файла или команд вводимых с консоли).
+6. Напишите тесты с использованием JUnit (см. [шаблон проекта](https://github.com/dsavenko/nsu-oop-java-template/tree/master/testlab)).

lab2/src/main/java/ru/nsu/gunko/ArgsParser.java

@@ -0,0 +1,35 @@
+package ru.nsu.gunko;
+
+import java.util.*;
+
+public class ArgsParser {
+    List<String> result;
+
+    public ArgsParser() {
+        result = new ArrayList<>();
+    }
+
+    public List<String> parse(List<String> args) {
+        if (args.isEmpty()) {
+            result.add("none");
+            result.add("base");
+        } else if (args.size() == 1) {
+            if (args.get(0).equals("base") || args.get(0).equals("add")) {
+                result.add("none");
+                result.add(args.get(0));
+            } else {
+                result.add(args.get(0));
+                result.add("base");
+            }
+        } else if (args.size() == 2) {
+            if (args.get(0).equals("base") || args.get(0).equals("add")) {
+                result.add(args.get(1));
+                result.add(args.get(0));
+            } else {
+                result.add(args.get(0));
+                result.add(args.get(1));
+            }
+        }
+        return result;
+    }
+}

lab2/src/main/java/ru/nsu/gunko/CommandReader.java

@@ -0,0 +1,24 @@
+package ru.nsu.gunko;
+
+import java.io.*;
+import java.util.*;
+
+public class CommandReader {
+    private final BufferedReader bufReader;
+
+    public CommandReader(BufferedReader newReader) {
+        bufReader = newReader;
+    }
+
+    public List<List<String>> getCommands() throws IOException {
+        String line;
+        List<List<String>> res = new ArrayList<>();
+
+        while ((line = bufReader.readLine()) != null) {
+            String[] sepStr = line.split("\\s+");
+            res.add(new ArrayList<>(Arrays.asList(sepStr)));
+        }
+
+        return res;
+    }
+}

lab2/src/main/java/ru/nsu/gunko/Context.java

@@ -0,0 +1,27 @@
+package ru.nsu.gunko;
+
+import java.util.*;
+
+public class Context {
+    private final Stack<Double> stack;
+    private final Map<String, Double> map;
+    private final List<String> arguments;
+
+    public Context() {
+        stack = new Stack<>();
+        map = new HashMap<>();
+        arguments = new ArrayList<>();
+    }
+
+    public Stack<Double> getStack() {
+        return stack;
+    }
+
+    public Map<String, Double> getMap() {
+        return map;
+    }
+
+    public List<String> getArguments() {
+        return arguments;
+    }
+}

lab2/src/main/java/ru/nsu/gunko/Main.java

@@ -0,0 +1,73 @@
+package ru.nsu.gunko;
+
+import ru.nsu.gunko.factory.commands.Operation;
+import ru.nsu.gunko.factory.exceptions.*;
+import ru.nsu.gunko.factory.*;
+
+import java.io.*;
+import java.util.*;
+
+public class Main {
+    public static void main(String[] args) {
+        List<List<String>> commands = new ArrayList<>();
+        Context context = new Context();
+        ArgsParser argsParser = new ArgsParser();
+
+        List<String> list = argsParser.parse(Arrays.asList(args));
+
+        if (!list.get(0).equals("none")) {
+            try (BufferedReader br = new BufferedReader(new FileReader(list.get(0)))) {
+                CommandReader cr = new CommandReader(br);
+                commands = cr.getCommands();
+            } catch (IOException e) {
+                System.err.println("Error while reading commands: " + e.getLocalizedMessage());
+            }
+        } else {
+            Scanner in = new Scanner(System.in);
+            String line = in.nextLine();
+
+            while (!line.isEmpty()) {
+                String[] sepStr = line.split("\\s+");
+                commands.add(new ArrayList<>(Arrays.asList(sepStr)));
+                line = in.nextLine();
+            }
+        }
+
+        try {
+            Factory factory;
+
+            if (list.get(1).equals("base")) {
+                factory = new BaseFactory();
+            } else {
+                Factory base = new BaseFactory();
+                factory = new AddFactory(base);
+            }
+
+            for (List<String> command : commands) {
+                try {
+                    Operation operation = factory.getOperation(command);
+
+                    if (command.size() > 1) {
+                        context.getArguments().addAll(command.subList(1, command.size()));
+                    }
+
+                    operation.perform(context);
+                } catch (EmptyStackException e) {
+                    System.err.println("Can't do perform (empty stack): " + command.get(0));
+                } catch (DefineNotFoundException | NotEnoughParamException e) {
+                    System.err.println("Error while do perform: " + e.getLocalizedMessage());
+                } catch (NameOfClassNotFoundException e) {
+                    System.err.println("Error while finding operation: " + e.getLocalizedMessage());
+                } catch (BadCreatingException e) {
+                    System.err.println("Error while creating operation: " + e.getLocalizedMessage());
+                }
+
+                if (!context.getArguments().isEmpty()) {
+                    context.getArguments().clear();
+                }
+            }
+        } catch (IOException e) {
+            System.err.println("Error while creating factory: " + e.getLocalizedMessage());
+        }
+    }
+}

lab2/src/main/java/ru/nsu/gunko/factory/AddFactory.java

@@ -0,0 +1,26 @@
+package ru.nsu.gunko.factory;
+
+import ru.nsu.gunko.factory.commands.Operation;
+
+import java.util.*;
+
+public class AddFactory implements Factory {
+    private final Factory factory;
+    private final Map<String, Operation> map;
+
+    public AddFactory(Factory newFactory) {
+        factory = newFactory;
+        map = new HashMap<>();
+    }
+
+    @Override
+    public Operation getOperation(List<String> command) {
+        if (!map.containsKey(command.get(0))) {
+            Operation operation = factory.getOperation(command);
+            map.put(command.get(0), operation);
+            return operation;
+        } else {
+            return map.get(command.get(0));
+        }
+    }
+}

lab2/src/main/java/ru/nsu/gunko/factory/BaseFactory.java

@@ -0,0 +1,53 @@
+package ru.nsu.gunko.factory;
+
+import ru.nsu.gunko.factory.commands.Operation;
+import ru.nsu.gunko.factory.exceptions.*;
+
+import java.io.*;
+import java.util.*;
+
+public class BaseFactory implements Factory {
+    private final Map<String, String> arrOfClass;
+
+    public BaseFactory() throws IOException {
+        arrOfClass = this.getMap();
+    }
+
+    @Override
+    public Operation getOperation(List<String> command) {
+        String nameOfClass;
+
+        if (arrOfClass.containsKey(command.get(0))) {
+            nameOfClass = arrOfClass.get(command.get(0));
+        } else {
+            throw new NameOfClassNotFoundException(command.get(0));
+        }
+
+        Operation operation;
+
+        try {
+            operation = (Operation) Class.forName(nameOfClass).newInstance();
+        } catch (ClassNotFoundException | InstantiationException | IllegalAccessException e) {
+            throw new BadCreatingException(command.get(0), e);
+        }
+
+        return operation;
+    }
+
+    private Map<String, String> getMap() throws IOException {
+        Map<String, String> map = new HashMap<>();
+        String line;
+
+        try (InputStream is = this.getClass().getResourceAsStream("/Conf");
+             InputStreamReader isr = new InputStreamReader(is);
+             BufferedReader br = new BufferedReader(isr)
+        ) {
+            while ((line = br.readLine()) != null) {
+                String[] sepStr = line.split("\\s+");
+                map.put(sepStr[0], sepStr[1]);
+            }
+        }
+
+        return map;
+    }
+}

lab2/src/main/java/ru/nsu/gunko/factory/Factory.java

@@ -0,0 +1,9 @@
+package ru.nsu.gunko.factory;
+
+import ru.nsu.gunko.factory.commands.Operation;
+
+import java.util.List;
+
+public interface Factory {
+    Operation getOperation(List<String> command);
+}