From 7fea5b60d9251bdc8045104c58e8ca2f3990e649 Mon Sep 17 00:00:00 2001 From: MaximGotovchits Date: Thu, 4 Dec 2014 02:15:51 +0300 Subject: [PATCH 01/18] =?UTF-8?q?=D0=93=D0=BE=D1=82=D0=BE=D0=B2=D1=87?= =?UTF-8?q?=D0=B8=D1=86=20=D0=9C=D0=B0=D0=BA=D1=81=D0=B8=D0=BC,=20396,=20S?= =?UTF-8?q?toreable?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit JSON --- .../Storeable/CommandsTools.java | 23 + .../MaximGotovchits/Storeable/Exit.java | 17 + .../MaximGotovchits/Storeable/FillTable.java | 38 ++ .../Storeable/Interpreter.java | 284 +++++++++ .../MaximGotovchits/Storeable/Main.java | 17 + .../MaximGotovchits/Storeable/MakeDirs.java | 24 + .../Storeable/ObjectStoreable.java | 233 ++++++++ .../Storeable/ObjectTable.java | 246 ++++++++ .../Storeable/ObjectTableProvider.java | 565 ++++++++++++++++++ .../Storeable/ObjectTableProviderFactory.java | 21 + .../Storeable/Test/ObjectStoreableTest.java | 109 ++++ .../Test/ObjectTableProviderFactoryTest.java | 15 + .../Test/ObjectTableProviderTest.java | 94 +++ .../Storeable/Test/ObjectTableTest.java | 133 +++++ .../MaximGotovchits/Storeable/Use.java | 66 ++ 15 files changed, 1885 insertions(+) create mode 100644 src/ru/fizteh/fivt/students/MaximGotovchits/Storeable/CommandsTools.java create mode 100644 src/ru/fizteh/fivt/students/MaximGotovchits/Storeable/Exit.java create mode 100644 src/ru/fizteh/fivt/students/MaximGotovchits/Storeable/FillTable.java create mode 100644 src/ru/fizteh/fivt/students/MaximGotovchits/Storeable/Interpreter.java create mode 100644 src/ru/fizteh/fivt/students/MaximGotovchits/Storeable/Main.java create mode 100644 src/ru/fizteh/fivt/students/MaximGotovchits/Storeable/MakeDirs.java create mode 100644 src/ru/fizteh/fivt/students/MaximGotovchits/Storeable/ObjectStoreable.java create mode 100644 src/ru/fizteh/fivt/students/MaximGotovchits/Storeable/ObjectTable.java create mode 100644 src/ru/fizteh/fivt/students/MaximGotovchits/Storeable/ObjectTableProvider.java create mode 100644 src/ru/fizteh/fivt/students/MaximGotovchits/Storeable/ObjectTableProviderFactory.java create mode 100644 src/ru/fizteh/fivt/students/MaximGotovchits/Storeable/Test/ObjectStoreableTest.java create mode 100644 src/ru/fizteh/fivt/students/MaximGotovchits/Storeable/Test/ObjectTableProviderFactoryTest.java create mode 100644 src/ru/fizteh/fivt/students/MaximGotovchits/Storeable/Test/ObjectTableProviderTest.java create mode 100644 src/ru/fizteh/fivt/students/MaximGotovchits/Storeable/Test/ObjectTableTest.java create mode 100644 src/ru/fizteh/fivt/students/MaximGotovchits/Storeable/Use.java diff --git a/src/ru/fizteh/fivt/students/MaximGotovchits/Storeable/CommandsTools.java b/src/ru/fizteh/fivt/students/MaximGotovchits/Storeable/CommandsTools.java new file mode 100644 index 000000000..5a0c1ad80 --- /dev/null +++ b/src/ru/fizteh/fivt/students/MaximGotovchits/Storeable/CommandsTools.java @@ -0,0 +1,23 @@ +package ru.fizteh.fivt.students.MaximGotovchits.Storeable; + +import java.util.HashMap; +import java.util.Map; +import java.util.Stack; + +public abstract class CommandsTools { + static String usingTable; + static ObjectTable currentTableObject; + static String dataBaseName = System.getProperty("fizteh.db.dir"); + static String signatureFileName = "signature.tsv"; + static Integer dirNum = 16; + static Integer fileNum = 16; + static String dirExt = ".dir"; + static String fileExt = ".dat"; + static Map storage = new HashMap(); + static Map commitStorage = new HashMap(); + static Stack lastChanges = new Stack(); + static int longestName = 260; + static int uncommitedChanges = 0; + static Boolean tableIsChosen = false; +} + diff --git a/src/ru/fizteh/fivt/students/MaximGotovchits/Storeable/Exit.java b/src/ru/fizteh/fivt/students/MaximGotovchits/Storeable/Exit.java new file mode 100644 index 000000000..f9abf65ee --- /dev/null +++ b/src/ru/fizteh/fivt/students/MaximGotovchits/Storeable/Exit.java @@ -0,0 +1,17 @@ +package ru.fizteh.fivt.students.MaximGotovchits.Storeable; + +public class Exit extends CommandsTools { + void exitFunction() { + System.exit(0); + } + Boolean exitAndUseAvailable() { + uncommitedChanges = Math.abs(storage.size() - commitStorage.size()); + if (uncommitedChanges == 0 || !tableIsChosen) { + return true; + } + System.out.println(uncommitedChanges + " uncommited changes"); + return false; + } +} + + diff --git a/src/ru/fizteh/fivt/students/MaximGotovchits/Storeable/FillTable.java b/src/ru/fizteh/fivt/students/MaximGotovchits/Storeable/FillTable.java new file mode 100644 index 000000000..98751720c --- /dev/null +++ b/src/ru/fizteh/fivt/students/MaximGotovchits/Storeable/FillTable.java @@ -0,0 +1,38 @@ +package ru.fizteh.fivt.students.MaximGotovchits.Storeable; + +import java.io.DataOutputStream; +import java.io.File; +import java.io.FileOutputStream; +import java.nio.charset.StandardCharsets; +import java.nio.file.Path; +import java.nio.file.Paths; +import java.util.Map; + +public class FillTable extends CommandsTools { + int dirAndFileNum = 16; + public void fillTableFunction(String tableName) throws Exception { + for (Map.Entry entry : commitStorage.entrySet()) { + int hashCode = entry.getKey().hashCode(); + Integer nDirectory = hashCode % dirAndFileNum; + Integer nFile = hashCode / dirAndFileNum % dirAndFileNum; + Path fileName = Paths.get(tableName, nDirectory + dirExt); + File file = new File(fileName.toString()); + if (!file.exists()) { + file.mkdir(); + } + fileName = Paths.get(fileName.toString(), nFile + fileExt); + file = new File(fileName.toString()); + if (!file.exists()) { + file.createNewFile(); + } + byte[] bytesKey = (" " + entry.getKey() + " ").getBytes(StandardCharsets.UTF_8); + DataOutputStream stream = new DataOutputStream(new FileOutputStream(fileName.toString(), true)); + stream.write((int) bytesKey.length); + stream.write(bytesKey); + byte[] bytesVal = ((" " + entry.getValue().serialisedValue + " ").getBytes(StandardCharsets.UTF_8)); + stream.write((int) bytesVal.length); + stream.write(bytesVal); + stream.close(); + } + } +} diff --git a/src/ru/fizteh/fivt/students/MaximGotovchits/Storeable/Interpreter.java b/src/ru/fizteh/fivt/students/MaximGotovchits/Storeable/Interpreter.java new file mode 100644 index 000000000..1470e6808 --- /dev/null +++ b/src/ru/fizteh/fivt/students/MaximGotovchits/Storeable/Interpreter.java @@ -0,0 +1,284 @@ +package ru.fizteh.fivt.students.MaximGotovchits.Storeable; + +import java.io.File; +import java.text.ParseException; +import java.util.*; + +public class Interpreter { + final String invitationSymbol = "$ "; + boolean tableIsChosen = false; // Determines if table is chosen. + boolean isCommand = false; + Scanner sc = new Scanner(System.in); + String tableName; + ObjectTable currentTable; + String dataBaseName = System.getProperty("fizteh.db.dir"); + static Map storage = new HashMap(); + + void getInputData() throws Exception { + System.out.print(invitationSymbol); + String cmd = sc.nextLine(); + parseInputData(cmd, false); + } + + void parseInputData(String cmd, boolean fromCmd) throws Exception { + String[] cmdBuffer = new String[1024]; + if (fromCmd) { + cmd = cmd.replaceAll("\\s+" + ";" + "\\s+", ";"); + cmd = cmd.replaceAll("\\s+", " "); + cmd = cmd.replaceAll(";", " "); + cmd = cmd.replaceAll("\\s+", " "); + cmdBuffer = cmd.split(" "); + } else { + if (cmd.equals("") || cmd.equals("\\s+")) { + getInputData(); + } else { + cmdBuffer = cmd.split(" "); + if (cmdBuffer[0].equals("") && cmdBuffer.length > 0) { + cmd = ""; + for (int ind = 1; ind < cmdBuffer.length; ++ind) { + cmd = cmd + cmdBuffer[ind] + " "; + } + cmdBuffer = cmd.split(" "); + } + } + } + interpreterFunction(cmdBuffer, fromCmd); + } + void interpreterFunction(String[] cmdBuffer, boolean fromCmd) throws Exception { + int ind = 0; + while (ind < cmdBuffer.length) { + isCommand = false; + if (fromCmd) { + ifContinue(ind, cmdBuffer, fromCmd); + } + if (cmdBuffer[ind].equals("put")) { + isCommand = true; + if (tableIsChosen) { + ++ind; + ifContinue(ind, cmdBuffer, fromCmd); + String key = cmdBuffer[ind]; + ++ind; + ifContinue(ind, cmdBuffer, fromCmd); + if (!cmdBuffer[ind].substring(0, 1).equals("[")) { + isCommand = false; + continue; + } + int startInd = ind; + while (!cmdBuffer[ind].substring(cmdBuffer[ind].length() - 1, + cmdBuffer[ind].length()).equals("]")) { + ++ind; + ifContinue(ind, cmdBuffer, fromCmd); + } + int finishInd = ind; + String value = new String(); + for (int i = startInd; i <= finishInd; ++i) { + value += cmdBuffer[i] + " "; + } + value = value.substring(0, value.length() - 1); + ObjectStoreable putParam = convertToStoreable(value); + new ObjectTable().put(key, putParam); + } else { + System.out.println("no table"); + } + ifContinue(ind + 1, cmdBuffer, fromCmd); + } + if (cmdBuffer[ind].equals("get")) { + isCommand = true; + if (tableIsChosen) { + if (ind + 1 < cmdBuffer.length) { + ++ind; + new ObjectTable().get(cmdBuffer[ind]); + } else { + new ObjectTable().get(null); + } + } else { + System.out.println("no table"); + } + ifContinue(ind + 1, cmdBuffer, fromCmd); + } + if (cmdBuffer[ind].equals("remove") && ind + 1 < cmdBuffer.length) { + isCommand = true; + ++ind; + if (tableIsChosen) { + new ObjectTable().remove(cmdBuffer[ind]); + } else { + System.out.println("no table"); + } + ifContinue(ind + 1, cmdBuffer, fromCmd); + } + if (cmdBuffer[ind].equals("list")) { + isCommand = true; + if (tableIsChosen) { + new ObjectTable().list(); + } else { + System.out.println("no table"); + } + ifContinue(ind + 1, cmdBuffer, fromCmd); + } + if (cmdBuffer[ind].equals("exit")) { + isCommand = true; + if (tableIsChosen) { + if (!fromCmd) { + if (new Exit().exitAndUseAvailable()) { + new FillTable().fillTableFunction(tableName); + } else { + ++ind; + ifContinue(ind, cmdBuffer, fromCmd); + continue; + } + } else { + currentTable.commit(); + new FillTable().fillTableFunction(tableName); + } + sc.close(); + new Exit().exitFunction(); + } + ifContinue(ind + 1, cmdBuffer, fromCmd); + } + if (cmdBuffer[ind].equals("create")) { + isCommand = true; + //if (tableIsChosen) { + ++ind; + ifContinue(ind, cmdBuffer, fromCmd); + String name = cmdBuffer[ind]; + ++ind; + ifContinue(ind, cmdBuffer, fromCmd); + if (!cmdBuffer[ind].substring(0, 1).equals("(")) { + isCommand = false; + System.err.println("incorrect syntax"); + continue; + } + int startInd = ind; + while (!cmdBuffer[ind].substring(cmdBuffer[ind].length() - 1, + cmdBuffer[ind].length()).equals(")")) { + ++ind; + ifContinue(ind, cmdBuffer, fromCmd); + } + int finishInd = ind; + String types = new String(); + for (int i = startInd; i <= finishInd; ++i) { + types += cmdBuffer[i]; + } + types.replaceAll("\\s+", ""); + types = types.substring(1, types.length() - 1); + String[] typeArr = types.split(","); + List> list = new LinkedList>(); + for (String type : typeArr) { + list.add(getType(type)); + } + new ObjectTableProvider().createTable(name, list); + ifContinue(ind + 1, cmdBuffer, fromCmd); + } + if (cmdBuffer[ind].equals("drop")) { + isCommand = true; + ++ind; + ifContinue(ind, cmdBuffer, fromCmd); + if (new File(tableName).getName().equals(cmdBuffer[ind])) { + tableName = null; + tableIsChosen = false; + } + new ObjectTableProvider().removeTable(tableName); + ifContinue(ind + 1, cmdBuffer, fromCmd); + } + if (cmdBuffer[ind].equals("use")) { + isCommand = true; + ++ind; + ifContinue(ind, cmdBuffer, fromCmd); + if (new Exit().exitAndUseAvailable()) { + if (storage.isEmpty()) { + new Use().useFunction(cmdBuffer[ind], tableName); + if (new File(dataBaseName + File.separator + cmdBuffer[ind]).exists()) { + tableIsChosen = true; + tableName = dataBaseName + File.separator + cmdBuffer[ind]; + currentTable = new ObjectTable(tableName); + } + } else { + System.out.println(storage.size() + " unsaved changes"); + } + } + ifContinue(ind + 1, cmdBuffer, fromCmd); + } + if (cmdBuffer[ind].equals("show")) { + ++ind; + ifContinue(ind, cmdBuffer, fromCmd); + if (cmdBuffer[ind].equals("tables")) { + isCommand = true; + new ObjectTableProvider().getTableNames(); + } + ifContinue(ind + 1, cmdBuffer, fromCmd); + } + if (cmdBuffer[ind].equals("rollback")) { + isCommand = true; + if (tableIsChosen) { + new ObjectTable().rollback(); + } else { + System.out.println("no table"); + } + ifContinue(ind + 1, cmdBuffer, fromCmd); + } + if (cmdBuffer[ind].equals("commit")) { + isCommand = true; + if (tableIsChosen) { + new ObjectTable().commit(); + } else { + System.out.println("no table"); + } + ifContinue(ind + 1, cmdBuffer, fromCmd); + } + ++ind; + if (!isCommand) { + System.err.println("incorrect syntax"); + if (fromCmd) { + System.exit(1); + } + ifContinue(ind + 1, cmdBuffer, fromCmd); + } + } + } + boolean isType(String typeName) { + if (typeName.equals("int") || typeName.equals("long") || typeName.equals("byte") || typeName.equals("float") + || typeName.equals("double") || typeName.equals("boolean") || typeName.equals("String")) { + return true; + } + return false; + } + Class getType(String typeName) { + if (typeName.equals("int")) { + return int.class; + } + if (typeName.equals("long")) { + return long.class; + } + if (typeName.equals("byte")) { + return byte.class; + } + if (typeName.equals("float")) { + return float.class; + } + if (typeName.equals("double")) { + return double.class; + } + if (typeName.equals("boolean")) { + return boolean.class; + } + if (typeName.equals("String")) { + return String.class; + } + return null; + } + ObjectStoreable convertToStoreable(String value) throws ParseException { + ObjectStoreable storeableToReturn = new ObjectStoreable(value); + return storeableToReturn; + } + void ifContinue(int ind, String[] cmdBuffer, boolean fromCmd) throws Exception { + if (ind >= cmdBuffer.length) { + if (fromCmd) { + System.err.println("incorrect syntax"); + System.exit(1); + } else { + getInputData(); + } + } + } + +} diff --git a/src/ru/fizteh/fivt/students/MaximGotovchits/Storeable/Main.java b/src/ru/fizteh/fivt/students/MaximGotovchits/Storeable/Main.java new file mode 100644 index 000000000..2d22460d1 --- /dev/null +++ b/src/ru/fizteh/fivt/students/MaximGotovchits/Storeable/Main.java @@ -0,0 +1,17 @@ +package ru.fizteh.fivt.students.MaximGotovchits.Storeable; + +public class Main { // Using JSON format. + public static void main(final String[] args) throws Exception { + new MakeDirs().makeDirsFunction(); + if (args.length == 0) { + new Interpreter().getInputData(); + } else { + String cmd = new String(); + for (String arg : args) { + cmd += arg + " "; + } + new Interpreter().parseInputData(cmd.substring(0, cmd.length() - 1), true); // Откусить " ". + new Exit().exitFunction(); + } + } +} diff --git a/src/ru/fizteh/fivt/students/MaximGotovchits/Storeable/MakeDirs.java b/src/ru/fizteh/fivt/students/MaximGotovchits/Storeable/MakeDirs.java new file mode 100644 index 000000000..84bedf0ff --- /dev/null +++ b/src/ru/fizteh/fivt/students/MaximGotovchits/Storeable/MakeDirs.java @@ -0,0 +1,24 @@ +package ru.fizteh.fivt.students.MaximGotovchits.Storeable; + +import java.io.File; + +public class MakeDirs extends CommandsTools { + void makeDirsFunction() throws Exception { + File file = new File(dataBaseName); + if (!file.exists()) { + file.mkdirs(); + } else { + if (!file.isDirectory()) { + System.err.println(dataBaseName + " is not a directory"); + System.exit(1); + } else { + for (File sub : file.listFiles()) { + if (!sub.isDirectory()) { + System.err.println(dataBaseName + File.separator + + sub.getName() + " is not a directory"); + } + } + } + } + } +} diff --git a/src/ru/fizteh/fivt/students/MaximGotovchits/Storeable/ObjectStoreable.java b/src/ru/fizteh/fivt/students/MaximGotovchits/Storeable/ObjectStoreable.java new file mode 100644 index 000000000..e38a0b672 --- /dev/null +++ b/src/ru/fizteh/fivt/students/MaximGotovchits/Storeable/ObjectStoreable.java @@ -0,0 +1,233 @@ +package ru.fizteh.fivt.students.MaximGotovchits.Storeable; + +import ru.fizteh.fivt.storage.structured.ColumnFormatException; +import ru.fizteh.fivt.storage.structured.Storeable; +import java.text.ParseException; +import java.util.LinkedList; +import java.util.List; +import java.util.Objects; + +public class ObjectStoreable extends CommandsTools implements Storeable { + public List subValueList = new LinkedList(); + public String serialisedValue = new String(); + public List> typeKeeper = new LinkedList>(); + public ObjectStoreable() {} + public ObjectStoreable(List values) { + int ind = 0; + serialisedValue = "["; + for (Object val : values) { + subValueList.add(val); + serialisedValue += val + ", "; + } + serialisedValue = serialisedValue.substring(0, serialisedValue.length() - 2); // Откусить ", ". + serialisedValue += "]"; + } + public ObjectStoreable(Storeable value) { + subValueList = ((ObjectStoreable) value).subValueList; + serialisedValue = ((ObjectStoreable) value).serialisedValue; + typeKeeper = ((ObjectStoreable) value).typeKeeper; + } + public ObjectStoreable(ObjectTable table) { + typeKeeper = table.typeKeeper; + } + public ObjectStoreable(String value) throws ParseException { + ObjectStoreable obj = (ObjectStoreable) new ObjectTableProvider().deserialize(currentTableObject, value); + if (obj == null) { + return; + } + subValueList = obj.subValueList; + serialisedValue = obj.serialisedValue; + typeKeeper = obj.typeKeeper; + } + @Override + public int hashCode() { + return Objects.hashCode(this.serialisedValue); + } + @Override + public boolean equals(Object obj) { // Возможно тут нужно было как-то использовать hashCode, + // но я не знаю как, особенно если учесть, что он возваращает Objects, а не Object. + ObjectStoreable storeableObj = (ObjectStoreable) obj; + if (this.serialisedValue.equals(storeableObj.serialisedValue) + && this.typeKeeper.equals(storeableObj.typeKeeper) + && this.subValueList.equals(storeableObj.subValueList)) { + return true; + } + return false; + } + @Override + public void setColumnAt(int columnIndex, Object value) throws ColumnFormatException, IndexOutOfBoundsException { + try { + if (columnIndex >= this.subValueList.size()) { + throw new IndexOutOfBoundsException(); + } + List> toConvert = new LinkedList>(); + toConvert.add(value.getClass()); + toConvert = convertToPrimitive(toConvert); + if (!typeKeeper.get(columnIndex).equals(toConvert.get(0))) { + throw new ColumnFormatException(); + } + } catch (IndexOutOfBoundsException s) { + System.err.println(s); + return; + } catch (ColumnFormatException s) { + System.err.println(s); + return; + } + this.subValueList.set(columnIndex, value); + this.serialisedValue = ""; + serialisedValue = "["; + for (Object val : this.subValueList) { + serialisedValue += val + ", "; + } + serialisedValue = serialisedValue.substring(0, serialisedValue.length() - 2); // Откусить ", ". + serialisedValue += "]"; + return; + } + @Override + public Object getColumnAt(int columnIndex) throws IndexOutOfBoundsException { + if (subValueList.size() < columnIndex - 1) { + throw new IndexOutOfBoundsException(); + } + return subValueList.get(columnIndex); + } + @Override + public Integer getIntAt(int columnIndex) throws ColumnFormatException, IndexOutOfBoundsException { + if (columnIndex >= subValueList.size()) { + throw new IndexOutOfBoundsException(); + } + if (!this.typeKeeper.get(columnIndex).equals(int.class)) { + throw new ColumnFormatException(); + } + return (Integer) subValueList.get(columnIndex); + } + @Override + public Long getLongAt(int columnIndex) throws ColumnFormatException, IndexOutOfBoundsException { + try { + if (columnIndex >= this.typeKeeper.size()) { + throw new IndexOutOfBoundsException(); + } + if (!typeKeeper.get(columnIndex).equals(long.class)) { + throw new ColumnFormatException(); + } + } catch (IndexOutOfBoundsException s) { + System.err.println(s); + } catch (ColumnFormatException s) { + System.err.println(s); + } + return (Long) subValueList.get(columnIndex); + } + @Override + public Byte getByteAt(int columnIndex) throws ColumnFormatException, IndexOutOfBoundsException { + try { + if (columnIndex >= this.typeKeeper.size()) { + throw new IndexOutOfBoundsException(); + } + if (!typeKeeper.get(columnIndex).equals(byte.class)) { + throw new ColumnFormatException(); + } + } catch (IndexOutOfBoundsException s) { + System.err.println(s); + } catch (ColumnFormatException s) { + System.err.println(s); + } + return (Byte) subValueList.get(columnIndex); + } + @Override + public Float getFloatAt(int columnIndex) throws ColumnFormatException, IndexOutOfBoundsException { + try { + if (columnIndex >= this.typeKeeper.size()) { + throw new IndexOutOfBoundsException(); + } + if (!typeKeeper.get(columnIndex).equals(float.class)) { + throw new ColumnFormatException(); + } + } catch (IndexOutOfBoundsException s) { + System.err.println(s); + } catch (ColumnFormatException s) { + System.err.println(s); + } + return (Float) subValueList.get(columnIndex); + } + @Override + public Double getDoubleAt(int columnIndex) throws ColumnFormatException, IndexOutOfBoundsException { + try { + if (columnIndex >= this.typeKeeper.size()) { + throw new IndexOutOfBoundsException(); + } + if (!typeKeeper.get(columnIndex).equals(double.class)) { + throw new ColumnFormatException(); + } + } catch (IndexOutOfBoundsException s) { + System.err.println(s); + } catch (ColumnFormatException s) { + System.err.println(s); + } + return (Double) subValueList.get(columnIndex); + } + @Override + public Boolean getBooleanAt(int columnIndex) throws ColumnFormatException, IndexOutOfBoundsException { + try { + if (columnIndex >= this.typeKeeper.size()) { + throw new IndexOutOfBoundsException(); + } + if (!typeKeeper.get(columnIndex).equals(boolean.class)) { + throw new ColumnFormatException(); + } + } catch (IndexOutOfBoundsException s) { + System.err.println(s); + } catch (ColumnFormatException s) { + System.err.println(s); + } + return (Boolean) subValueList.get(columnIndex); + } + @Override + public String getStringAt(int columnIndex) throws ColumnFormatException, IndexOutOfBoundsException { + try { + if (columnIndex >= this.typeKeeper.size()) { + throw new IndexOutOfBoundsException(); + } + if (!typeKeeper.get(columnIndex).equals(String.class)) { + throw new ColumnFormatException(); + } + } catch (IndexOutOfBoundsException s) { + System.err.println(s); + } catch (ColumnFormatException s) { + System.err.println(s); + } + return subValueList.get(columnIndex).toString(); + } + private List> convertToPrimitive(List> list) { // Этим методом пользуюсь только я. + List> toReturn = new LinkedList>(); + for (Class object : list) { + if (object.equals(Integer.class)) { + toReturn.add(int.class); + continue; + } + if (object.equals(Long.class)) { + toReturn.add(long.class); + continue; + } + if (object.equals(Boolean.class)) { + toReturn.add(boolean.class); + continue; + } + if (object.equals(String.class)) { + toReturn.add(String.class); + continue; + } + if (object.equals(Byte.class)) { + toReturn.add(byte.class); + continue; + } + if (object.equals(Double.class)) { + toReturn.add(double.class); + continue; + } + if (object.equals(Float.class)) { + toReturn.add(float.class); + continue; + } + } + return toReturn; + } +} diff --git a/src/ru/fizteh/fivt/students/MaximGotovchits/Storeable/ObjectTable.java b/src/ru/fizteh/fivt/students/MaximGotovchits/Storeable/ObjectTable.java new file mode 100644 index 000000000..1207d5b3e --- /dev/null +++ b/src/ru/fizteh/fivt/students/MaximGotovchits/Storeable/ObjectTable.java @@ -0,0 +1,246 @@ +package ru.fizteh.fivt.students.MaximGotovchits.Storeable; + +import ru.fizteh.fivt.storage.structured.ColumnFormatException; +import ru.fizteh.fivt.storage.structured.Storeable; +import ru.fizteh.fivt.storage.structured.Table; +import java.io.File; +import java.io.IOException; +import java.nio.charset.Charset; +import java.nio.file.Files; +import java.nio.file.Paths; +import java.text.ParseException; +import java.util.*; + +public class ObjectTable extends CommandsTools implements Table { + static int overwriteNum = 0; + public String tableName; + public List> typeKeeper = new LinkedList>(); + public ObjectTable() { + tableName = usingTable; + typeKeeper = currentTableObject.typeKeeper; + } + public ObjectTable(Table table) { + ObjectTable temp = (ObjectTable) table; + this.tableName = temp.tableName; + this.typeKeeper = temp.typeKeeper; + } + public ObjectTable(String name) { + this.tableName = new File(name).getName(); + String content = new String(); + try { + if (!new File(name + File.separator + signatureFileName).isAbsolute()) { + name = dataBaseName + File.separator + name; + } + content = readFile(name + File.separator + signatureFileName, Charset.defaultCharset()); + content.replaceAll("\\s+", " "); + String[] types = content.split(" "); + int ind = 0; + for (String type : types) { + typeKeeper.add(ind, getType(type)); + ++ind; + } + } catch (IOException s) { + System.err.println(s); + } + } + public ObjectTable(String name, List> typeList) { + int ind = 0; + for (Class type : typeList) { + typeKeeper.add(type); + } + tableName = name; + } + @Override + public int hashCode() { + return Objects.hashCode(this.tableName); + } + @Override + public boolean equals(Object obj) { + ObjectTable tableObj = (ObjectTable) obj; + if (this.tableName.equals(tableObj.tableName) && this.typeKeeper.equals(tableObj.typeKeeper)) { + return true; + } + return false; + } + @Override + public String getName() { + String nameToReturn = new File(tableName).getName(); + return nameToReturn; + } + @Override + public Storeable get(String key) throws ParseException, IllegalArgumentException { // В документации в Index + // не сказано, когда кидать ParseException, однако согласно интерфейсу тут все-таки написано + // throws ParseException, но на самом деле это исключение тут не бросатется. + try { + if (key == null) { + throw new IllegalArgumentException(); + } + } catch (IllegalArgumentException s) { + System.err.println(s); + return null; + } + ObjectStoreable value = storage.get(key); + if (value == null) { + System.out.println("not found"); + return null; + } + String serializedValue = value.serialisedValue; + System.out.println("found"); + System.out.println(serializedValue); + return value; + } + @Override + public Storeable put(String key, Storeable value) throws ColumnFormatException { + try { + if (key == null || value == null) { + throw new IllegalArgumentException(); + } + } catch (IllegalArgumentException s) { + System.err.println(s); + return null; + } + try { + if (!this.typeKeeper.equals(((ObjectStoreable) value).typeKeeper)) { + throw new ColumnFormatException(); + } + } catch (ColumnFormatException s) { + System.err.println(s); + return null; + } + ObjectStoreable previousValue = storage.put(key, (ObjectStoreable) value); + if (previousValue == null) { + lastChanges.push(key); + lastChanges.push("remove"); + System.out.println("new"); + } else { + System.out.println("overwrite"); + lastChanges.push(previousValue); + lastChanges.push(key); + lastChanges.push("put"); + ++overwriteNum; + System.out.println(previousValue.serialisedValue); + } + return previousValue; + } + @Override + public Storeable remove(String key) { + try { + if (key == null) { + throw new IllegalArgumentException(); + } + } catch (IllegalArgumentException s) { + System.err.println(s); + return null; + } + ObjectStoreable value = storage.remove(key); + if (value != null) { + lastChanges.push(value); + lastChanges.push(key); + lastChanges.push("put"); + System.out.println("removed"); + } else { + System.out.println("not found"); + } + return value; + } + @Override + public int size() { + return storage.size(); + } + @Override + public List list() { + LinkedList list = new LinkedList(); + int size = 0; + Set k = storage.keySet(); + for (Object iter : k) { + list.add(iter.toString()); + if (size < storage.size() - 1) { + System.out.print(iter + ", "); + } else { + System.out.print(iter); + } + ++size; + } + if (size != 0) { + System.out.println(); + } + return list; + } + @Override + public int commit() { + int savedKeys = Math.abs(storage.size() - commitStorage.size()); + Map tmp = new HashMap(commitStorage); + commitStorage = new HashMap(storage); + lastChanges.clear(); + return savedKeys; + } + @Override + public int rollback() throws IllegalArgumentException { + int changes = Math.abs(storage.size() - commitStorage.size() + overwriteNum); + while (!lastChanges.isEmpty()) { + Object tmpCmd = lastChanges.pop(); + if (tmpCmd.equals("put")) { + String key = lastChanges.pop().toString(); + ObjectStoreable value = (ObjectStoreable) lastChanges.pop(); + storage.put(key, value); + } + if (tmpCmd.equals("remove")) { + String key = lastChanges.pop().toString(); + storage.remove(key); + } + } + overwriteNum = 0; + return changes; + } + @Override + public int getNumberOfUncommittedChanges() { + int numberOfUncommitedChanges = Math.abs(storage.size() - commitStorage.size()); + return numberOfUncommitedChanges; + } + @Override + public int getColumnsCount() { + return typeKeeper.size(); + } + @Override + public Class getColumnType(int columnIndex) throws IndexOutOfBoundsException { + try { + if (this.getColumnsCount() < columnIndex - 1) { + throw new IndexOutOfBoundsException(); + } + } catch (IndexOutOfBoundsException s) { + System.err.println(s); + return null; + } + Class objectToReturn = typeKeeper.get(columnIndex); + return objectToReturn; + } + static String readFile(String path, Charset encoding) throws IOException { + byte[] encoded = Files.readAllBytes(Paths.get(path)); + String temp = new String(encoded, encoding); + return temp.substring(0, temp.length() - 2); + } + private Class getType(String typeName) { + if (typeName.equals("int")) { + return int.class; + } + if (typeName.equals("long")) { + return long.class; + } + if (typeName.equals("byte")) { + return byte.class; + } + if (typeName.equals("float")) { + return float.class; + } + if (typeName.equals("double")) { + return double.class; + } + if (typeName.equals("boolean")) { + return boolean.class; + } + if (typeName.equals("String")) { + return String.class; + } + return null; + } +} diff --git a/src/ru/fizteh/fivt/students/MaximGotovchits/Storeable/ObjectTableProvider.java b/src/ru/fizteh/fivt/students/MaximGotovchits/Storeable/ObjectTableProvider.java new file mode 100644 index 000000000..83b9d05e8 --- /dev/null +++ b/src/ru/fizteh/fivt/students/MaximGotovchits/Storeable/ObjectTableProvider.java @@ -0,0 +1,565 @@ +package ru.fizteh.fivt.students.MaximGotovchits.Storeable; + +import ru.fizteh.fivt.storage.structured.ColumnFormatException; +import ru.fizteh.fivt.storage.structured.Storeable; +import ru.fizteh.fivt.storage.structured.Table; +import ru.fizteh.fivt.storage.structured.TableProvider; +import java.io.*; +import java.nio.charset.StandardCharsets; +import java.text.ParseException; +import java.util.LinkedList; +import java.util.List; +import java.util.Objects; + +public class ObjectTableProvider extends CommandsTools implements TableProvider { + private String rootDirectory; // Только ради тестов. Или нет... + public ObjectTableProvider() { + rootDirectory = dataBaseName; + } + public ObjectTableProvider(String dir) { + dataBaseName = dir; + rootDirectory = dir; + } + public int hashCode() { + return Objects.hashCode(this.rootDirectory); + } + @Override + public boolean equals(Object obj) { + ObjectTableProvider tempObj = (ObjectTableProvider) obj; + if (tempObj.rootDirectory.equals(this.rootDirectory)) { + return true; + } + return false; + } + @Override + public Table getTable(String name) throws IllegalArgumentException { + checkException(name); + if (new File(rootDirectory + File.separator + name).exists()) { + return new ObjectTable(rootDirectory + File.separator + name); + } + return null; + } + @Override + public Table createTable(String name, List> columnTypes) throws IOException { + checkException(name); + File file = new File(rootDirectory + File.separator + name); + File signatureFile = new File(rootDirectory + File.separator + name + File.separator + signatureFileName); + if (file.exists()) { + System.out.println(name + " exists"); + } else { + file.mkdir(); + signatureFile.createNewFile(); + PrintWriter writer = new PrintWriter(signatureFile, "UTF-8"); + String tempTypes = new String(); + for (Class type : columnTypes) { + if (type.equals(String.class)) { + tempTypes += "String "; + } else { + tempTypes += type.getName() + " "; + } + } + tempTypes = tempTypes.substring(0, tempTypes.length() - 1); + writer.println(tempTypes); + writer.close(); + System.out.println("created"); + } + return new ObjectTable(name, columnTypes); + } + @Override + public void removeTable(String name) throws IllegalArgumentException, IllegalStateException { + try { + if (name == null || name.length() > longestName) { + throw new IllegalArgumentException(); + } + String tableName = rootDirectory + File.separator + name; + File toBeRemoved = new File(tableName); + if (toBeRemoved.exists()) { + if (tableIsChosen) { + if (usingTable.equals(name)) { + storage.clear(); + commitStorage.clear(); + uncommitedChanges = 0; + tableIsChosen = false; + usingTable = null; + } + } + recRem(tableName); + toBeRemoved.delete(); + System.out.println("dropped"); + } else { + throw new IllegalStateException(); + } + } catch (IllegalArgumentException s) { + System.err.println(s); + return; + } catch (IllegalStateException s) { + System.err.println(s); + return; + } + } + @Override + public Storeable deserialize(Table table, String value) throws ParseException { + if (!checkCorrectness(value)) { + return null; + } + try { + ObjectStoreable tempStoreable = new ObjectStoreable(); + ObjectTable tempTable = (ObjectTable) table; + String[] toBeParsed = value.split(""); + if (!toBeParsed[0].equals("[")) { + throw new ParseException(value, 0); + } + if (!toBeParsed[toBeParsed.length - 1].equals("]")) { + throw new ParseException(value, toBeParsed.length - 1); + } + int writingIndex = 0; + int readingIndex = 1; + boolean detector = false; // Detects if JSON format is incorrect. + while (readingIndex < toBeParsed.length - 1) { // Parsing process. + detector = false; + if (toBeParsed[readingIndex].equals("\"")) { // String is found. + detector = true; + readingIndex = parseString(tempTable, toBeParsed, readingIndex, writingIndex, tempStoreable); + readingIndex += 3; + ++writingIndex; + if (whetherIsParsed(toBeParsed, readingIndex)) { // Checks if parsing has to be stopped immediately. + break; + } + } + if (toBeParsed[readingIndex].equals("t") || toBeParsed[readingIndex].equals("f")) { // Boolean is found. + detector = true; + readingIndex = parseBoolean(tempTable, toBeParsed, readingIndex, writingIndex, tempStoreable); + readingIndex += 2; + ++writingIndex; + if (whetherIsParsed(toBeParsed, readingIndex)) { + break; + } + } + if (toBeParsed[readingIndex].equals("n")) { // Null is found. + detector = true; + parseNull(tempTable, toBeParsed, readingIndex, writingIndex, tempStoreable); + readingIndex += 2; + ++writingIndex; + if (whetherIsParsed(toBeParsed, readingIndex)) { + break; + } + } + if (isNumber(toBeParsed[readingIndex])) { + detector = true; + readingIndex = parseNumber(tempTable, toBeParsed, readingIndex, writingIndex, tempStoreable); + if (!toBeParsed[readingIndex].equals(",") && !toBeParsed[readingIndex].equals("]")) { + throw new ParseException(value, readingIndex); + } + readingIndex += 2; + ++writingIndex; + if (whetherIsParsed(toBeParsed, readingIndex)) { + break; + } + } + if (!detector) { + throw new ParseException(value, readingIndex); + } + } + tempStoreable.serialisedValue = value; + return tempStoreable; + } catch (ParseException s) { + System.err.println(s); + return null; + } + } + @Override + public String serialize(Table table, Storeable value) throws ColumnFormatException { + ObjectStoreable valueToSerialize = (ObjectStoreable) value; + ObjectTable tableObj = (ObjectTable) table; + try { + int index = 0; + for (Class type : tableObj.typeKeeper) { + if (!type.equals(valueToSerialize.typeKeeper.get(index))) { + throw new ColumnFormatException(); + } + ++index; + } + } catch (ColumnFormatException s) { + System.out.println(s); + return null; + } + return valueToSerialize.serialisedValue; + } + @Override + public Storeable createFor(Table table) { + return new ObjectStoreable((ObjectTable) table); + } + @Override + public Storeable createFor(Table table, List values) throws ColumnFormatException, IndexOutOfBoundsException { + int ind = 0; + ObjectTable tempTable = new ObjectTable(table); + try { + List> valTypes = new LinkedList>(); + valTypes = convertToPrimitive(values); + if (values.size() != tempTable.getColumnsCount()) { + throw new IndexOutOfBoundsException(); + } + Class tableType; + Class valueType; + if (!valTypes.equals(tempTable.typeKeeper)) { + throw new ColumnFormatException(); + } + } catch (ColumnFormatException s) { + System.err.println(s); + return null; + } catch (IndexOutOfBoundsException s) { + System.err.println(s); + return null; + } + ObjectStoreable toReturn = new ObjectStoreable(values); + toReturn.typeKeeper = tempTable.typeKeeper; + return toReturn; + } + @Override + public List getTableNames() { + List list = new LinkedList(); + String currentFile = new String(); + int recordsAmount = 0; + File file = new File(rootDirectory); + for (File sub : file.listFiles()) { + recordsAmount = 0; + for (Integer i = 0; i < dirNum; ++i) { + currentFile = rootDirectory + File.separator + sub.getName() + File.separator + + i + fileExt; + File file1 = new File(currentFile); + if (file1.exists()) { + for (Integer j = 0; j < fileNum; ++j) { + currentFile = rootDirectory + File.separator + sub.getName() + File.separator + + i + dirExt + File.separator + j + fileExt; + file1 = new File(currentFile); + try { + if (file1.exists()) { + DataInputStream stream = new DataInputStream(new FileInputStream(currentFile)); + byte[] data = new byte[(int) file1.length()]; + stream.read(data); + String temp = new String(data, StandardCharsets.UTF_8); + recordsAmount += (temp.length() - temp.replaceAll(" ", "").length()) / 4; + } + } catch (IOException s) { + return null; + } + } + } + } + currentFile = new File(new File(new File(currentFile).getParent()).getParent()).getName(); + list.add(sub.getName()); + if (sub.getName().equals(usingTable)) { + System.out.println(sub.getName() + " " + (recordsAmount + storage.size())); + } else { + System.out.println(sub.getName() + " " + recordsAmount); + } + } + return list; + } + + void recRem(String myFile) { + File file = new File(myFile); + if (!file.exists()) { + return; + } + if (file.isDirectory()) { + for (File f : file.listFiles()) { + recRem(f.getAbsolutePath()); + } + } + file.delete(); + } + + public Object checkException(String name) throws IllegalArgumentException { + try { + if (name == null || name.length() > longestName) { + throw new IllegalArgumentException(); + } + } catch (IllegalArgumentException s) { + System.err.println(s); + return null; + } + return null; + } + private boolean whetherIsParsed(String[] toBeParsed, int readingIndex) { + if (toBeParsed.length - readingIndex < 3) { + return true; + } + return false; + } + private int parseString(ObjectTable table, String[] toBeParsed, + int readingIndex, int writingIndex, ObjectStoreable tempStoreable) { + ++readingIndex; + String toAdd = new String(); + while (!toBeParsed[readingIndex].equals("\"")) { + toAdd += toBeParsed[readingIndex]; + ++readingIndex; + } + tempStoreable.typeKeeper.add(writingIndex, String.class); + tempStoreable.subValueList.add(writingIndex, "\"" + toAdd + "\""); + return readingIndex; + } + + private int parseBoolean(ObjectTable table, String[] toBeParsed, + int readingIndex, int writingIndex, ObjectStoreable tempStoreable) { + if (toBeParsed[readingIndex].equals("t")) { + tempStoreable.subValueList.add(writingIndex, true); + readingIndex += 4; + } else { + tempStoreable.subValueList.add(writingIndex, false); + readingIndex += 5; + } + tempStoreable.typeKeeper.add(writingIndex, boolean.class); + return readingIndex; + } + private int parseNull(ObjectTable table, String[] toBeParsed, + int readingIndex, int writingIndex, ObjectStoreable tempStoreable) { + tempStoreable.subValueList.add(writingIndex, null); + readingIndex += 4; + tempStoreable.typeKeeper.add(writingIndex, Object.class); + return readingIndex; + } + private int parseNumber(ObjectTable table, String[] toBeParsed, + int readingIndex, int writingIndex, ObjectStoreable tempStoreable) { + int firstIndex = readingIndex; + int lastIndex = readingIndex; + boolean isDouble = false; + boolean isByte = false; + while ((!toBeParsed[lastIndex].equals("]")) && (!toBeParsed[lastIndex].equals(","))) { + // Checks if it's a boolean. + if (toBeParsed[lastIndex].equals("x")) { + if (isDouble) { + return lastIndex; + } + isByte = true; + ++lastIndex; + continue; + } + if (toBeParsed[lastIndex].equals(".") && !isByte) { + if (isByte) { + return lastIndex; + } + isDouble = true; + ++lastIndex; + continue; + } + ++lastIndex; + } + String temp = new String(); + for (int i = firstIndex; i < lastIndex; ++i) { + temp += toBeParsed[i]; + } + firstIndex = lastIndex + 2; + if (isByte) { // Is Byte. + tempStoreable.subValueList.add(writingIndex, Byte.parseByte(temp)); + tempStoreable.typeKeeper.add(writingIndex, byte.class); + return lastIndex; + } + if (isDouble) { + try { // http://bit.ly/1v9GqBT + if (table != null) { + if (table.typeKeeper.get(writingIndex).equals(double.class)) { + tempStoreable.subValueList.add(writingIndex, Double.parseDouble(temp)); + tempStoreable.typeKeeper.add(writingIndex, double.class); + return lastIndex; + } + if (table.typeKeeper.get(writingIndex).equals(float.class)) { + tempStoreable.subValueList.add(writingIndex, Float.parseFloat(temp)); + tempStoreable.typeKeeper.add(writingIndex, float.class); + return lastIndex; + } + } + Float.parseFloat(temp); + } catch (NumberFormatException s) { + tempStoreable.subValueList.add(writingIndex, Double.parseDouble(temp)); + tempStoreable.typeKeeper.add(writingIndex, double.class); + return lastIndex; + } + tempStoreable.subValueList.add(writingIndex, Float.parseFloat(temp)); + tempStoreable.typeKeeper.add(writingIndex, float.class); + return lastIndex; + } else { // Int or long is found. + try { + if (table != null) { + if (table.typeKeeper.get(writingIndex).equals(int.class)) { + tempStoreable.subValueList.add(writingIndex, Integer.parseInt(temp)); + tempStoreable.typeKeeper.add(writingIndex, int.class); + return lastIndex; + } + if (table.typeKeeper.get(writingIndex).equals(long.class)) { + tempStoreable.subValueList.add(writingIndex, Long.parseLong(temp)); + tempStoreable.typeKeeper.add(writingIndex, long.class); + return lastIndex; + } + if (table.typeKeeper.get(writingIndex).equals(byte.class)) { + tempStoreable.subValueList.add(writingIndex, Byte.parseByte(temp)); + tempStoreable.typeKeeper.add(writingIndex, byte.class); + return lastIndex; + } + } + Integer.parseInt(temp); + } catch (NumberFormatException s) { + tempStoreable.subValueList.add(writingIndex, Double.parseDouble(temp)); + tempStoreable.typeKeeper.add(writingIndex, double.class); + return lastIndex; + } + tempStoreable.subValueList.add(writingIndex, Float.parseFloat(temp)); + tempStoreable.typeKeeper.add(writingIndex, float.class); + return lastIndex; + } + } + + private boolean isNumber(String str) { + try { + Integer.parseInt(str); + } catch (NumberFormatException e) { + return false; + } + return true; + } + private boolean checkCorrectness(String value) { + boolean byteIsUsed = false; + boolean dotIsUsed = false; + String[] valueList = value.split(""); + if (!valueList[0].equals("[") || !valueList[valueList.length - 1].equals("]")) { + return false; + } + if (valueList.length == 2 && valueList[1].equals("]")) { + return true; + } + if (valueList[1].equals(" ")) { + return false; + } + for (int ind = 1; ind < valueList.length; ++ind) { + dotIsUsed = false; + byteIsUsed = false; + if (valueList[ind].equals(" ")) { + return false; + } + if (isNumber(valueList[ind])) { + ++ind; + while (isNumber(valueList[ind]) || valueList[ind].equals("x") || valueList[ind].equals(".")) { + if (valueList[ind].equals("x")) { + if (!byteIsUsed) { + byteIsUsed = true; + } else { + return false; + } + } + if (valueList[ind].equals(".")) { + if (!dotIsUsed) { + dotIsUsed = true; + } else { + return false; + } + } + ++ind; + } + if (!valueList[ind].equals(",") && ind != valueList.length - 1) { + return false; + } + if (valueList[ind].equals("]")) { + return ind == valueList.length - 1; + } + ++ind; + if (!valueList[ind].equals(" ")) { + return false; + } + } else { + if (valueList[ind].equals("\"")) { + ++ind; + while (!valueList[ind].equals("\"")) { + if (ind == valueList.length - 1) { + return false; + } + ++ind; + } + ++ind; + if (!valueList[ind].equals(",") && ind != valueList.length - 1) { + return false; + } + if (valueList[ind].equals("]")) { + return ind == valueList.length - 1; + } + ++ind; + if (!valueList[ind].equals(" ")) { + return false; + } + } else { + if (valueList[ind].equals("t") || valueList[ind].equals("f")) { + if (valueList[ind].equals("t") && ind + 4 < valueList.length) { + if (!valueList[ind + 1].equals("r") || !valueList[ind + 2].equals("u") + || !valueList[ind + 3].equals("e")) { + return false; + } + ind += 4; + if (!valueList[ind].equals(",") && ind != valueList.length - 1) { + return false; + } + if (valueList[ind].equals("]")) { + return ind == valueList.length - 1; + } + ++ind; + if (!valueList[ind].equals(" ")) { + return false; + } + } else { + if (valueList[ind].equals("f") && ind + 5 < valueList.length) { + if (!valueList[ind + 1].equals("a") || !valueList[ind + 2].equals("l") + || !valueList[ind + 3].equals("s") || !valueList[ind + 4].equals("e")) { + return false; + } + ind += 5; + if (!valueList[ind].equals(",") && ind != valueList.length - 1) { + return false; + } + if (valueList[ind].equals("]")) { + return ind == valueList.length - 1; + } + ++ind; + if (!valueList[ind].equals(" ")) { + return false; + } + } + } + } + } + } + } + return true; + } + private List> convertToPrimitive(List list) { // Этим методом пользуюсь только я. Все под контролем. + List> toReturn = new LinkedList>(); + for (Object object : list) { + if (object.getClass().equals(Integer.class)) { + toReturn.add(int.class); + continue; + } + if (object.getClass().equals(Long.class)) { + toReturn.add(long.class); + continue; + } + if (object.getClass().equals(Boolean.class)) { + toReturn.add(boolean.class); + continue; + } + if (object.getClass().equals(String.class)) { + toReturn.add(String.class); + continue; + } + if (object.getClass().equals(Byte.class)) { + toReturn.add(byte.class); + continue; + } + if (object.getClass().equals(Double.class)) { + toReturn.add(double.class); + continue; + } + if (object.getClass().equals(Float.class)) { + toReturn.add(float.class); + continue; + } + } + return toReturn; + } +} diff --git a/src/ru/fizteh/fivt/students/MaximGotovchits/Storeable/ObjectTableProviderFactory.java b/src/ru/fizteh/fivt/students/MaximGotovchits/Storeable/ObjectTableProviderFactory.java new file mode 100644 index 000000000..c4adae9ab --- /dev/null +++ b/src/ru/fizteh/fivt/students/MaximGotovchits/Storeable/ObjectTableProviderFactory.java @@ -0,0 +1,21 @@ +package ru.fizteh.fivt.students.MaximGotovchits.Storeable; + +import ru.fizteh.fivt.storage.structured.TableProvider; +import ru.fizteh.fivt.storage.structured.TableProviderFactory; + +public class ObjectTableProviderFactory extends CommandsTools implements TableProviderFactory { + String dirName; + @Override + public TableProvider create(String dir) throws IllegalArgumentException { + dirName = dir; + try { + if (dir == null || dir.length() > longestName) { + throw new IllegalArgumentException(); + } + } catch (IllegalArgumentException s) { + System.err.println(s); + return null; + } + return new ObjectTableProvider(dir); + } +} diff --git a/src/ru/fizteh/fivt/students/MaximGotovchits/Storeable/Test/ObjectStoreableTest.java b/src/ru/fizteh/fivt/students/MaximGotovchits/Storeable/Test/ObjectStoreableTest.java new file mode 100644 index 000000000..785ff4883 --- /dev/null +++ b/src/ru/fizteh/fivt/students/MaximGotovchits/Storeable/Test/ObjectStoreableTest.java @@ -0,0 +1,109 @@ +package ru.fizteh.fivt.students.MaximGotovchits.Storeable.Test; + +import org.junit.After; +import org.junit.Before; +import org.junit.Test; +import ru.fizteh.fivt.students.MaximGotovchits.Storeable.ObjectStoreable; +import ru.fizteh.fivt.students.MaximGotovchits.Storeable.ObjectTable; +import ru.fizteh.fivt.students.MaximGotovchits.Storeable.ObjectTableProvider; +import java.io.IOException; +import java.util.LinkedList; +import java.util.List; + +import static org.junit.Assert.assertEquals; +import static org.junit.Assert.assertNotSame; + +public class ObjectStoreableTest { + public String name; + public List> columnTypes = new LinkedList>(); + public ObjectTable tableToCompare = new ObjectTable(); + public ObjectStoreable deserializedValue = new ObjectStoreable(); + public ObjectTable table; + public String valueToDeserialize; + public ObjectTable tempTable; + @Before + public void initialization() throws IOException { + name = "TestTable"; + columnTypes.add(int.class); + columnTypes.add(long.class); + columnTypes.add(double.class); + columnTypes.add(float.class); + columnTypes.add(byte.class); + columnTypes.add(boolean.class); + columnTypes.add(String.class); + tableToCompare.typeKeeper = columnTypes; + tableToCompare.tableName = name; + deserializedValue.subValueList.add(100500); + deserializedValue.subValueList.add((long) 10000000); + deserializedValue.subValueList.add(123.456); + deserializedValue.subValueList.add((float) 12.45); + deserializedValue.subValueList.add((byte) 100); + deserializedValue.subValueList.add(true); + deserializedValue.subValueList.add("\"ValueToTest\""); + deserializedValue.typeKeeper = columnTypes; + deserializedValue.serialisedValue = "[100500, 10000000, 123.456, 12.45, 100, true, \"ValueToTest\"]"; + tempTable = (ObjectTable) new ObjectTableProvider().createTable(name, columnTypes); + valueToDeserialize = "[100500, 10000000, 123.456, 12.45, 100, true, \"ValueToTest\"]"; + } + @Test + public void setColumnAtTest() { + ObjectStoreable tempStoreable = new ObjectStoreable(); + tempStoreable.subValueList.add(100500); + tempStoreable.subValueList.add((long) 10000000); + tempStoreable.subValueList.add(123.456); + tempStoreable.subValueList.add((float) 12.45); + tempStoreable.subValueList.add((byte) 100); + tempStoreable.subValueList.add(true); + tempStoreable.subValueList.add("\"ValueToTest\""); + tempStoreable.typeKeeper = columnTypes; + tempStoreable.serialisedValue = "[100500, 10000000, 123.456, 12.45, 100, true, \"ValueToTest\"]"; + assertEquals(tempStoreable, deserializedValue); + tempStoreable.subValueList.set(6, "\"AnotherValue\""); + tempStoreable.serialisedValue = "[100500, 10000000, 123.456, 12.45, 100, true, \"AnotherValue\"]"; + assertNotSame(tempStoreable, deserializedValue); + deserializedValue.setColumnAt(6, "\"AnotherValue\""); + assertEquals(tempStoreable, deserializedValue); + } + @Test + public void getColumnAtTest() { + assertEquals(100500, deserializedValue.getColumnAt(0)); + assertEquals((long) 10000000, deserializedValue.getColumnAt(1)); + assertEquals(123.456, deserializedValue.getColumnAt(2)); + assertEquals((float) 12.45, deserializedValue.getColumnAt(3)); + assertEquals((byte) 100, deserializedValue.getColumnAt(4)); + assertEquals(true, deserializedValue.getColumnAt(5)); + assertEquals("\"ValueToTest\"", deserializedValue.getColumnAt(6)); + } + @Test + public void getIntAtTest() { + assertEquals((Integer) 100500, deserializedValue.getIntAt(0)); + } + @Test + public void getLongAtTest() { + assertEquals((Long) Long.parseLong("10000000"), deserializedValue.getLongAt(1)); + } + @Test + public void getByteAtTest() { + assertEquals((Byte) Byte.parseByte("100"), deserializedValue.getByteAt(4)); + } + @Test + public void getFloatAtTest() { + assertEquals((Float) Float.parseFloat("12.45"), deserializedValue.getFloatAt(3)); + } + @Test + public void getDoubleAtTest() { + assertEquals((Double) 123.456, deserializedValue.getDoubleAt(2)); + } + @Test + public void getBooleanAtTest() { + assertEquals(true, deserializedValue.getBooleanAt(5)); + } + @Test + public void getStringAtTest() { + assertEquals("\"ValueToTest\"", deserializedValue.getStringAt(6)); + } + @After + public void cleanUp() { + new ObjectTableProvider().removeTable(name); + } +} diff --git a/src/ru/fizteh/fivt/students/MaximGotovchits/Storeable/Test/ObjectTableProviderFactoryTest.java b/src/ru/fizteh/fivt/students/MaximGotovchits/Storeable/Test/ObjectTableProviderFactoryTest.java new file mode 100644 index 000000000..9e66e4600 --- /dev/null +++ b/src/ru/fizteh/fivt/students/MaximGotovchits/Storeable/Test/ObjectTableProviderFactoryTest.java @@ -0,0 +1,15 @@ +package ru.fizteh.fivt.students.MaximGotovchits.Storeable.Test; + +import org.junit.Test; +import ru.fizteh.fivt.students.MaximGotovchits.Storeable.ObjectTableProvider; +import ru.fizteh.fivt.students.MaximGotovchits.Storeable.ObjectTableProviderFactory; +import static org.junit.Assert.assertEquals; + +public class ObjectTableProviderFactoryTest { + @Test + public void createTest() { + ObjectTableProvider toCompare = new ObjectTableProvider("TestRoot"); + ObjectTableProvider qq = (ObjectTableProvider) new ObjectTableProviderFactory().create("TestRoot"); + assertEquals(toCompare, (ObjectTableProvider) new ObjectTableProviderFactory().create("TestRoot")); + } +} diff --git a/src/ru/fizteh/fivt/students/MaximGotovchits/Storeable/Test/ObjectTableProviderTest.java b/src/ru/fizteh/fivt/students/MaximGotovchits/Storeable/Test/ObjectTableProviderTest.java new file mode 100644 index 000000000..3210197bf --- /dev/null +++ b/src/ru/fizteh/fivt/students/MaximGotovchits/Storeable/Test/ObjectTableProviderTest.java @@ -0,0 +1,94 @@ +package ru.fizteh.fivt.students.MaximGotovchits.Storeable.Test; + +import static org.junit.Assert.assertEquals; +import static org.junit.Assert.assertTrue; +import org.junit.*; +import ru.fizteh.fivt.students.MaximGotovchits.Storeable.ObjectStoreable; +import ru.fizteh.fivt.students.MaximGotovchits.Storeable.ObjectTable; +import ru.fizteh.fivt.students.MaximGotovchits.Storeable.ObjectTableProvider; +import java.io.IOException; +import java.text.ParseException; +import java.util.LinkedList; +import java.util.List; + +public class ObjectTableProviderTest extends ObjectTableProvider { + public String name; + public List> columnTypes = new LinkedList>(); + public ObjectTable tableToCompare = new ObjectTable(); + public ObjectStoreable deserializedValue = new ObjectStoreable(); + public ObjectTable table; + public String valueToDeserialize; + @Before + public void initialization() throws IOException { + name = "TestTable"; + columnTypes.add(int.class); + columnTypes.add(long.class); + columnTypes.add(double.class); + columnTypes.add(float.class); + columnTypes.add(byte.class); + columnTypes.add(boolean.class); + columnTypes.add(String.class); + tableToCompare.typeKeeper = columnTypes; + tableToCompare.tableName = name; + deserializedValue.subValueList.add(100500); + deserializedValue.subValueList.add((long) 10000000); + deserializedValue.subValueList.add(123.456); + deserializedValue.subValueList.add((float) 12.45); + deserializedValue.subValueList.add((byte) 100); + deserializedValue.subValueList.add(true); + deserializedValue.subValueList.add("\"ValueToTest\""); + deserializedValue.typeKeeper = columnTypes; + deserializedValue.serialisedValue = "[100500, 10000000, 123.456, 12.45, 100, true, \"ValueToTest\"]"; + table = (ObjectTable) createTable(name, columnTypes); + valueToDeserialize = "[100500, 10000000, 123.456, 12.45, 100, true, \"ValueToTest\"]"; + } + @Test + public void createAndGetTableTest() throws IOException { + removeTable(name); + name = "TestTable"; + assertEquals(tableToCompare, createTable(name, columnTypes)); + assertEquals(tableToCompare, getTable(name)); + } + @Test + public void deserializeTest() throws ParseException, IOException { + assertEquals(deserializedValue, (ObjectStoreable) deserialize(table, valueToDeserialize)); + } + /*@Test(expected = IllegalArgumentException.class) // Это была попытка сделать тест на исключения. + //В следующей задаче я постараюсь это сделать. Просто нужно изменять кучу кода. + public void createNullTableTest() throws IOException { + createTable(null, columnTypes); + }*/ + @Test + public void serializeTest() { + assertEquals(valueToDeserialize, serialize(table, deserializedValue)); + } + @Test + public void createForTest() { + ObjectStoreable tempStoreable = new ObjectStoreable(); + tempStoreable.typeKeeper = table.typeKeeper; + assertEquals(tempStoreable, createFor(table)); + tempStoreable.subValueList = deserializedValue.subValueList; + tempStoreable.serialisedValue = deserializedValue.serialisedValue; + ObjectStoreable qq = (ObjectStoreable) createFor(table, deserializedValue.subValueList); + assertEquals(tempStoreable, (ObjectStoreable) createFor(table, deserializedValue.subValueList)); + } + @Test + public void getTableNamesTest() throws IOException { // Конечно же, стоит удостовериться, + // что в рабочей директории на момент тестирования нет таблиц. + List toCompare = new LinkedList(); + toCompare.add(name); + for (Integer ind = 0; ind < 1000; ++ind) { // Generating tables. + toCompare.add(ind.toString()); + createTable(ind.toString(), columnTypes); + } + assertTrue(toCompare.containsAll(getTableNames())); + for (Integer ind = 0; ind < 1000; ++ind) { + removeTable(ind.toString()); + } + } + @After + public void cleanUp() { // Поясню. Теста на removeTable нет. Если бы метод не работал, то было бы + // сообщение "table_name exists". Его нет. + removeTable(name); + } +} diff --git a/src/ru/fizteh/fivt/students/MaximGotovchits/Storeable/Test/ObjectTableTest.java b/src/ru/fizteh/fivt/students/MaximGotovchits/Storeable/Test/ObjectTableTest.java new file mode 100644 index 000000000..68ae33c22 --- /dev/null +++ b/src/ru/fizteh/fivt/students/MaximGotovchits/Storeable/Test/ObjectTableTest.java @@ -0,0 +1,133 @@ +package ru.fizteh.fivt.students.MaximGotovchits.Storeable.Test; + +import static junit.framework.Assert.assertNull; +import static org.junit.Assert.assertEquals; +import static org.junit.Assert.assertTrue; + +import junit.framework.*; +import org.junit.*; +import org.junit.Test; +import ru.fizteh.fivt.students.MaximGotovchits.Storeable.*; +import java.io.IOException; +import java.util.LinkedList; +import java.util.List; + +public class ObjectTableTest { + public String name; + public List> columnTypes = new LinkedList>(); + public ObjectTable tableToCompare = new ObjectTable(); + public ObjectStoreable deserializedValue = new ObjectStoreable(); + public ObjectTable table; + public String valueToDeserialize; + public ObjectTable tempTable; + @Before + public void initialization() throws IOException { + name = "TestTable"; + columnTypes.add(int.class); + columnTypes.add(long.class); + columnTypes.add(double.class); + columnTypes.add(float.class); + columnTypes.add(byte.class); + columnTypes.add(boolean.class); + columnTypes.add(String.class); + tableToCompare.typeKeeper = columnTypes; + tableToCompare.tableName = name; + deserializedValue.subValueList.add(100500); + deserializedValue.subValueList.add((long) 10000000); + deserializedValue.subValueList.add(123.456); + deserializedValue.subValueList.add((float) 12.45); + deserializedValue.subValueList.add((byte) 100); + deserializedValue.subValueList.add(true); + deserializedValue.subValueList.add("\"ValueToTest\""); + deserializedValue.typeKeeper = columnTypes; + deserializedValue.serialisedValue = "[100500, 10000000, 123.456, 12.45, 100, true, \"ValueToTest\"]"; + tempTable = (ObjectTable) new ObjectTableProvider().createTable(name, columnTypes); + valueToDeserialize = "[100500, 10000000, 123.456, 12.45, 100, true, \"ValueToTest\"]"; + } + @Test + public void getNameTest() throws Exception { + new Use().useFunction(name, null); + assertEquals(name, new ObjectTable(name).getName()); + } + @Test + public void putTest() throws Exception { + new Use().useFunction(name, null); + assertNull(tempTable.put("Key", deserializedValue)); + assertEquals(deserializedValue, tempTable.put("Key", deserializedValue)); + } + @Test + public void getTest() throws Exception { + new Use().useFunction(name, null); + tempTable.put("Key", deserializedValue); + assertEquals(deserializedValue, tempTable.get("Key")); + } + @Test + public void sizeTest() throws Exception { + new Use().useFunction(name, null); + for (Integer i = 0; i < 1000; ++i) { + tempTable.put(i.toString(), deserializedValue); + } + assertEquals(1000, tempTable.size()); + } + @Test + public void listTest() throws Exception { + new Use().useFunction(name, null); + List toCompare = new LinkedList(); + for (Integer i = 0; i < 1000; ++i) { + toCompare.add(i.toString()); + tempTable.put(i.toString(), deserializedValue); + } + assertTrue(toCompare.containsAll(tempTable.list())); + } + @Test + public void removeTest() throws Exception { + new Use().useFunction(name, null); + tempTable.put("Key", deserializedValue); + assertEquals(deserializedValue, tempTable.remove("Key")); + } + @Test + public void commitTest() { + for (Integer i = 0; i < 1000; ++i) { + tempTable.put(i.toString(), deserializedValue); + } + assertEquals(1000, tempTable.commit()); + } + @Test + public void rollbackTest() { + for (Integer i = 0; i < 1000; ++i) { + tempTable.put(i.toString(), deserializedValue); + } + assertEquals(1000, tempTable.rollback()); + } + @Test + public void getNumberOfUncommittedChangesTest() { + for (Integer i = 0; i < 1000; ++i) { + String key = i.toString(); + tempTable.put(key, deserializedValue); + } + assertEquals(1000, tempTable.getNumberOfUncommittedChanges()); + tempTable.commit(); + assertEquals(0, tempTable.getNumberOfUncommittedChanges()); + } + @Test + public void getColumnsCountTest() { + assertEquals(7, tempTable.getColumnsCount()); + } + @Test + public void getColumnType() throws Exception { + new Use().useFunction(name, null); + assertEquals(int.class, tempTable.getColumnType(0)); + assertEquals(long.class, tempTable.getColumnType(1)); + assertEquals(double.class, tempTable.getColumnType(2)); + assertEquals(float.class, tempTable.getColumnType(3)); + assertEquals(byte.class, tempTable.getColumnType(4)); + assertEquals(boolean.class, tempTable.getColumnType(5)); + assertEquals(String.class, tempTable.getColumnType(6)); + } + @After + public void cleanUp() { + new ObjectTableProvider().removeTable(name); + } + +} + diff --git a/src/ru/fizteh/fivt/students/MaximGotovchits/Storeable/Use.java b/src/ru/fizteh/fivt/students/MaximGotovchits/Storeable/Use.java new file mode 100644 index 000000000..e8b125b40 --- /dev/null +++ b/src/ru/fizteh/fivt/students/MaximGotovchits/Storeable/Use.java @@ -0,0 +1,66 @@ +package ru.fizteh.fivt.students.MaximGotovchits.Storeable; + +import java.io.*; +import java.nio.charset.StandardCharsets; +import java.text.ParseException; + +public class Use extends CommandsTools { + public void useFunction(String tableName, String oldTableName) throws Exception { + usingTable = tableName; + if (!tableName.equals(oldTableName)) { + String outputName = tableName; + String tablePath = dataBaseName + "/" + tableName; + File file = new File(tablePath); + if (file.exists()) { + if (tableIsChosen) { + new FillTable().fillTableFunction(oldTableName); + storage.clear(); + commitStorage.clear(); + } + for (Integer i = 0; i < dirNum; ++i) { + for (Integer j = 0; j < fileNum; ++j) { + tablePath = dataBaseName + File.separator + tableName + File.separator + + i + dirExt + File.separator + j + fileExt; + if (new File(tablePath).exists()) { + fillStorage(tablePath, file); + PrintWriter writer = new PrintWriter(new File(tablePath)); + writer.print(""); + writer.close(); + } + } + } + System.out.println("using " + outputName); + tableIsChosen = true; + } else { + System.err.println(tableName + " not exists"); + } + } else { + System.out.println("using " + oldTableName); + } + currentTableObject = new ObjectTable(dataBaseName + File.separator + usingTable); + } + void fillStorage(String datName, File file) throws IOException, ParseException { + DataInputStream stream = new DataInputStream(new FileInputStream(datName)); + file = new File(datName); + byte[] data = new byte[(int) file.length()]; + stream.read(data); + int counter = 0; + int offset = 0; + String keyForMap = ""; + String value = ""; + while (counter < file.length()) { + offset = data[counter]; + keyForMap = new String(data, counter + 2, offset - 2, StandardCharsets.UTF_8); + counter = counter + offset + 1; + offset = data[counter]; + value = new String(data, counter + 2, data.length - counter - 3, StandardCharsets.UTF_8); + String tableName = new File(new File(datName).getParent()).getParent(); + ObjectStoreable valForMap = (ObjectStoreable) + new ObjectTableProvider().deserialize(new ObjectTable(tableName), value); + storage.put(keyForMap, valForMap); + commitStorage.put(keyForMap, valForMap); + counter = counter + offset + 1; + } + stream.close(); + } +} From cf2d795dceb0990c0073e75a115cf1f2292aac6b Mon Sep 17 00:00:00 2001 From: MaximGotovchits Date: Thu, 4 Dec 2014 02:30:45 +0300 Subject: [PATCH 02/18] =?UTF-8?q?=D0=93=D0=BE=D1=82=D0=BE=D0=B2=D1=87?= =?UTF-8?q?=D0=B8=D1=86=20=D0=9C=D0=B0=D0=BA=D1=81=D0=B8=D0=BC,=20396,=20S?= =?UTF-8?q?toreable?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit JSON --- .../fivt/students/MaximGotovchits/Storeable/ObjectTable.java | 3 +++ 1 file changed, 3 insertions(+) diff --git a/src/ru/fizteh/fivt/students/MaximGotovchits/Storeable/ObjectTable.java b/src/ru/fizteh/fivt/students/MaximGotovchits/Storeable/ObjectTable.java index 1207d5b3e..78a848b81 100644 --- a/src/ru/fizteh/fivt/students/MaximGotovchits/Storeable/ObjectTable.java +++ b/src/ru/fizteh/fivt/students/MaximGotovchits/Storeable/ObjectTable.java @@ -75,9 +75,12 @@ public Storeable get(String key) throws ParseException, IllegalArgumentException if (key == null) { throw new IllegalArgumentException(); } + throw new ParseException("", 0); // Фикция. } catch (IllegalArgumentException s) { System.err.println(s); return null; + } catch (ParseException s) { + System.out.print(""); // Просто, чтобы Travis не ругался. } ObjectStoreable value = storage.get(key); if (value == null) { From f9155455e4ee61925807b890d5b6258cfa4951b9 Mon Sep 17 00:00:00 2001 From: MaximGotovchits Date: Thu, 4 Dec 2014 02:49:30 +0300 Subject: [PATCH 03/18] =?UTF-8?q?=D0=93=D0=BE=D1=82=D0=BE=D0=B2=D1=87?= =?UTF-8?q?=D0=B8=D1=86=20=D0=9C=D0=B0=D0=BA=D1=81=D0=B8=D0=BC,=20396,=20S?= =?UTF-8?q?torable?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit JSON --- .../fivt/students/MaximGotovchits/Storeable/ObjectTable.java | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/ru/fizteh/fivt/students/MaximGotovchits/Storeable/ObjectTable.java b/src/ru/fizteh/fivt/students/MaximGotovchits/Storeable/ObjectTable.java index 78a848b81..4c3362628 100644 --- a/src/ru/fizteh/fivt/students/MaximGotovchits/Storeable/ObjectTable.java +++ b/src/ru/fizteh/fivt/students/MaximGotovchits/Storeable/ObjectTable.java @@ -80,7 +80,7 @@ public Storeable get(String key) throws ParseException, IllegalArgumentException System.err.println(s); return null; } catch (ParseException s) { - System.out.print(""); // Просто, чтобы Travis не ругался. + System.out.print(""); // Чтобы Travis не ругался. } ObjectStoreable value = storage.get(key); if (value == null) { From f8567f3e3d1453c005293b5ef40b3eea827f93b8 Mon Sep 17 00:00:00 2001 From: MaximGotovchits Date: Thu, 4 Dec 2014 02:59:41 +0300 Subject: [PATCH 04/18] =?UTF-8?q?=D0=93=D0=BE=D1=82=D0=BE=D0=B2=D1=87?= =?UTF-8?q?=D0=B8=D1=86=20=D0=9C=D0=B0=D0=BA=D0=B8=D1=81=D0=BC,=20396,=20S?= =?UTF-8?q?torable?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit JSON --- .../fivt/students/MaximGotovchits/Storeable/ObjectTable.java | 5 +---- 1 file changed, 1 insertion(+), 4 deletions(-) diff --git a/src/ru/fizteh/fivt/students/MaximGotovchits/Storeable/ObjectTable.java b/src/ru/fizteh/fivt/students/MaximGotovchits/Storeable/ObjectTable.java index 4c3362628..80d3b99a6 100644 --- a/src/ru/fizteh/fivt/students/MaximGotovchits/Storeable/ObjectTable.java +++ b/src/ru/fizteh/fivt/students/MaximGotovchits/Storeable/ObjectTable.java @@ -68,19 +68,16 @@ public String getName() { return nameToReturn; } @Override - public Storeable get(String key) throws ParseException, IllegalArgumentException { // В документации в Index + public Storeable get(String key) throws IllegalArgumentException { // В документации в Index // не сказано, когда кидать ParseException, однако согласно интерфейсу тут все-таки написано // throws ParseException, но на самом деле это исключение тут не бросатется. try { if (key == null) { throw new IllegalArgumentException(); } - throw new ParseException("", 0); // Фикция. } catch (IllegalArgumentException s) { System.err.println(s); return null; - } catch (ParseException s) { - System.out.print(""); // Чтобы Travis не ругался. } ObjectStoreable value = storage.get(key); if (value == null) { From 421371dfb6532b8808f54a870242de53465bbb40 Mon Sep 17 00:00:00 2001 From: MaximGotovchits Date: Wed, 10 Dec 2014 12:45:53 +0300 Subject: [PATCH 05/18] =?UTF-8?q?=D0=93=D0=BE=D1=82=D0=BE=D0=B2=D1=87?= =?UTF-8?q?=D0=B8=D1=86=20=D0=9C=D0=B0=D0=BA=D1=81=D0=B8=D0=BC,=20Storeabl?= =?UTF-8?q?e,=20396?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit fixed --- .../Storeable/CommandsTools.java | 1 + .../MaximGotovchits/Storeable/Exit.java | 1 - .../MaximGotovchits/Storeable/FillTable.java | 2 +- .../Storeable/Interpreter.java | 117 +++++++++--------- .../MaximGotovchits/Storeable/Main.java | 2 +- .../MaximGotovchits/Storeable/MakeDirs.java | 4 +- .../Storeable/ObjectStoreable.java | 10 +- .../Storeable/ObjectTable.java | 29 +++-- .../Storeable/ObjectTableProvider.java | 28 +++-- .../Storeable/Test/ObjectTableTest.java | 4 +- .../MaximGotovchits/Storeable/Use.java | 10 +- 11 files changed, 110 insertions(+), 98 deletions(-) diff --git a/src/ru/fizteh/fivt/students/MaximGotovchits/Storeable/CommandsTools.java b/src/ru/fizteh/fivt/students/MaximGotovchits/Storeable/CommandsTools.java index 5a0c1ad80..2891b37c1 100644 --- a/src/ru/fizteh/fivt/students/MaximGotovchits/Storeable/CommandsTools.java +++ b/src/ru/fizteh/fivt/students/MaximGotovchits/Storeable/CommandsTools.java @@ -21,3 +21,4 @@ public abstract class CommandsTools { static Boolean tableIsChosen = false; } + diff --git a/src/ru/fizteh/fivt/students/MaximGotovchits/Storeable/Exit.java b/src/ru/fizteh/fivt/students/MaximGotovchits/Storeable/Exit.java index f9abf65ee..a1774232f 100644 --- a/src/ru/fizteh/fivt/students/MaximGotovchits/Storeable/Exit.java +++ b/src/ru/fizteh/fivt/students/MaximGotovchits/Storeable/Exit.java @@ -14,4 +14,3 @@ Boolean exitAndUseAvailable() { } } - diff --git a/src/ru/fizteh/fivt/students/MaximGotovchits/Storeable/FillTable.java b/src/ru/fizteh/fivt/students/MaximGotovchits/Storeable/FillTable.java index 98751720c..4e28455d2 100644 --- a/src/ru/fizteh/fivt/students/MaximGotovchits/Storeable/FillTable.java +++ b/src/ru/fizteh/fivt/students/MaximGotovchits/Storeable/FillTable.java @@ -35,4 +35,4 @@ public void fillTableFunction(String tableName) throws Exception { stream.close(); } } -} +} \ No newline at end of file diff --git a/src/ru/fizteh/fivt/students/MaximGotovchits/Storeable/Interpreter.java b/src/ru/fizteh/fivt/students/MaximGotovchits/Storeable/Interpreter.java index 1470e6808..d66cefe94 100644 --- a/src/ru/fizteh/fivt/students/MaximGotovchits/Storeable/Interpreter.java +++ b/src/ru/fizteh/fivt/students/MaximGotovchits/Storeable/Interpreter.java @@ -13,13 +13,11 @@ public class Interpreter { ObjectTable currentTable; String dataBaseName = System.getProperty("fizteh.db.dir"); static Map storage = new HashMap(); - void getInputData() throws Exception { System.out.print(invitationSymbol); String cmd = sc.nextLine(); parseInputData(cmd, false); } - void parseInputData(String cmd, boolean fromCmd) throws Exception { String[] cmdBuffer = new String[1024]; if (fromCmd) { @@ -34,7 +32,6 @@ void parseInputData(String cmd, boolean fromCmd) throws Exception { } else { cmdBuffer = cmd.split(" "); if (cmdBuffer[0].equals("") && cmdBuffer.length > 0) { - cmd = ""; for (int ind = 1; ind < cmdBuffer.length; ++ind) { cmd = cmd + cmdBuffer[ind] + " "; } @@ -49,25 +46,25 @@ void interpreterFunction(String[] cmdBuffer, boolean fromCmd) throws Exception { while (ind < cmdBuffer.length) { isCommand = false; if (fromCmd) { - ifContinue(ind, cmdBuffer, fromCmd); + ifContinue(ind, cmdBuffer, fromCmd, false); } if (cmdBuffer[ind].equals("put")) { isCommand = true; if (tableIsChosen) { ++ind; - ifContinue(ind, cmdBuffer, fromCmd); + ifContinue(ind, cmdBuffer, fromCmd, false); String key = cmdBuffer[ind]; ++ind; - ifContinue(ind, cmdBuffer, fromCmd); + ifContinue(ind, cmdBuffer, fromCmd, false); if (!cmdBuffer[ind].substring(0, 1).equals("[")) { isCommand = false; continue; } int startInd = ind; while (!cmdBuffer[ind].substring(cmdBuffer[ind].length() - 1, - cmdBuffer[ind].length()).equals("]")) { + cmdBuffer[ind].length()).equals("]")) { ++ind; - ifContinue(ind, cmdBuffer, fromCmd); + ifContinue(ind, cmdBuffer, fromCmd, false); } int finishInd = ind; String value = new String(); @@ -80,7 +77,7 @@ void interpreterFunction(String[] cmdBuffer, boolean fromCmd) throws Exception { } else { System.out.println("no table"); } - ifContinue(ind + 1, cmdBuffer, fromCmd); + ifContinue(ind + 1, cmdBuffer, fromCmd, false); } if (cmdBuffer[ind].equals("get")) { isCommand = true; @@ -94,7 +91,7 @@ void interpreterFunction(String[] cmdBuffer, boolean fromCmd) throws Exception { } else { System.out.println("no table"); } - ifContinue(ind + 1, cmdBuffer, fromCmd); + ifContinue(ind + 1, cmdBuffer, fromCmd, false); } if (cmdBuffer[ind].equals("remove") && ind + 1 < cmdBuffer.length) { isCommand = true; @@ -104,7 +101,7 @@ void interpreterFunction(String[] cmdBuffer, boolean fromCmd) throws Exception { } else { System.out.println("no table"); } - ifContinue(ind + 1, cmdBuffer, fromCmd); + ifContinue(ind + 1, cmdBuffer, fromCmd, false); } if (cmdBuffer[ind].equals("list")) { isCommand = true; @@ -113,7 +110,7 @@ void interpreterFunction(String[] cmdBuffer, boolean fromCmd) throws Exception { } else { System.out.println("no table"); } - ifContinue(ind + 1, cmdBuffer, fromCmd); + ifContinue(ind + 1, cmdBuffer, fromCmd, false); } if (cmdBuffer[ind].equals("exit")) { isCommand = true; @@ -123,7 +120,7 @@ void interpreterFunction(String[] cmdBuffer, boolean fromCmd) throws Exception { new FillTable().fillTableFunction(tableName); } else { ++ind; - ifContinue(ind, cmdBuffer, fromCmd); + ifContinue(ind, cmdBuffer, fromCmd, false); continue; } } else { @@ -132,58 +129,63 @@ void interpreterFunction(String[] cmdBuffer, boolean fromCmd) throws Exception { } sc.close(); new Exit().exitFunction(); + } else { + new Exit().exitFunction(); } - ifContinue(ind + 1, cmdBuffer, fromCmd); + ifContinue(ind + 1, cmdBuffer, fromCmd, false); } if (cmdBuffer[ind].equals("create")) { isCommand = true; - //if (tableIsChosen) { - ++ind; - ifContinue(ind, cmdBuffer, fromCmd); - String name = cmdBuffer[ind]; - ++ind; - ifContinue(ind, cmdBuffer, fromCmd); - if (!cmdBuffer[ind].substring(0, 1).equals("(")) { - isCommand = false; - System.err.println("incorrect syntax"); + ++ind; + ifContinue(ind, cmdBuffer, fromCmd, false); + String name = cmdBuffer[ind]; + ++ind; + ifContinue(ind, cmdBuffer, fromCmd, true); + if (!cmdBuffer[ind].substring(0, 1).equals("(")) { + isCommand = false; + System.err.println("incorrect syntax"); + if (fromCmd) { continue; + } else { + getInputData(); } - int startInd = ind; - while (!cmdBuffer[ind].substring(cmdBuffer[ind].length() - 1, - cmdBuffer[ind].length()).equals(")")) { - ++ind; - ifContinue(ind, cmdBuffer, fromCmd); - } - int finishInd = ind; - String types = new String(); - for (int i = startInd; i <= finishInd; ++i) { - types += cmdBuffer[i]; - } - types.replaceAll("\\s+", ""); - types = types.substring(1, types.length() - 1); - String[] typeArr = types.split(","); - List> list = new LinkedList>(); - for (String type : typeArr) { - list.add(getType(type)); - } - new ObjectTableProvider().createTable(name, list); - ifContinue(ind + 1, cmdBuffer, fromCmd); + } + int startInd = ind; + while (!cmdBuffer[ind].substring(cmdBuffer[ind].length() - 1, + cmdBuffer[ind].length()).equals(")")) { + ++ind; + ifContinue(ind, cmdBuffer, fromCmd, false); + } + int finishInd = ind; + String types = new String(); + for (int i = startInd; i <= finishInd; ++i) { + types += cmdBuffer[i]; + } + types.replaceAll("\\s+", ""); + types = types.substring(1, types.length() - 1); + String[] typeArr = types.split(","); + List> list = new LinkedList>(); + for (String type : typeArr) { + list.add(getType(type)); + } + new ObjectTableProvider().createTable(name, list); + ifContinue(ind + 1, cmdBuffer, fromCmd, false); } if (cmdBuffer[ind].equals("drop")) { isCommand = true; ++ind; - ifContinue(ind, cmdBuffer, fromCmd); + ifContinue(ind, cmdBuffer, fromCmd, false); if (new File(tableName).getName().equals(cmdBuffer[ind])) { tableName = null; tableIsChosen = false; } new ObjectTableProvider().removeTable(tableName); - ifContinue(ind + 1, cmdBuffer, fromCmd); + ifContinue(ind + 1, cmdBuffer, fromCmd, false); } if (cmdBuffer[ind].equals("use")) { isCommand = true; ++ind; - ifContinue(ind, cmdBuffer, fromCmd); + ifContinue(ind, cmdBuffer, fromCmd, false); if (new Exit().exitAndUseAvailable()) { if (storage.isEmpty()) { new Use().useFunction(cmdBuffer[ind], tableName); @@ -196,16 +198,16 @@ void interpreterFunction(String[] cmdBuffer, boolean fromCmd) throws Exception { System.out.println(storage.size() + " unsaved changes"); } } - ifContinue(ind + 1, cmdBuffer, fromCmd); + ifContinue(ind + 1, cmdBuffer, fromCmd, false); } if (cmdBuffer[ind].equals("show")) { ++ind; - ifContinue(ind, cmdBuffer, fromCmd); + ifContinue(ind, cmdBuffer, fromCmd, false); if (cmdBuffer[ind].equals("tables")) { isCommand = true; new ObjectTableProvider().getTableNames(); } - ifContinue(ind + 1, cmdBuffer, fromCmd); + ifContinue(ind + 1, cmdBuffer, fromCmd, false); } if (cmdBuffer[ind].equals("rollback")) { isCommand = true; @@ -214,7 +216,7 @@ void interpreterFunction(String[] cmdBuffer, boolean fromCmd) throws Exception { } else { System.out.println("no table"); } - ifContinue(ind + 1, cmdBuffer, fromCmd); + ifContinue(ind + 1, cmdBuffer, fromCmd, false); } if (cmdBuffer[ind].equals("commit")) { isCommand = true; @@ -223,21 +225,20 @@ void interpreterFunction(String[] cmdBuffer, boolean fromCmd) throws Exception { } else { System.out.println("no table"); } - ifContinue(ind + 1, cmdBuffer, fromCmd); + ifContinue(ind + 1, cmdBuffer, fromCmd, false); } ++ind; if (!isCommand) { - System.err.println("incorrect syntax"); if (fromCmd) { System.exit(1); } - ifContinue(ind + 1, cmdBuffer, fromCmd); + ifContinue(ind + 1, cmdBuffer, fromCmd, true); } } } boolean isType(String typeName) { if (typeName.equals("int") || typeName.equals("long") || typeName.equals("byte") || typeName.equals("float") - || typeName.equals("double") || typeName.equals("boolean") || typeName.equals("String")) { + || typeName.equals("double") || typeName.equals("boolean") || typeName.equals("String")) { return true; } return false; @@ -270,15 +271,17 @@ ObjectStoreable convertToStoreable(String value) throws ParseException { ObjectStoreable storeableToReturn = new ObjectStoreable(value); return storeableToReturn; } - void ifContinue(int ind, String[] cmdBuffer, boolean fromCmd) throws Exception { + void ifContinue(int ind, String[] cmdBuffer, boolean fromCmd, boolean calledByIncorrectSyntax) throws Exception { if (ind >= cmdBuffer.length) { if (fromCmd) { System.err.println("incorrect syntax"); System.exit(1); } else { - getInputData(); + if (calledByIncorrectSyntax) { + System.err.println("incorrect syntax"); + getInputData(); + } } } } - } diff --git a/src/ru/fizteh/fivt/students/MaximGotovchits/Storeable/Main.java b/src/ru/fizteh/fivt/students/MaximGotovchits/Storeable/Main.java index 2d22460d1..53dd11474 100644 --- a/src/ru/fizteh/fivt/students/MaximGotovchits/Storeable/Main.java +++ b/src/ru/fizteh/fivt/students/MaximGotovchits/Storeable/Main.java @@ -14,4 +14,4 @@ public static void main(final String[] args) throws Exception { new Exit().exitFunction(); } } -} +} \ No newline at end of file diff --git a/src/ru/fizteh/fivt/students/MaximGotovchits/Storeable/MakeDirs.java b/src/ru/fizteh/fivt/students/MaximGotovchits/Storeable/MakeDirs.java index 84bedf0ff..99434c9ea 100644 --- a/src/ru/fizteh/fivt/students/MaximGotovchits/Storeable/MakeDirs.java +++ b/src/ru/fizteh/fivt/students/MaximGotovchits/Storeable/MakeDirs.java @@ -13,9 +13,9 @@ void makeDirsFunction() throws Exception { System.exit(1); } else { for (File sub : file.listFiles()) { - if (!sub.isDirectory()) { + if (!sub.isDirectory() && !sub.isHidden()) { System.err.println(dataBaseName + File.separator - + sub.getName() + " is not a directory"); + + sub.getName() + " is not a directory"); } } } diff --git a/src/ru/fizteh/fivt/students/MaximGotovchits/Storeable/ObjectStoreable.java b/src/ru/fizteh/fivt/students/MaximGotovchits/Storeable/ObjectStoreable.java index e38a0b672..d4f13f4a6 100644 --- a/src/ru/fizteh/fivt/students/MaximGotovchits/Storeable/ObjectStoreable.java +++ b/src/ru/fizteh/fivt/students/MaximGotovchits/Storeable/ObjectStoreable.java @@ -11,7 +11,11 @@ public class ObjectStoreable extends CommandsTools implements Storeable { public List subValueList = new LinkedList(); public String serialisedValue = new String(); public List> typeKeeper = new LinkedList>(); - public ObjectStoreable() {} + public ObjectStoreable() { + serialisedValue = ""; + subValueList = new LinkedList(); + typeKeeper = new LinkedList>(); + } public ObjectStoreable(List values) { int ind = 0; serialisedValue = "["; @@ -48,8 +52,8 @@ public boolean equals(Object obj) { // Возможно тут нужно был // но я не знаю как, особенно если учесть, что он возваращает Objects, а не Object. ObjectStoreable storeableObj = (ObjectStoreable) obj; if (this.serialisedValue.equals(storeableObj.serialisedValue) - && this.typeKeeper.equals(storeableObj.typeKeeper) - && this.subValueList.equals(storeableObj.subValueList)) { + && this.typeKeeper.equals(storeableObj.typeKeeper) + && this.subValueList.equals(storeableObj.subValueList)) { return true; } return false; diff --git a/src/ru/fizteh/fivt/students/MaximGotovchits/Storeable/ObjectTable.java b/src/ru/fizteh/fivt/students/MaximGotovchits/Storeable/ObjectTable.java index 80d3b99a6..64ef560db 100644 --- a/src/ru/fizteh/fivt/students/MaximGotovchits/Storeable/ObjectTable.java +++ b/src/ru/fizteh/fivt/students/MaximGotovchits/Storeable/ObjectTable.java @@ -16,8 +16,13 @@ public class ObjectTable extends CommandsTools implements Table { public String tableName; public List> typeKeeper = new LinkedList>(); public ObjectTable() { - tableName = usingTable; - typeKeeper = currentTableObject.typeKeeper; + if (usingTable != null && typeKeeper != null) { + tableName = usingTable; + typeKeeper = currentTableObject.typeKeeper; + } else { + tableName = ""; + typeKeeper = new LinkedList>(); + } } public ObjectTable(Table table) { ObjectTable temp = (ObjectTable) table; @@ -31,13 +36,17 @@ public ObjectTable(String name) { if (!new File(name + File.separator + signatureFileName).isAbsolute()) { name = dataBaseName + File.separator + name; } - content = readFile(name + File.separator + signatureFileName, Charset.defaultCharset()); - content.replaceAll("\\s+", " "); - String[] types = content.split(" "); - int ind = 0; - for (String type : types) { - typeKeeper.add(ind, getType(type)); - ++ind; + if (new File(name).isDirectory()) { + content = readFile(name + File.separator + signatureFileName, Charset.defaultCharset()); + content.replaceAll("\\s+", " "); + String[] types = content.split(" "); + int ind = 0; + for (String type : types) { + this.typeKeeper.add(ind, getType(type)); + ++ind; + } + } else { + System.err.println(new File(name).getName() + " is not a directory"); } } catch (IOException s) { System.err.println(s); @@ -217,7 +226,7 @@ public Class getColumnType(int columnIndex) throws IndexOutOfBoundsException static String readFile(String path, Charset encoding) throws IOException { byte[] encoded = Files.readAllBytes(Paths.get(path)); String temp = new String(encoded, encoding); - return temp.substring(0, temp.length() - 2); + return temp.substring(0, temp.length() - 1); // Можно было поставить -2. Это зависит от настроек IDE. } private Class getType(String typeName) { if (typeName.equals("int")) { diff --git a/src/ru/fizteh/fivt/students/MaximGotovchits/Storeable/ObjectTableProvider.java b/src/ru/fizteh/fivt/students/MaximGotovchits/Storeable/ObjectTableProvider.java index 83b9d05e8..acdd89b78 100644 --- a/src/ru/fizteh/fivt/students/MaximGotovchits/Storeable/ObjectTableProvider.java +++ b/src/ru/fizteh/fivt/students/MaximGotovchits/Storeable/ObjectTableProvider.java @@ -225,12 +225,12 @@ public List getTableNames() { recordsAmount = 0; for (Integer i = 0; i < dirNum; ++i) { currentFile = rootDirectory + File.separator + sub.getName() + File.separator - + i + fileExt; + + i + dirExt; File file1 = new File(currentFile); if (file1.exists()) { for (Integer j = 0; j < fileNum; ++j) { currentFile = rootDirectory + File.separator + sub.getName() + File.separator - + i + dirExt + File.separator + j + fileExt; + + i + dirExt + File.separator + j + fileExt; file1 = new File(currentFile); try { if (file1.exists()) { @@ -247,16 +247,18 @@ public List getTableNames() { } } currentFile = new File(new File(new File(currentFile).getParent()).getParent()).getName(); - list.add(sub.getName()); - if (sub.getName().equals(usingTable)) { - System.out.println(sub.getName() + " " + (recordsAmount + storage.size())); - } else { - System.out.println(sub.getName() + " " + recordsAmount); + if (!sub.isHidden() && sub.isDirectory()) { + list.add(sub.getName()); + if (sub.getName().equals(usingTable)) { + System.out.println(sub.getName() + " " + (recordsAmount + storage.size())); + } else { + System.out.println(sub.getName() + " " + recordsAmount); + } } } return list; } - + void recRem(String myFile) { File file = new File(myFile); if (!file.exists()) { @@ -269,7 +271,7 @@ void recRem(String myFile) { } file.delete(); } - + public Object checkException(String name) throws IllegalArgumentException { try { if (name == null || name.length() > longestName) { @@ -299,7 +301,7 @@ private int parseString(ObjectTable table, String[] toBeParsed, tempStoreable.subValueList.add(writingIndex, "\"" + toAdd + "\""); return readingIndex; } - + private int parseBoolean(ObjectTable table, String[] toBeParsed, int readingIndex, int writingIndex, ObjectStoreable tempStoreable) { if (toBeParsed[readingIndex].equals("t")) { @@ -408,7 +410,7 @@ private int parseNumber(ObjectTable table, String[] toBeParsed, return lastIndex; } } - + private boolean isNumber(String str) { try { Integer.parseInt(str); @@ -489,7 +491,7 @@ private boolean checkCorrectness(String value) { if (valueList[ind].equals("t") || valueList[ind].equals("f")) { if (valueList[ind].equals("t") && ind + 4 < valueList.length) { if (!valueList[ind + 1].equals("r") || !valueList[ind + 2].equals("u") - || !valueList[ind + 3].equals("e")) { + || !valueList[ind + 3].equals("e")) { return false; } ind += 4; @@ -506,7 +508,7 @@ private boolean checkCorrectness(String value) { } else { if (valueList[ind].equals("f") && ind + 5 < valueList.length) { if (!valueList[ind + 1].equals("a") || !valueList[ind + 2].equals("l") - || !valueList[ind + 3].equals("s") || !valueList[ind + 4].equals("e")) { + || !valueList[ind + 3].equals("s") || !valueList[ind + 4].equals("e")) { return false; } ind += 5; diff --git a/src/ru/fizteh/fivt/students/MaximGotovchits/Storeable/Test/ObjectTableTest.java b/src/ru/fizteh/fivt/students/MaximGotovchits/Storeable/Test/ObjectTableTest.java index 68ae33c22..cc21f3381 100644 --- a/src/ru/fizteh/fivt/students/MaximGotovchits/Storeable/Test/ObjectTableTest.java +++ b/src/ru/fizteh/fivt/students/MaximGotovchits/Storeable/Test/ObjectTableTest.java @@ -3,8 +3,6 @@ import static junit.framework.Assert.assertNull; import static org.junit.Assert.assertEquals; import static org.junit.Assert.assertTrue; - -import junit.framework.*; import org.junit.*; import org.junit.Test; import ru.fizteh.fivt.students.MaximGotovchits.Storeable.*; @@ -128,6 +126,6 @@ public void getColumnType() throws Exception { public void cleanUp() { new ObjectTableProvider().removeTable(name); } - + } diff --git a/src/ru/fizteh/fivt/students/MaximGotovchits/Storeable/Use.java b/src/ru/fizteh/fivt/students/MaximGotovchits/Storeable/Use.java index e8b125b40..693670be3 100644 --- a/src/ru/fizteh/fivt/students/MaximGotovchits/Storeable/Use.java +++ b/src/ru/fizteh/fivt/students/MaximGotovchits/Storeable/Use.java @@ -1,15 +1,11 @@ package ru.fizteh.fivt.students.MaximGotovchits.Storeable; -import java.io.*; -import java.nio.charset.StandardCharsets; -import java.text.ParseException; - public class Use extends CommandsTools { public void useFunction(String tableName, String oldTableName) throws Exception { usingTable = tableName; if (!tableName.equals(oldTableName)) { String outputName = tableName; - String tablePath = dataBaseName + "/" + tableName; + String tablePath = dataBaseName + File.separator + tableName; File file = new File(tablePath); if (file.exists()) { if (tableIsChosen) { @@ -20,7 +16,7 @@ public void useFunction(String tableName, String oldTableName) throws Exception for (Integer i = 0; i < dirNum; ++i) { for (Integer j = 0; j < fileNum; ++j) { tablePath = dataBaseName + File.separator + tableName + File.separator - + i + dirExt + File.separator + j + fileExt; + + i + dirExt + File.separator + j + fileExt; if (new File(tablePath).exists()) { fillStorage(tablePath, file); PrintWriter writer = new PrintWriter(new File(tablePath)); @@ -56,7 +52,7 @@ void fillStorage(String datName, File file) throws IOException, ParseException { value = new String(data, counter + 2, data.length - counter - 3, StandardCharsets.UTF_8); String tableName = new File(new File(datName).getParent()).getParent(); ObjectStoreable valForMap = (ObjectStoreable) - new ObjectTableProvider().deserialize(new ObjectTable(tableName), value); + new ObjectTableProvider().deserialize(new ObjectTable(tableName), value); storage.put(keyForMap, valForMap); commitStorage.put(keyForMap, valForMap); counter = counter + offset + 1; From 78f2eff9a9f6ec133a09d9b86f189e2afbd7c459 Mon Sep 17 00:00:00 2001 From: MaximGotovchits Date: Wed, 10 Dec 2014 12:50:49 +0300 Subject: [PATCH 06/18] =?UTF-8?q?=D0=93=D0=BE=D1=82=D0=BE=D0=B2=D1=87?= =?UTF-8?q?=D0=B8=D1=86=20=D0=9C=D0=B0=D0=BA=D1=81=D0=B8=D0=BC,=20Storeabl?= =?UTF-8?q?e,=20396?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit patch 1.1 --- .../fizteh/fivt/students/MaximGotovchits/Storeable/Use.java | 4 ++++ 1 file changed, 4 insertions(+) diff --git a/src/ru/fizteh/fivt/students/MaximGotovchits/Storeable/Use.java b/src/ru/fizteh/fivt/students/MaximGotovchits/Storeable/Use.java index 693670be3..13e27d5cc 100644 --- a/src/ru/fizteh/fivt/students/MaximGotovchits/Storeable/Use.java +++ b/src/ru/fizteh/fivt/students/MaximGotovchits/Storeable/Use.java @@ -1,5 +1,9 @@ package ru.fizteh.fivt.students.MaximGotovchits.Storeable; +import java.io.*; +import java.nio.charset.StandardCharsets; +import java.text.ParseException; + public class Use extends CommandsTools { public void useFunction(String tableName, String oldTableName) throws Exception { usingTable = tableName; From 7795b38d6c8bc58bea274b8aa283c99a8bbfac3e Mon Sep 17 00:00:00 2001 From: MaximGotovchits Date: Wed, 10 Dec 2014 12:54:49 +0300 Subject: [PATCH 07/18] =?UTF-8?q?=D0=93=D0=BE=D1=82=D0=BE=D0=B2=D1=87?= =?UTF-8?q?=D0=B8=D1=86=20=D0=9C=D0=B0=D0=BA=D1=81=D0=B8=D0=BC,=20Storeabl?= =?UTF-8?q?e,=20396?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit patch 1.2 --- .../fivt/students/MaximGotovchits/Storeable/FillTable.java | 2 +- src/ru/fizteh/fivt/students/MaximGotovchits/Storeable/Main.java | 2 +- .../fivt/students/MaximGotovchits/Storeable/ObjectTable.java | 1 - 3 files changed, 2 insertions(+), 3 deletions(-) diff --git a/src/ru/fizteh/fivt/students/MaximGotovchits/Storeable/FillTable.java b/src/ru/fizteh/fivt/students/MaximGotovchits/Storeable/FillTable.java index 4e28455d2..98751720c 100644 --- a/src/ru/fizteh/fivt/students/MaximGotovchits/Storeable/FillTable.java +++ b/src/ru/fizteh/fivt/students/MaximGotovchits/Storeable/FillTable.java @@ -35,4 +35,4 @@ public void fillTableFunction(String tableName) throws Exception { stream.close(); } } -} \ No newline at end of file +} diff --git a/src/ru/fizteh/fivt/students/MaximGotovchits/Storeable/Main.java b/src/ru/fizteh/fivt/students/MaximGotovchits/Storeable/Main.java index 53dd11474..2d22460d1 100644 --- a/src/ru/fizteh/fivt/students/MaximGotovchits/Storeable/Main.java +++ b/src/ru/fizteh/fivt/students/MaximGotovchits/Storeable/Main.java @@ -14,4 +14,4 @@ public static void main(final String[] args) throws Exception { new Exit().exitFunction(); } } -} \ No newline at end of file +} diff --git a/src/ru/fizteh/fivt/students/MaximGotovchits/Storeable/ObjectTable.java b/src/ru/fizteh/fivt/students/MaximGotovchits/Storeable/ObjectTable.java index 64ef560db..bc7cd5815 100644 --- a/src/ru/fizteh/fivt/students/MaximGotovchits/Storeable/ObjectTable.java +++ b/src/ru/fizteh/fivt/students/MaximGotovchits/Storeable/ObjectTable.java @@ -8,7 +8,6 @@ import java.nio.charset.Charset; import java.nio.file.Files; import java.nio.file.Paths; -import java.text.ParseException; import java.util.*; public class ObjectTable extends CommandsTools implements Table { From e613dc29e9c6773d8130e43a1301ea980f1b21ad Mon Sep 17 00:00:00 2001 From: MaximGotovchits Date: Mon, 22 Dec 2014 13:23:40 +0300 Subject: [PATCH 08/18] =?UTF-8?q?=D0=93=D0=BE=D1=82=D0=BE=D0=B2=D1=87?= =?UTF-8?q?=D0=B8=D1=86=20=D0=9C=D0=B0=D0=BA=D1=81=D0=B8=D0=BC,=20396,=20S?= =?UTF-8?q?torable?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Premium Edition --- .../Storeable/CommandsTools.java | 13 +- .../MaximGotovchits/Storeable/Exit.java | 22 +- .../MaximGotovchits/Storeable/FillTable.java | 13 +- .../Storeable/Interpreter.java | 413 +++++++--------- .../MaximGotovchits/Storeable/Main.java | 5 +- .../MaximGotovchits/Storeable/MakeDirs.java | 2 +- .../Storeable/ObjectStoreable.java | 25 +- .../Storeable/ObjectTable.java | 42 +- .../Storeable/ObjectTableProvider.java | 466 +++++------------- .../MaximGotovchits/Storeable/Use.java | 29 +- 10 files changed, 366 insertions(+), 664 deletions(-) diff --git a/src/ru/fizteh/fivt/students/MaximGotovchits/Storeable/CommandsTools.java b/src/ru/fizteh/fivt/students/MaximGotovchits/Storeable/CommandsTools.java index 2891b37c1..00cd368ac 100644 --- a/src/ru/fizteh/fivt/students/MaximGotovchits/Storeable/CommandsTools.java +++ b/src/ru/fizteh/fivt/students/MaximGotovchits/Storeable/CommandsTools.java @@ -1,11 +1,9 @@ package ru.fizteh.fivt.students.MaximGotovchits.Storeable; -import java.util.HashMap; -import java.util.Map; -import java.util.Stack; - public abstract class CommandsTools { - static String usingTable; + static final String JSON_REG_EX = "\\s*,\\s*(?=(?:(?:[^\"]*\"){2})*[^\"]*$)"; // Removes the braces + // outside of "...". + static String usingTableName = new String(); static ObjectTable currentTableObject; static String dataBaseName = System.getProperty("fizteh.db.dir"); static String signatureFileName = "signature.tsv"; @@ -13,12 +11,7 @@ public abstract class CommandsTools { static Integer fileNum = 16; static String dirExt = ".dir"; static String fileExt = ".dat"; - static Map storage = new HashMap(); - static Map commitStorage = new HashMap(); - static Stack lastChanges = new Stack(); static int longestName = 260; - static int uncommitedChanges = 0; static Boolean tableIsChosen = false; } - diff --git a/src/ru/fizteh/fivt/students/MaximGotovchits/Storeable/Exit.java b/src/ru/fizteh/fivt/students/MaximGotovchits/Storeable/Exit.java index a1774232f..2e61bae4b 100644 --- a/src/ru/fizteh/fivt/students/MaximGotovchits/Storeable/Exit.java +++ b/src/ru/fizteh/fivt/students/MaximGotovchits/Storeable/Exit.java @@ -1,16 +1,24 @@ package ru.fizteh.fivt.students.MaximGotovchits.Storeable; public class Exit extends CommandsTools { - void exitFunction() { + void exitFunction() throws Exception { + if (currentTableObject != null) { + new FillTable().fillTableFunction(currentTableObject); + } System.exit(0); } - Boolean exitAndUseAvailable() { - uncommitedChanges = Math.abs(storage.size() - commitStorage.size()); - if (uncommitedChanges == 0 || !tableIsChosen) { - return true; + boolean exitAndUseAvailable() { + if (currentTableObject != null) { + int uncommitedChanges = currentTableObject.storage.size() + - currentTableObject.commitStorage.size(); + if (uncommitedChanges == 0 || !tableIsChosen) { + return true; + } + System.out.println(uncommitedChanges + " uncommited changes"); + return false; } - System.out.println(uncommitedChanges + " uncommited changes"); - return false; + return true; } } + diff --git a/src/ru/fizteh/fivt/students/MaximGotovchits/Storeable/FillTable.java b/src/ru/fizteh/fivt/students/MaximGotovchits/Storeable/FillTable.java index 98751720c..1148c955d 100644 --- a/src/ru/fizteh/fivt/students/MaximGotovchits/Storeable/FillTable.java +++ b/src/ru/fizteh/fivt/students/MaximGotovchits/Storeable/FillTable.java @@ -9,13 +9,12 @@ import java.util.Map; public class FillTable extends CommandsTools { - int dirAndFileNum = 16; - public void fillTableFunction(String tableName) throws Exception { - for (Map.Entry entry : commitStorage.entrySet()) { + public void fillTableFunction(ObjectTable usingTable) throws Exception { + for (Map.Entry entry : usingTable.commitStorage.entrySet()) { int hashCode = entry.getKey().hashCode(); - Integer nDirectory = hashCode % dirAndFileNum; - Integer nFile = hashCode / dirAndFileNum % dirAndFileNum; - Path fileName = Paths.get(tableName, nDirectory + dirExt); + Integer nDirectory = hashCode % dirNum; + Integer nFile = hashCode / dirNum % fileNum; + Path fileName = Paths.get(dataBaseName + File.separator + usingTable.getName(), nDirectory + dirExt); File file = new File(fileName.toString()); if (!file.exists()) { file.mkdir(); @@ -30,7 +29,7 @@ public void fillTableFunction(String tableName) throws Exception { stream.write((int) bytesKey.length); stream.write(bytesKey); byte[] bytesVal = ((" " + entry.getValue().serialisedValue + " ").getBytes(StandardCharsets.UTF_8)); - stream.write((int) bytesVal.length); + stream.write((int) bytesVal.length - 1); stream.write(bytesVal); stream.close(); } diff --git a/src/ru/fizteh/fivt/students/MaximGotovchits/Storeable/Interpreter.java b/src/ru/fizteh/fivt/students/MaximGotovchits/Storeable/Interpreter.java index d66cefe94..01f7228b1 100644 --- a/src/ru/fizteh/fivt/students/MaximGotovchits/Storeable/Interpreter.java +++ b/src/ru/fizteh/fivt/students/MaximGotovchits/Storeable/Interpreter.java @@ -1,287 +1,210 @@ package ru.fizteh.fivt.students.MaximGotovchits.Storeable; -import java.io.File; -import java.text.ParseException; import java.util.*; -public class Interpreter { - final String invitationSymbol = "$ "; - boolean tableIsChosen = false; // Determines if table is chosen. - boolean isCommand = false; - Scanner sc = new Scanner(System.in); - String tableName; - ObjectTable currentTable; - String dataBaseName = System.getProperty("fizteh.db.dir"); - static Map storage = new HashMap(); - void getInputData() throws Exception { - System.out.print(invitationSymbol); - String cmd = sc.nextLine(); - parseInputData(cmd, false); - } - void parseInputData(String cmd, boolean fromCmd) throws Exception { - String[] cmdBuffer = new String[1024]; - if (fromCmd) { - cmd = cmd.replaceAll("\\s+" + ";" + "\\s+", ";"); - cmd = cmd.replaceAll("\\s+", " "); - cmd = cmd.replaceAll(";", " "); - cmd = cmd.replaceAll("\\s+", " "); - cmdBuffer = cmd.split(" "); - } else { - if (cmd.equals("") || cmd.equals("\\s+")) { - getInputData(); - } else { - cmdBuffer = cmd.split(" "); - if (cmdBuffer[0].equals("") && cmdBuffer.length > 0) { - for (int ind = 1; ind < cmdBuffer.length; ++ind) { - cmd = cmd + cmdBuffer[ind] + " "; - } - cmdBuffer = cmd.split(" "); - } - } +public class Interpreter extends CommandsTools { + private final String invitationalSymbol = "$ "; + + void parseDataFromCmdLine(String cmdLine) throws Exception { + String[] splittedLine = cmdLine.split("\\s*;\\s*"); + for (String line : splittedLine) { + String[] cmd = line.split("\\s+"); + executionFunction(cmd, true); // True means that data is from command line. } - interpreterFunction(cmdBuffer, fromCmd); } - void interpreterFunction(String[] cmdBuffer, boolean fromCmd) throws Exception { - int ind = 0; - while (ind < cmdBuffer.length) { - isCommand = false; - if (fromCmd) { - ifContinue(ind, cmdBuffer, fromCmd, false); - } - if (cmdBuffer[ind].equals("put")) { - isCommand = true; - if (tableIsChosen) { - ++ind; - ifContinue(ind, cmdBuffer, fromCmd, false); - String key = cmdBuffer[ind]; - ++ind; - ifContinue(ind, cmdBuffer, fromCmd, false); - if (!cmdBuffer[ind].substring(0, 1).equals("[")) { - isCommand = false; - continue; - } - int startInd = ind; - while (!cmdBuffer[ind].substring(cmdBuffer[ind].length() - 1, - cmdBuffer[ind].length()).equals("]")) { - ++ind; - ifContinue(ind, cmdBuffer, fromCmd, false); - } - int finishInd = ind; - String value = new String(); - for (int i = startInd; i <= finishInd; ++i) { - value += cmdBuffer[i] + " "; - } - value = value.substring(0, value.length() - 1); - ObjectStoreable putParam = convertToStoreable(value); - new ObjectTable().put(key, putParam); - } else { - System.out.println("no table"); - } - ifContinue(ind + 1, cmdBuffer, fromCmd, false); + + void getCmdFromStream() throws Exception { + Scanner scan = new Scanner(System.in); + System.out.print(invitationalSymbol); + String[] cmd = scan.nextLine().split("\\s+"); + executionFunction(cmd, false); // False means that data is from "System.in". + } + + private void executionFunction(String[] cmd, boolean fromCmdLine) throws Exception { // The main interpreter + // function. + if (cmd[0].equals("create") && cmd.length > 2) { + String createParameter = new String(); // (...) - type list. + String tableName = cmd[1]; + for (int ind = 2; ind < cmd.length; ++ind) { + createParameter += cmd[ind] + " "; } - if (cmdBuffer[ind].equals("get")) { - isCommand = true; - if (tableIsChosen) { - if (ind + 1 < cmdBuffer.length) { - ++ind; - new ObjectTable().get(cmdBuffer[ind]); - } else { - new ObjectTable().get(null); - } - } else { - System.out.println("no table"); - } - ifContinue(ind + 1, cmdBuffer, fromCmd, false); + createParameter = createParameter.substring(0, createParameter.length() - 1); + List> typeList = new LinkedList<>(); + try { + typeList = getTypeList(createParameter, fromCmdLine); + new ObjectTableProvider().createTable(tableName, typeList); + } catch (Exception e) { + printExceptionMessage(e); } - if (cmdBuffer[ind].equals("remove") && ind + 1 < cmdBuffer.length) { - isCommand = true; - ++ind; + ifContinue(fromCmdLine); + } + + if (cmd[0].equals("use") && cmd.length == 2) { + String tableName = cmd[1]; + boolean changeUsingTable = false; + try { if (tableIsChosen) { - new ObjectTable().remove(cmdBuffer[ind]); + new Use().useFunction(tableName, currentTableObject.getName()); } else { - System.out.println("no table"); + tableIsChosen = new Use().useFunction(tableName, null); } - ifContinue(ind + 1, cmdBuffer, fromCmd, false); + } catch (Exception e) { + printExceptionMessage(e); } - if (cmdBuffer[ind].equals("list")) { - isCommand = true; - if (tableIsChosen) { - new ObjectTable().list(); - } else { - System.out.println("no table"); + ifContinue(fromCmdLine); + } + + if (cmd[0].equals("put") && cmd.length > 2) { + if (tableIsChosen) { + String putParameter = new String(); + String key = cmd[1]; + for (int ind = 2; ind < cmd.length; ++ind) { + putParameter += cmd[ind] + " "; + } + putParameter = putParameter.substring(0, putParameter.length() - 1); + try { + ObjectStoreable value = (ObjectStoreable) new ObjectTableProvider(). + deserialize(currentTableObject, putParameter); + currentTableObject.put(key, value); + } catch (Exception e) { + printExceptionMessage(e); } - ifContinue(ind + 1, cmdBuffer, fromCmd, false); + } else { + informToChooseTable(); } - if (cmdBuffer[ind].equals("exit")) { - isCommand = true; - if (tableIsChosen) { - if (!fromCmd) { - if (new Exit().exitAndUseAvailable()) { - new FillTable().fillTableFunction(tableName); - } else { - ++ind; - ifContinue(ind, cmdBuffer, fromCmd, false); - continue; - } - } else { - currentTable.commit(); - new FillTable().fillTableFunction(tableName); - } - sc.close(); - new Exit().exitFunction(); - } else { - new Exit().exitFunction(); - } - ifContinue(ind + 1, cmdBuffer, fromCmd, false); + ifContinue(fromCmdLine); + } + + if (cmd[0].equals("commit") && cmd.length == 1) { + currentTableObject.commit(); + ifContinue(fromCmdLine); + } + + if (cmd[0].equals("show") && cmd[1].equals("tables") && cmd.length == 2) { + new ObjectTableProvider().getTableNames(); + ifContinue(fromCmdLine); + } + + if (cmd[0].equals("get") && cmd.length == 2) { + if (tableIsChosen) { + currentTableObject.get(cmd[1]); + } else { + informToChooseTable(); } - if (cmdBuffer[ind].equals("create")) { - isCommand = true; - ++ind; - ifContinue(ind, cmdBuffer, fromCmd, false); - String name = cmdBuffer[ind]; - ++ind; - ifContinue(ind, cmdBuffer, fromCmd, true); - if (!cmdBuffer[ind].substring(0, 1).equals("(")) { - isCommand = false; - System.err.println("incorrect syntax"); - if (fromCmd) { - continue; - } else { - getInputData(); - } - } - int startInd = ind; - while (!cmdBuffer[ind].substring(cmdBuffer[ind].length() - 1, - cmdBuffer[ind].length()).equals(")")) { - ++ind; - ifContinue(ind, cmdBuffer, fromCmd, false); - } - int finishInd = ind; - String types = new String(); - for (int i = startInd; i <= finishInd; ++i) { - types += cmdBuffer[i]; - } - types.replaceAll("\\s+", ""); - types = types.substring(1, types.length() - 1); - String[] typeArr = types.split(","); - List> list = new LinkedList>(); - for (String type : typeArr) { - list.add(getType(type)); - } - new ObjectTableProvider().createTable(name, list); - ifContinue(ind + 1, cmdBuffer, fromCmd, false); + ifContinue(fromCmdLine); + } + + if (cmd[0].equals("list") && cmd.length == 1) { + if (tableIsChosen) { + currentTableObject.list(); + } else { + informToChooseTable(); } - if (cmdBuffer[ind].equals("drop")) { - isCommand = true; - ++ind; - ifContinue(ind, cmdBuffer, fromCmd, false); - if (new File(tableName).getName().equals(cmdBuffer[ind])) { - tableName = null; - tableIsChosen = false; - } - new ObjectTableProvider().removeTable(tableName); - ifContinue(ind + 1, cmdBuffer, fromCmd, false); + ifContinue(fromCmdLine); + } + + if (cmd[0].equals("remove") && cmd.length == 2) { + if (tableIsChosen) { + currentTableObject.remove(cmd[1]); + } else { + informToChooseTable(); } - if (cmdBuffer[ind].equals("use")) { - isCommand = true; - ++ind; - ifContinue(ind, cmdBuffer, fromCmd, false); + ifContinue(fromCmdLine); + } + + if (cmd[0].equals("drop") && cmd.length == 2) { + new ObjectTableProvider().removeTable(cmd[1]); + ifContinue(fromCmdLine); + } + + if (cmd[0].equals("rollback") && cmd.length == 1) { + currentTableObject.rollback(); + ifContinue(fromCmdLine); + } + + if (cmd[0].equals("exit") && cmd.length == 1) { + if (fromCmdLine) { + currentTableObject.commit(); + new Exit().exitFunction(); + } else { if (new Exit().exitAndUseAvailable()) { - if (storage.isEmpty()) { - new Use().useFunction(cmdBuffer[ind], tableName); - if (new File(dataBaseName + File.separator + cmdBuffer[ind]).exists()) { - tableIsChosen = true; - tableName = dataBaseName + File.separator + cmdBuffer[ind]; - currentTable = new ObjectTable(tableName); - } - } else { - System.out.println(storage.size() + " unsaved changes"); - } - } - ifContinue(ind + 1, cmdBuffer, fromCmd, false); - } - if (cmdBuffer[ind].equals("show")) { - ++ind; - ifContinue(ind, cmdBuffer, fromCmd, false); - if (cmdBuffer[ind].equals("tables")) { - isCommand = true; - new ObjectTableProvider().getTableNames(); - } - ifContinue(ind + 1, cmdBuffer, fromCmd, false); - } - if (cmdBuffer[ind].equals("rollback")) { - isCommand = true; - if (tableIsChosen) { - new ObjectTable().rollback(); - } else { - System.out.println("no table"); - } - ifContinue(ind + 1, cmdBuffer, fromCmd, false); - } - if (cmdBuffer[ind].equals("commit")) { - isCommand = true; - if (tableIsChosen) { - new ObjectTable().commit(); - } else { - System.out.println("no table"); + new Exit().exitFunction(); } - ifContinue(ind + 1, cmdBuffer, fromCmd, false); } - ++ind; - if (!isCommand) { - if (fromCmd) { + ifContinue(fromCmdLine); + } + if (cmd.length != 0) { + syntaxError(); + } + ifContinue(fromCmdLine); + } + + void informToChooseTable() { + System.err.println("table is not chosen"); + } + + void ifContinue(boolean fromCmdLine) throws Exception { + if (fromCmdLine) { + return; + } else { + getCmdFromStream(); + } + } + + private void printExceptionMessage(Exception e) { + System.err.println(e); + } + + private List> getTypeList(String line, boolean fromCmdLine) throws Exception { + List> typeList = new LinkedList>(); + line = line.replaceAll("\\s*\\)\\s*", ""); + line = line.replaceAll("\\s*\\(\\s*", ""); + String[] tmp = line.split("\\s+"); + for (String str : tmp) { + Class type = getType(str); + if (type != null) { + typeList.add(type); + } else { + syntaxError(); + if (fromCmdLine) { System.exit(1); + } else { + getCmdFromStream(); } - ifContinue(ind + 1, cmdBuffer, fromCmd, true); } } + return typeList; } - boolean isType(String typeName) { - if (typeName.equals("int") || typeName.equals("long") || typeName.equals("byte") || typeName.equals("float") - || typeName.equals("double") || typeName.equals("boolean") || typeName.equals("String")) { - return true; - } - return false; - } - Class getType(String typeName) { - if (typeName.equals("int")) { + + private Class getType(String str) { + if (str.equals("int")) { return int.class; } - if (typeName.equals("long")) { + if (str.equals("long")) { return long.class; } - if (typeName.equals("byte")) { - return byte.class; + if (str.equals("double")) { + return double.class; } - if (typeName.equals("float")) { + if (str.equals("float")) { return float.class; } - if (typeName.equals("double")) { + if (str.equals("double")) { return double.class; } - if (typeName.equals("boolean")) { + if (str.equals("boolean")) { return boolean.class; } - if (typeName.equals("String")) { + if (str.equals("byte")) { + return byte.class; + } + if (str.equals("String")) { return String.class; } return null; } - ObjectStoreable convertToStoreable(String value) throws ParseException { - ObjectStoreable storeableToReturn = new ObjectStoreable(value); - return storeableToReturn; - } - void ifContinue(int ind, String[] cmdBuffer, boolean fromCmd, boolean calledByIncorrectSyntax) throws Exception { - if (ind >= cmdBuffer.length) { - if (fromCmd) { - System.err.println("incorrect syntax"); - System.exit(1); - } else { - if (calledByIncorrectSyntax) { - System.err.println("incorrect syntax"); - getInputData(); - } - } - } + + void syntaxError() { + System.err.println("incorrect syntax"); } } diff --git a/src/ru/fizteh/fivt/students/MaximGotovchits/Storeable/Main.java b/src/ru/fizteh/fivt/students/MaximGotovchits/Storeable/Main.java index 2d22460d1..1f8008088 100644 --- a/src/ru/fizteh/fivt/students/MaximGotovchits/Storeable/Main.java +++ b/src/ru/fizteh/fivt/students/MaximGotovchits/Storeable/Main.java @@ -4,13 +4,14 @@ public class Main { // Using JSON format. public static void main(final String[] args) throws Exception { new MakeDirs().makeDirsFunction(); if (args.length == 0) { - new Interpreter().getInputData(); + new Interpreter().getCmdFromStream(); } else { String cmd = new String(); for (String arg : args) { cmd += arg + " "; } - new Interpreter().parseInputData(cmd.substring(0, cmd.length() - 1), true); // Откусить " ". + cmd = cmd.replaceAll("\\s+", " "); + new Interpreter().parseDataFromCmdLine(cmd.substring(0, cmd.length() - 1)); new Exit().exitFunction(); } } diff --git a/src/ru/fizteh/fivt/students/MaximGotovchits/Storeable/MakeDirs.java b/src/ru/fizteh/fivt/students/MaximGotovchits/Storeable/MakeDirs.java index 99434c9ea..f4ab90476 100644 --- a/src/ru/fizteh/fivt/students/MaximGotovchits/Storeable/MakeDirs.java +++ b/src/ru/fizteh/fivt/students/MaximGotovchits/Storeable/MakeDirs.java @@ -15,7 +15,7 @@ void makeDirsFunction() throws Exception { for (File sub : file.listFiles()) { if (!sub.isDirectory() && !sub.isHidden()) { System.err.println(dataBaseName + File.separator - + sub.getName() + " is not a directory"); + + sub.getName() + " is not a directory"); } } } diff --git a/src/ru/fizteh/fivt/students/MaximGotovchits/Storeable/ObjectStoreable.java b/src/ru/fizteh/fivt/students/MaximGotovchits/Storeable/ObjectStoreable.java index d4f13f4a6..b6acb1f11 100644 --- a/src/ru/fizteh/fivt/students/MaximGotovchits/Storeable/ObjectStoreable.java +++ b/src/ru/fizteh/fivt/students/MaximGotovchits/Storeable/ObjectStoreable.java @@ -8,14 +8,10 @@ import java.util.Objects; public class ObjectStoreable extends CommandsTools implements Storeable { - public List subValueList = new LinkedList(); + public List subValueList = new LinkedList<>(); public String serialisedValue = new String(); - public List> typeKeeper = new LinkedList>(); - public ObjectStoreable() { - serialisedValue = ""; - subValueList = new LinkedList(); - typeKeeper = new LinkedList>(); - } + public List> typeKeeper = new LinkedList<>(); + public ObjectStoreable() {} public ObjectStoreable(List values) { int ind = 0; serialisedValue = "["; @@ -23,7 +19,7 @@ public ObjectStoreable(List values) { subValueList.add(val); serialisedValue += val + ", "; } - serialisedValue = serialisedValue.substring(0, serialisedValue.length() - 2); // Откусить ", ". + serialisedValue = serialisedValue.substring(0, serialisedValue.length() - 2); serialisedValue += "]"; } public ObjectStoreable(Storeable value) { @@ -48,12 +44,11 @@ public int hashCode() { return Objects.hashCode(this.serialisedValue); } @Override - public boolean equals(Object obj) { // Возможно тут нужно было как-то использовать hashCode, - // но я не знаю как, особенно если учесть, что он возваращает Objects, а не Object. + public boolean equals(Object obj) { ObjectStoreable storeableObj = (ObjectStoreable) obj; if (this.serialisedValue.equals(storeableObj.serialisedValue) - && this.typeKeeper.equals(storeableObj.typeKeeper) - && this.subValueList.equals(storeableObj.subValueList)) { + && this.typeKeeper.equals(storeableObj.typeKeeper) + && this.subValueList.equals(storeableObj.subValueList)) { return true; } return false; @@ -64,7 +59,7 @@ public void setColumnAt(int columnIndex, Object value) throws ColumnFormatExcept if (columnIndex >= this.subValueList.size()) { throw new IndexOutOfBoundsException(); } - List> toConvert = new LinkedList>(); + List> toConvert = new LinkedList<>(); toConvert.add(value.getClass()); toConvert = convertToPrimitive(toConvert); if (!typeKeeper.get(columnIndex).equals(toConvert.get(0))) { @@ -200,8 +195,8 @@ public String getStringAt(int columnIndex) throws ColumnFormatException, IndexOu } return subValueList.get(columnIndex).toString(); } - private List> convertToPrimitive(List> list) { // Этим методом пользуюсь только я. - List> toReturn = new LinkedList>(); + private List> convertToPrimitive(List> list) { + List> toReturn = new LinkedList<>(); for (Class object : list) { if (object.equals(Integer.class)) { toReturn.add(int.class); diff --git a/src/ru/fizteh/fivt/students/MaximGotovchits/Storeable/ObjectTable.java b/src/ru/fizteh/fivt/students/MaximGotovchits/Storeable/ObjectTable.java index bc7cd5815..468cb46fc 100644 --- a/src/ru/fizteh/fivt/students/MaximGotovchits/Storeable/ObjectTable.java +++ b/src/ru/fizteh/fivt/students/MaximGotovchits/Storeable/ObjectTable.java @@ -12,16 +12,14 @@ public class ObjectTable extends CommandsTools implements Table { static int overwriteNum = 0; - public String tableName; + public Stack lastChanges = new Stack(); + public Map storage = new HashMap(); + public Map commitStorage = new HashMap(); + public String tableName = new String(); public List> typeKeeper = new LinkedList>(); public ObjectTable() { - if (usingTable != null && typeKeeper != null) { - tableName = usingTable; - typeKeeper = currentTableObject.typeKeeper; - } else { - tableName = ""; - typeKeeper = new LinkedList>(); - } + tableName = usingTableName; + typeKeeper = currentTableObject.typeKeeper; } public ObjectTable(Table table) { ObjectTable temp = (ObjectTable) table; @@ -29,23 +27,22 @@ public ObjectTable(Table table) { this.typeKeeper = temp.typeKeeper; } public ObjectTable(String name) { + if (!new File(name).isAbsolute()) { + name = dataBaseName + File.separator + name; + } this.tableName = new File(name).getName(); String content = new String(); try { if (!new File(name + File.separator + signatureFileName).isAbsolute()) { name = dataBaseName + File.separator + name; } - if (new File(name).isDirectory()) { - content = readFile(name + File.separator + signatureFileName, Charset.defaultCharset()); - content.replaceAll("\\s+", " "); - String[] types = content.split(" "); - int ind = 0; - for (String type : types) { - this.typeKeeper.add(ind, getType(type)); - ++ind; - } - } else { - System.err.println(new File(name).getName() + " is not a directory"); + content = readFile(name + File.separator + signatureFileName, Charset.defaultCharset()); + content.replaceAll("\\s+", " "); + String[] types = content.split(" "); + int ind = 0; + for (String type : types) { + typeKeeper.add(ind, getType(type)); + ++ind; } } catch (IOException s) { System.err.println(s); @@ -89,7 +86,7 @@ public Storeable get(String key) throws IllegalArgumentException { // В док } ObjectStoreable value = storage.get(key); if (value == null) { - System.out.println("not found"); + System.err.println("not found"); return null; } String serializedValue = value.serialisedValue; @@ -141,6 +138,7 @@ public Storeable remove(String key) { return null; } ObjectStoreable value = storage.remove(key); + commitStorage.remove(key); if (value != null) { lastChanges.push(value); lastChanges.push(key); @@ -185,7 +183,7 @@ public int commit() { @Override public int rollback() throws IllegalArgumentException { int changes = Math.abs(storage.size() - commitStorage.size() + overwriteNum); - while (!lastChanges.isEmpty()) { + while (!lastChanges.isEmpty()) { Object tmpCmd = lastChanges.pop(); if (tmpCmd.equals("put")) { String key = lastChanges.pop().toString(); @@ -225,7 +223,7 @@ public Class getColumnType(int columnIndex) throws IndexOutOfBoundsException static String readFile(String path, Charset encoding) throws IOException { byte[] encoded = Files.readAllBytes(Paths.get(path)); String temp = new String(encoded, encoding); - return temp.substring(0, temp.length() - 1); // Можно было поставить -2. Это зависит от настроек IDE. + return temp.replaceAll("^\\s*|\\s*$", ""); } private Class getType(String typeName) { if (typeName.equals("int")) { diff --git a/src/ru/fizteh/fivt/students/MaximGotovchits/Storeable/ObjectTableProvider.java b/src/ru/fizteh/fivt/students/MaximGotovchits/Storeable/ObjectTableProvider.java index acdd89b78..2c44e5225 100644 --- a/src/ru/fizteh/fivt/students/MaximGotovchits/Storeable/ObjectTableProvider.java +++ b/src/ru/fizteh/fivt/students/MaximGotovchits/Storeable/ObjectTableProvider.java @@ -12,7 +12,7 @@ import java.util.Objects; public class ObjectTableProvider extends CommandsTools implements TableProvider { - private String rootDirectory; // Только ради тестов. Или нет... + private String rootDirectory = new String(); public ObjectTableProvider() { rootDirectory = dataBaseName; } @@ -75,12 +75,12 @@ public void removeTable(String name) throws IllegalArgumentException, IllegalSta File toBeRemoved = new File(tableName); if (toBeRemoved.exists()) { if (tableIsChosen) { - if (usingTable.equals(name)) { - storage.clear(); - commitStorage.clear(); - uncommitedChanges = 0; + if (usingTableName.equals(name)) { + currentTableObject.storage.clear(); + currentTableObject.commitStorage.clear(); + //currentTableObject.uncommitedChanges = 0; tableIsChosen = false; - usingTable = null; + usingTableName = null; } } recRem(tableName); @@ -99,74 +99,37 @@ public void removeTable(String name) throws IllegalArgumentException, IllegalSta } @Override public Storeable deserialize(Table table, String value) throws ParseException { - if (!checkCorrectness(value)) { - return null; + ObjectTable usingTable = (ObjectTable) table; + ObjectStoreable valueToReturn = new ObjectStoreable(); + String[] splittedValue = value.split(""); + if (!splittedValue[0].equals("[") || !splittedValue[splittedValue.length - 1].equals("]")) { + throw new ParseException(value, 0); } - try { - ObjectStoreable tempStoreable = new ObjectStoreable(); - ObjectTable tempTable = (ObjectTable) table; - String[] toBeParsed = value.split(""); - if (!toBeParsed[0].equals("[")) { - throw new ParseException(value, 0); - } - if (!toBeParsed[toBeParsed.length - 1].equals("]")) { - throw new ParseException(value, toBeParsed.length - 1); - } - int writingIndex = 0; - int readingIndex = 1; - boolean detector = false; // Detects if JSON format is incorrect. - while (readingIndex < toBeParsed.length - 1) { // Parsing process. - detector = false; - if (toBeParsed[readingIndex].equals("\"")) { // String is found. - detector = true; - readingIndex = parseString(tempTable, toBeParsed, readingIndex, writingIndex, tempStoreable); - readingIndex += 3; - ++writingIndex; - if (whetherIsParsed(toBeParsed, readingIndex)) { // Checks if parsing has to be stopped immediately. - break; - } - } - if (toBeParsed[readingIndex].equals("t") || toBeParsed[readingIndex].equals("f")) { // Boolean is found. - detector = true; - readingIndex = parseBoolean(tempTable, toBeParsed, readingIndex, writingIndex, tempStoreable); - readingIndex += 2; - ++writingIndex; - if (whetherIsParsed(toBeParsed, readingIndex)) { - break; - } - } - if (toBeParsed[readingIndex].equals("n")) { // Null is found. - detector = true; - parseNull(tempTable, toBeParsed, readingIndex, writingIndex, tempStoreable); - readingIndex += 2; - ++writingIndex; - if (whetherIsParsed(toBeParsed, readingIndex)) { - break; - } - } - if (isNumber(toBeParsed[readingIndex])) { - detector = true; - readingIndex = parseNumber(tempTable, toBeParsed, readingIndex, writingIndex, tempStoreable); - if (!toBeParsed[readingIndex].equals(",") && !toBeParsed[readingIndex].equals("]")) { - throw new ParseException(value, readingIndex); - } - readingIndex += 2; - ++writingIndex; - if (whetherIsParsed(toBeParsed, readingIndex)) { - break; - } - } - if (!detector) { - throw new ParseException(value, readingIndex); + valueToReturn.serialisedValue = value; + value = value.replaceAll("^\\s*\\[\\s*|\\s*\\]\\s*$", ""); // Removing [ and ]. + String[] tempValue = value.split(JSON_REG_EX); // Split by comma. + if (usingTable.getColumnsCount() != tempValue.length) { + throw new ParseException(value, 0); + } + int index = 0; + List> typeList = new LinkedList<>(); + for (String str : tempValue) { + try { + Object val = getValue(str, usingTable, usingTable.typeKeeper.get(index)); + if (val.equals("^incorrect$")) { + throw new ParseException(value, 0); } + valueToReturn.subValueList.add(val); + typeList.add(val.getClass()); + } catch (NumberFormatException e) { + throw new ParseException(value, 0); } - tempStoreable.serialisedValue = value; - return tempStoreable; - } catch (ParseException s) { - System.err.println(s); - return null; + ++index; } + valueToReturn.typeKeeper = usingTable.typeKeeper; + return valueToReturn; } + @Override public String serialize(Table table, Storeable value) throws ColumnFormatException { ObjectStoreable valueToSerialize = (ObjectStoreable) value; @@ -185,10 +148,12 @@ public String serialize(Table table, Storeable value) throws ColumnFormatExcepti } return valueToSerialize.serialisedValue; } + @Override public Storeable createFor(Table table) { return new ObjectStoreable((ObjectTable) table); } + @Override public Storeable createFor(Table table, List values) throws ColumnFormatException, IndexOutOfBoundsException { int ind = 0; @@ -215,6 +180,7 @@ public Storeable createFor(Table table, List values) throws ColumnFormatExcep toReturn.typeKeeper = tempTable.typeKeeper; return toReturn; } + @Override public List getTableNames() { List list = new LinkedList(); @@ -222,35 +188,36 @@ public List getTableNames() { int recordsAmount = 0; File file = new File(rootDirectory); for (File sub : file.listFiles()) { - recordsAmount = 0; - for (Integer i = 0; i < dirNum; ++i) { - currentFile = rootDirectory + File.separator + sub.getName() + File.separator - + i + dirExt; - File file1 = new File(currentFile); - if (file1.exists()) { - for (Integer j = 0; j < fileNum; ++j) { - currentFile = rootDirectory + File.separator + sub.getName() + File.separator - + i + dirExt + File.separator + j + fileExt; - file1 = new File(currentFile); - try { - if (file1.exists()) { - DataInputStream stream = new DataInputStream(new FileInputStream(currentFile)); - byte[] data = new byte[(int) file1.length()]; - stream.read(data); - String temp = new String(data, StandardCharsets.UTF_8); - recordsAmount += (temp.length() - temp.replaceAll(" ", "").length()) / 4; + if ((!sub.isHidden()) && sub.isDirectory()) { + recordsAmount = 0; + for (Integer i = 0; i < dirNum; ++i) { + currentFile = rootDirectory + File.separator + sub.getName() + File.separator + + i + dirExt; + File file1 = new File(currentFile); + if (file1.exists()) { + for (Integer j = 0; j < fileNum; ++j) { + currentFile = rootDirectory + File.separator + sub.getName() + File.separator + + i + dirExt + File.separator + j + fileExt; + file1 = new File(currentFile); + try { + if (file1.exists()) { + DataInputStream stream = new DataInputStream(new FileInputStream(currentFile)); + byte[] data = new byte[(int) file1.length()]; + stream.read(data); + String temp = new String(data, StandardCharsets.UTF_8); + recordsAmount += (temp.length() - temp.replaceAll(" ", "").length()) / 4; + } + } catch (IOException s) { + return null; } - } catch (IOException s) { - return null; } } } - } - currentFile = new File(new File(new File(currentFile).getParent()).getParent()).getName(); - if (!sub.isHidden() && sub.isDirectory()) { + currentFile = new File(new File(new File(currentFile).getParent()).getParent()).getName(); list.add(sub.getName()); - if (sub.getName().equals(usingTable)) { - System.out.println(sub.getName() + " " + (recordsAmount + storage.size())); + if (sub.getName().equals(usingTableName)) { + System.out.println(sub.getName() + " " + + (recordsAmount + currentTableObject.storage.size())); } else { System.out.println(sub.getName() + " " + recordsAmount); } @@ -258,7 +225,66 @@ public List getTableNames() { } return list; } - + + private Object getValue(String str, ObjectTable usingTable, Class expectedType) throws NumberFormatException { + for (Class type : usingTable.typeKeeper) { + if (expectedType.equals(int.class)) { + if (str.equals("null")) { + return null; + } + Integer toReturn = Integer.parseInt(str); + return toReturn; + } + if (expectedType.equals(long.class)) { + if (str.equals("null")) { + return null; + } + Long toReturn = Long.parseLong(str); + return toReturn; + } + if (expectedType.equals(boolean.class)) { + if (str.equals("null")) { + return null; + } + Boolean toReturn = Boolean.parseBoolean(str); + return toReturn; + } + if (expectedType.equals(String.class)) { + if (str.equals("null")) { + return null; + } + String[] tmp = str.split(""); + if (tmp[0].equals("\"") && tmp[tmp.length - 1].equals("\"")) { + return str; + } else { + throw new NumberFormatException(); + } + } + if (expectedType.equals(byte.class)) { + if (str.equals("null")) { + return null; + } + Byte toReturn = Byte.parseByte(str); + return toReturn; + } + if (expectedType.equals(double.class)) { + if (str.equals("null")) { + return null; + } + Double toReturn = Double.parseDouble(str); + return toReturn; + } + if (expectedType.equals(float.class)) { + if (str.equals("null")) { + return null; + } + Float toReturn = Float.parseFloat(str); + return toReturn; + } + } + return "^incorrect@"; + } + void recRem(String myFile) { File file = new File(myFile); if (!file.exists()) { @@ -271,7 +297,7 @@ void recRem(String myFile) { } file.delete(); } - + public Object checkException(String name) throws IllegalArgumentException { try { if (name == null || name.length() > longestName) { @@ -283,254 +309,8 @@ public Object checkException(String name) throws IllegalArgumentException { } return null; } - private boolean whetherIsParsed(String[] toBeParsed, int readingIndex) { - if (toBeParsed.length - readingIndex < 3) { - return true; - } - return false; - } - private int parseString(ObjectTable table, String[] toBeParsed, - int readingIndex, int writingIndex, ObjectStoreable tempStoreable) { - ++readingIndex; - String toAdd = new String(); - while (!toBeParsed[readingIndex].equals("\"")) { - toAdd += toBeParsed[readingIndex]; - ++readingIndex; - } - tempStoreable.typeKeeper.add(writingIndex, String.class); - tempStoreable.subValueList.add(writingIndex, "\"" + toAdd + "\""); - return readingIndex; - } - - private int parseBoolean(ObjectTable table, String[] toBeParsed, - int readingIndex, int writingIndex, ObjectStoreable tempStoreable) { - if (toBeParsed[readingIndex].equals("t")) { - tempStoreable.subValueList.add(writingIndex, true); - readingIndex += 4; - } else { - tempStoreable.subValueList.add(writingIndex, false); - readingIndex += 5; - } - tempStoreable.typeKeeper.add(writingIndex, boolean.class); - return readingIndex; - } - private int parseNull(ObjectTable table, String[] toBeParsed, - int readingIndex, int writingIndex, ObjectStoreable tempStoreable) { - tempStoreable.subValueList.add(writingIndex, null); - readingIndex += 4; - tempStoreable.typeKeeper.add(writingIndex, Object.class); - return readingIndex; - } - private int parseNumber(ObjectTable table, String[] toBeParsed, - int readingIndex, int writingIndex, ObjectStoreable tempStoreable) { - int firstIndex = readingIndex; - int lastIndex = readingIndex; - boolean isDouble = false; - boolean isByte = false; - while ((!toBeParsed[lastIndex].equals("]")) && (!toBeParsed[lastIndex].equals(","))) { - // Checks if it's a boolean. - if (toBeParsed[lastIndex].equals("x")) { - if (isDouble) { - return lastIndex; - } - isByte = true; - ++lastIndex; - continue; - } - if (toBeParsed[lastIndex].equals(".") && !isByte) { - if (isByte) { - return lastIndex; - } - isDouble = true; - ++lastIndex; - continue; - } - ++lastIndex; - } - String temp = new String(); - for (int i = firstIndex; i < lastIndex; ++i) { - temp += toBeParsed[i]; - } - firstIndex = lastIndex + 2; - if (isByte) { // Is Byte. - tempStoreable.subValueList.add(writingIndex, Byte.parseByte(temp)); - tempStoreable.typeKeeper.add(writingIndex, byte.class); - return lastIndex; - } - if (isDouble) { - try { // http://bit.ly/1v9GqBT - if (table != null) { - if (table.typeKeeper.get(writingIndex).equals(double.class)) { - tempStoreable.subValueList.add(writingIndex, Double.parseDouble(temp)); - tempStoreable.typeKeeper.add(writingIndex, double.class); - return lastIndex; - } - if (table.typeKeeper.get(writingIndex).equals(float.class)) { - tempStoreable.subValueList.add(writingIndex, Float.parseFloat(temp)); - tempStoreable.typeKeeper.add(writingIndex, float.class); - return lastIndex; - } - } - Float.parseFloat(temp); - } catch (NumberFormatException s) { - tempStoreable.subValueList.add(writingIndex, Double.parseDouble(temp)); - tempStoreable.typeKeeper.add(writingIndex, double.class); - return lastIndex; - } - tempStoreable.subValueList.add(writingIndex, Float.parseFloat(temp)); - tempStoreable.typeKeeper.add(writingIndex, float.class); - return lastIndex; - } else { // Int or long is found. - try { - if (table != null) { - if (table.typeKeeper.get(writingIndex).equals(int.class)) { - tempStoreable.subValueList.add(writingIndex, Integer.parseInt(temp)); - tempStoreable.typeKeeper.add(writingIndex, int.class); - return lastIndex; - } - if (table.typeKeeper.get(writingIndex).equals(long.class)) { - tempStoreable.subValueList.add(writingIndex, Long.parseLong(temp)); - tempStoreable.typeKeeper.add(writingIndex, long.class); - return lastIndex; - } - if (table.typeKeeper.get(writingIndex).equals(byte.class)) { - tempStoreable.subValueList.add(writingIndex, Byte.parseByte(temp)); - tempStoreable.typeKeeper.add(writingIndex, byte.class); - return lastIndex; - } - } - Integer.parseInt(temp); - } catch (NumberFormatException s) { - tempStoreable.subValueList.add(writingIndex, Double.parseDouble(temp)); - tempStoreable.typeKeeper.add(writingIndex, double.class); - return lastIndex; - } - tempStoreable.subValueList.add(writingIndex, Float.parseFloat(temp)); - tempStoreable.typeKeeper.add(writingIndex, float.class); - return lastIndex; - } - } - - private boolean isNumber(String str) { - try { - Integer.parseInt(str); - } catch (NumberFormatException e) { - return false; - } - return true; - } - private boolean checkCorrectness(String value) { - boolean byteIsUsed = false; - boolean dotIsUsed = false; - String[] valueList = value.split(""); - if (!valueList[0].equals("[") || !valueList[valueList.length - 1].equals("]")) { - return false; - } - if (valueList.length == 2 && valueList[1].equals("]")) { - return true; - } - if (valueList[1].equals(" ")) { - return false; - } - for (int ind = 1; ind < valueList.length; ++ind) { - dotIsUsed = false; - byteIsUsed = false; - if (valueList[ind].equals(" ")) { - return false; - } - if (isNumber(valueList[ind])) { - ++ind; - while (isNumber(valueList[ind]) || valueList[ind].equals("x") || valueList[ind].equals(".")) { - if (valueList[ind].equals("x")) { - if (!byteIsUsed) { - byteIsUsed = true; - } else { - return false; - } - } - if (valueList[ind].equals(".")) { - if (!dotIsUsed) { - dotIsUsed = true; - } else { - return false; - } - } - ++ind; - } - if (!valueList[ind].equals(",") && ind != valueList.length - 1) { - return false; - } - if (valueList[ind].equals("]")) { - return ind == valueList.length - 1; - } - ++ind; - if (!valueList[ind].equals(" ")) { - return false; - } - } else { - if (valueList[ind].equals("\"")) { - ++ind; - while (!valueList[ind].equals("\"")) { - if (ind == valueList.length - 1) { - return false; - } - ++ind; - } - ++ind; - if (!valueList[ind].equals(",") && ind != valueList.length - 1) { - return false; - } - if (valueList[ind].equals("]")) { - return ind == valueList.length - 1; - } - ++ind; - if (!valueList[ind].equals(" ")) { - return false; - } - } else { - if (valueList[ind].equals("t") || valueList[ind].equals("f")) { - if (valueList[ind].equals("t") && ind + 4 < valueList.length) { - if (!valueList[ind + 1].equals("r") || !valueList[ind + 2].equals("u") - || !valueList[ind + 3].equals("e")) { - return false; - } - ind += 4; - if (!valueList[ind].equals(",") && ind != valueList.length - 1) { - return false; - } - if (valueList[ind].equals("]")) { - return ind == valueList.length - 1; - } - ++ind; - if (!valueList[ind].equals(" ")) { - return false; - } - } else { - if (valueList[ind].equals("f") && ind + 5 < valueList.length) { - if (!valueList[ind + 1].equals("a") || !valueList[ind + 2].equals("l") - || !valueList[ind + 3].equals("s") || !valueList[ind + 4].equals("e")) { - return false; - } - ind += 5; - if (!valueList[ind].equals(",") && ind != valueList.length - 1) { - return false; - } - if (valueList[ind].equals("]")) { - return ind == valueList.length - 1; - } - ++ind; - if (!valueList[ind].equals(" ")) { - return false; - } - } - } - } - } - } - } - return true; - } - private List> convertToPrimitive(List list) { // Этим методом пользуюсь только я. Все под контролем. + + private List> convertToPrimitive(List list) { List> toReturn = new LinkedList>(); for (Object object : list) { if (object.getClass().equals(Integer.class)) { diff --git a/src/ru/fizteh/fivt/students/MaximGotovchits/Storeable/Use.java b/src/ru/fizteh/fivt/students/MaximGotovchits/Storeable/Use.java index 13e27d5cc..4b5f87ddb 100644 --- a/src/ru/fizteh/fivt/students/MaximGotovchits/Storeable/Use.java +++ b/src/ru/fizteh/fivt/students/MaximGotovchits/Storeable/Use.java @@ -5,22 +5,23 @@ import java.text.ParseException; public class Use extends CommandsTools { - public void useFunction(String tableName, String oldTableName) throws Exception { - usingTable = tableName; + public boolean useFunction(String tableName, String oldTableName) throws Exception { if (!tableName.equals(oldTableName)) { String outputName = tableName; - String tablePath = dataBaseName + File.separator + tableName; + String tablePath = dataBaseName + "/" + tableName; File file = new File(tablePath); if (file.exists()) { + usingTableName = tableName; if (tableIsChosen) { - new FillTable().fillTableFunction(oldTableName); - storage.clear(); - commitStorage.clear(); + new FillTable().fillTableFunction(currentTableObject); + currentTableObject.storage.clear(); + currentTableObject.commitStorage.clear(); } + currentTableObject = new ObjectTable(dataBaseName + File.separator + usingTableName); for (Integer i = 0; i < dirNum; ++i) { for (Integer j = 0; j < fileNum; ++j) { tablePath = dataBaseName + File.separator + tableName + File.separator - + i + dirExt + File.separator + j + fileExt; + + i + dirExt + File.separator + j + fileExt; if (new File(tablePath).exists()) { fillStorage(tablePath, file); PrintWriter writer = new PrintWriter(new File(tablePath)); @@ -33,11 +34,13 @@ public void useFunction(String tableName, String oldTableName) throws Exception tableIsChosen = true; } else { System.err.println(tableName + " not exists"); + return false; } } else { System.out.println("using " + oldTableName); } - currentTableObject = new ObjectTable(dataBaseName + File.separator + usingTable); + usingTableName = currentTableObject.getName(); + return true; } void fillStorage(String datName, File file) throws IOException, ParseException { DataInputStream stream = new DataInputStream(new FileInputStream(datName)); @@ -48,18 +51,20 @@ void fillStorage(String datName, File file) throws IOException, ParseException { int offset = 0; String keyForMap = ""; String value = ""; + String aLL = new String(data); while (counter < file.length()) { offset = data[counter]; keyForMap = new String(data, counter + 2, offset - 2, StandardCharsets.UTF_8); counter = counter + offset + 1; offset = data[counter]; value = new String(data, counter + 2, data.length - counter - 3, StandardCharsets.UTF_8); + value = value.replaceAll("^\\s*|\\s*$", ""); String tableName = new File(new File(datName).getParent()).getParent(); ObjectStoreable valForMap = (ObjectStoreable) - new ObjectTableProvider().deserialize(new ObjectTable(tableName), value); - storage.put(keyForMap, valForMap); - commitStorage.put(keyForMap, valForMap); - counter = counter + offset + 1; + new ObjectTableProvider().deserialize(new ObjectTable(tableName), value); + currentTableObject.storage.put(keyForMap, valForMap); + currentTableObject.commitStorage.put(keyForMap, valForMap); + counter = counter + offset + 3; } stream.close(); } From bd030d1df4e990c04ba5b1c5f1c8a79e7e981fbe Mon Sep 17 00:00:00 2001 From: MaximGotovchits Date: Mon, 22 Dec 2014 17:11:24 +0300 Subject: [PATCH 09/18] =?UTF-8?q?=D0=93=D0=BE=D1=82=D0=BE=D0=B2=D1=87?= =?UTF-8?q?=D0=B8=D1=86=20=D0=9C=D0=B0=D0=BA=D1=81=D0=B8=D0=BC,=20396,=20S?= =?UTF-8?q?torable?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Premium Edition 1.1 --- .../Storeable/CommandsTools.java | 2 +- .../Storeable/Interpreter.java | 28 +++-- .../Storeable/ObjectTable.java | 49 ++------ .../Storeable/ObjectTableProvider.java | 118 +++++++----------- 4 files changed, 75 insertions(+), 122 deletions(-) diff --git a/src/ru/fizteh/fivt/students/MaximGotovchits/Storeable/CommandsTools.java b/src/ru/fizteh/fivt/students/MaximGotovchits/Storeable/CommandsTools.java index 00cd368ac..2724ad229 100644 --- a/src/ru/fizteh/fivt/students/MaximGotovchits/Storeable/CommandsTools.java +++ b/src/ru/fizteh/fivt/students/MaximGotovchits/Storeable/CommandsTools.java @@ -1,7 +1,7 @@ package ru.fizteh.fivt.students.MaximGotovchits.Storeable; public abstract class CommandsTools { - static final String JSON_REG_EX = "\\s*,\\s*(?=(?:(?:[^\"]*\"){2})*[^\"]*$)"; // Removes the braces + static final String JSON_REG_EX = "\\s*,\\s*(?=(?:(?:[^\"]*\"){2})*[^\"]*$)"; // Removes commas // outside of "...". static String usingTableName = new String(); static ObjectTable currentTableObject; diff --git a/src/ru/fizteh/fivt/students/MaximGotovchits/Storeable/Interpreter.java b/src/ru/fizteh/fivt/students/MaximGotovchits/Storeable/Interpreter.java index 01f7228b1..7281615db 100644 --- a/src/ru/fizteh/fivt/students/MaximGotovchits/Storeable/Interpreter.java +++ b/src/ru/fizteh/fivt/students/MaximGotovchits/Storeable/Interpreter.java @@ -34,7 +34,7 @@ private void executionFunction(String[] cmd, boolean fromCmdLine) throws Excepti typeList = getTypeList(createParameter, fromCmdLine); new ObjectTableProvider().createTable(tableName, typeList); } catch (Exception e) { - printExceptionMessage(e); + System.err.println(e); } ifContinue(fromCmdLine); } @@ -67,7 +67,7 @@ private void executionFunction(String[] cmd, boolean fromCmdLine) throws Excepti deserialize(currentTableObject, putParameter); currentTableObject.put(key, value); } catch (Exception e) { - printExceptionMessage(e); + System.err.println(e); } } else { informToChooseTable(); @@ -86,10 +86,14 @@ private void executionFunction(String[] cmd, boolean fromCmdLine) throws Excepti } if (cmd[0].equals("get") && cmd.length == 2) { - if (tableIsChosen) { - currentTableObject.get(cmd[1]); - } else { - informToChooseTable(); + try { + if (tableIsChosen) { + currentTableObject.get(cmd[1]); + } else { + informToChooseTable(); + } + } catch (Exception e) { + System.out.println(e); } ifContinue(fromCmdLine); } @@ -105,7 +109,11 @@ private void executionFunction(String[] cmd, boolean fromCmdLine) throws Excepti if (cmd[0].equals("remove") && cmd.length == 2) { if (tableIsChosen) { - currentTableObject.remove(cmd[1]); + try { + currentTableObject.remove(cmd[1]); + } catch (Exception e) { + System.err.println(e); + } } else { informToChooseTable(); } @@ -113,7 +121,11 @@ private void executionFunction(String[] cmd, boolean fromCmdLine) throws Excepti } if (cmd[0].equals("drop") && cmd.length == 2) { - new ObjectTableProvider().removeTable(cmd[1]); + try { + new ObjectTableProvider().removeTable(cmd[1]); + } catch (Exception e) { + + } ifContinue(fromCmdLine); } diff --git a/src/ru/fizteh/fivt/students/MaximGotovchits/Storeable/ObjectTable.java b/src/ru/fizteh/fivt/students/MaximGotovchits/Storeable/ObjectTable.java index 468cb46fc..68e57ba89 100644 --- a/src/ru/fizteh/fivt/students/MaximGotovchits/Storeable/ObjectTable.java +++ b/src/ru/fizteh/fivt/students/MaximGotovchits/Storeable/ObjectTable.java @@ -13,8 +13,8 @@ public class ObjectTable extends CommandsTools implements Table { static int overwriteNum = 0; public Stack lastChanges = new Stack(); - public Map storage = new HashMap(); - public Map commitStorage = new HashMap(); + public Map storage = new HashMap<>(); + public Map commitStorage = new HashMap<>(); public String tableName = new String(); public List> typeKeeper = new LinkedList>(); public ObjectTable() { @@ -76,13 +76,8 @@ public String getName() { public Storeable get(String key) throws IllegalArgumentException { // В документации в Index // не сказано, когда кидать ParseException, однако согласно интерфейсу тут все-таки написано // throws ParseException, но на самом деле это исключение тут не бросатется. - try { - if (key == null) { - throw new IllegalArgumentException(); - } - } catch (IllegalArgumentException s) { - System.err.println(s); - return null; + if (key == null) { + throw new IllegalArgumentException(); } ObjectStoreable value = storage.get(key); if (value == null) { @@ -96,21 +91,11 @@ public Storeable get(String key) throws IllegalArgumentException { // В док } @Override public Storeable put(String key, Storeable value) throws ColumnFormatException { - try { - if (key == null || value == null) { - throw new IllegalArgumentException(); - } - } catch (IllegalArgumentException s) { - System.err.println(s); - return null; + if (key == null || value == null) { + throw new IllegalArgumentException(); } - try { - if (!this.typeKeeper.equals(((ObjectStoreable) value).typeKeeper)) { - throw new ColumnFormatException(); - } - } catch (ColumnFormatException s) { - System.err.println(s); - return null; + if (!this.typeKeeper.equals(((ObjectStoreable) value).typeKeeper)) { + throw new ColumnFormatException(); } ObjectStoreable previousValue = storage.put(key, (ObjectStoreable) value); if (previousValue == null) { @@ -129,13 +114,8 @@ public Storeable put(String key, Storeable value) throws ColumnFormatException { } @Override public Storeable remove(String key) { - try { - if (key == null) { - throw new IllegalArgumentException(); - } - } catch (IllegalArgumentException s) { - System.err.println(s); - return null; + if (key == null) { + throw new IllegalArgumentException(); } ObjectStoreable value = storage.remove(key); commitStorage.remove(key); @@ -209,13 +189,8 @@ public int getColumnsCount() { } @Override public Class getColumnType(int columnIndex) throws IndexOutOfBoundsException { - try { - if (this.getColumnsCount() < columnIndex - 1) { - throw new IndexOutOfBoundsException(); - } - } catch (IndexOutOfBoundsException s) { - System.err.println(s); - return null; + if (this.getColumnsCount() < columnIndex - 1) { + throw new IndexOutOfBoundsException(); } Class objectToReturn = typeKeeper.get(columnIndex); return objectToReturn; diff --git a/src/ru/fizteh/fivt/students/MaximGotovchits/Storeable/ObjectTableProvider.java b/src/ru/fizteh/fivt/students/MaximGotovchits/Storeable/ObjectTableProvider.java index 2c44e5225..a143ec6dc 100644 --- a/src/ru/fizteh/fivt/students/MaximGotovchits/Storeable/ObjectTableProvider.java +++ b/src/ru/fizteh/fivt/students/MaximGotovchits/Storeable/ObjectTableProvider.java @@ -26,10 +26,7 @@ public int hashCode() { @Override public boolean equals(Object obj) { ObjectTableProvider tempObj = (ObjectTableProvider) obj; - if (tempObj.rootDirectory.equals(this.rootDirectory)) { - return true; - } - return false; + return tempObj.rootDirectory.equals(this.rootDirectory); } @Override public Table getTable(String name) throws IllegalArgumentException { @@ -40,7 +37,7 @@ public Table getTable(String name) throws IllegalArgumentException { return null; } @Override - public Table createTable(String name, List> columnTypes) throws IOException { + public Table createTable(String name, List> columnTypes) throws IOException, IllegalArgumentException { checkException(name); File file = new File(rootDirectory + File.separator + name); File signatureFile = new File(rootDirectory + File.separator + name + File.separator + signatureFileName); @@ -67,36 +64,28 @@ public Table createTable(String name, List> columnTypes) throws IOExcep } @Override public void removeTable(String name) throws IllegalArgumentException, IllegalStateException { - try { - if (name == null || name.length() > longestName) { - throw new IllegalArgumentException(); - } - String tableName = rootDirectory + File.separator + name; - File toBeRemoved = new File(tableName); - if (toBeRemoved.exists()) { - if (tableIsChosen) { - if (usingTableName.equals(name)) { - currentTableObject.storage.clear(); - currentTableObject.commitStorage.clear(); - //currentTableObject.uncommitedChanges = 0; - tableIsChosen = false; - usingTableName = null; - } + if (name == null || name.length() > longestName) { + throw new IllegalArgumentException(); + } + String tableName = rootDirectory + File.separator + name; + File toBeRemoved = new File(tableName); + if (toBeRemoved.exists()) { + if (tableIsChosen) { + if (usingTableName.equals(name)) { + currentTableObject.storage.clear(); + currentTableObject.commitStorage.clear(); + tableIsChosen = false; + usingTableName = null; } - recRem(tableName); - toBeRemoved.delete(); - System.out.println("dropped"); - } else { - throw new IllegalStateException(); } - } catch (IllegalArgumentException s) { - System.err.println(s); - return; - } catch (IllegalStateException s) { - System.err.println(s); - return; + recRem(tableName); + toBeRemoved.delete(); + System.out.println("dropped"); + } else { + throw new IllegalStateException(); } } + @Override public Storeable deserialize(Table table, String value) throws ParseException { ObjectTable usingTable = (ObjectTable) table; @@ -114,16 +103,12 @@ public Storeable deserialize(Table table, String value) throws ParseException { int index = 0; List> typeList = new LinkedList<>(); for (String str : tempValue) { - try { - Object val = getValue(str, usingTable, usingTable.typeKeeper.get(index)); - if (val.equals("^incorrect$")) { - throw new ParseException(value, 0); - } - valueToReturn.subValueList.add(val); - typeList.add(val.getClass()); - } catch (NumberFormatException e) { + Object val = getValue(str, usingTable, usingTable.typeKeeper.get(index)); + if (val.equals("^incorrect$")) { throw new ParseException(value, 0); } + valueToReturn.subValueList.add(val); + typeList.add(val.getClass()); ++index; } valueToReturn.typeKeeper = usingTable.typeKeeper; @@ -134,17 +119,12 @@ public Storeable deserialize(Table table, String value) throws ParseException { public String serialize(Table table, Storeable value) throws ColumnFormatException { ObjectStoreable valueToSerialize = (ObjectStoreable) value; ObjectTable tableObj = (ObjectTable) table; - try { - int index = 0; - for (Class type : tableObj.typeKeeper) { - if (!type.equals(valueToSerialize.typeKeeper.get(index))) { - throw new ColumnFormatException(); - } - ++index; + int index = 0; + for (Class type : tableObj.typeKeeper) { + if (!type.equals(valueToSerialize.typeKeeper.get(index))) { + throw new ColumnFormatException(); } - } catch (ColumnFormatException s) { - System.out.println(s); - return null; + ++index; } return valueToSerialize.serialisedValue; } @@ -158,23 +138,13 @@ public Storeable createFor(Table table) { public Storeable createFor(Table table, List values) throws ColumnFormatException, IndexOutOfBoundsException { int ind = 0; ObjectTable tempTable = new ObjectTable(table); - try { - List> valTypes = new LinkedList>(); - valTypes = convertToPrimitive(values); - if (values.size() != tempTable.getColumnsCount()) { - throw new IndexOutOfBoundsException(); - } - Class tableType; - Class valueType; - if (!valTypes.equals(tempTable.typeKeeper)) { - throw new ColumnFormatException(); - } - } catch (ColumnFormatException s) { - System.err.println(s); - return null; - } catch (IndexOutOfBoundsException s) { - System.err.println(s); - return null; + List> valTypes = new LinkedList>(); + valTypes = convertToPrimitive(values); + if (values.size() != tempTable.getColumnsCount()) { + throw new IndexOutOfBoundsException(); + } + if (!valTypes.equals(tempTable.typeKeeper)) { + throw new ColumnFormatException(); } ObjectStoreable toReturn = new ObjectStoreable(values); toReturn.typeKeeper = tempTable.typeKeeper; @@ -207,7 +177,9 @@ public List getTableNames() { String temp = new String(data, StandardCharsets.UTF_8); recordsAmount += (temp.length() - temp.replaceAll(" ", "").length()) / 4; } - } catch (IOException s) { + } catch (FileNotFoundException e) { + return null; + } catch (IOException e) { return null; } } @@ -298,16 +270,10 @@ void recRem(String myFile) { file.delete(); } - public Object checkException(String name) throws IllegalArgumentException { - try { - if (name == null || name.length() > longestName) { - throw new IllegalArgumentException(); - } - } catch (IllegalArgumentException s) { - System.err.println(s); - return null; + public void checkException(String name) throws IllegalArgumentException { + if (name == null || name.length() > longestName) { + throw new IllegalArgumentException(); } - return null; } private List> convertToPrimitive(List list) { From 509e8939c375acef4bbdf8b3d2257b5a958d8426 Mon Sep 17 00:00:00 2001 From: MaximGotovchits Date: Mon, 22 Dec 2014 17:20:25 +0300 Subject: [PATCH 10/18] Edite --- .../fivt/students/MaximGotovchits/Storeable/Interpreter.java | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/ru/fizteh/fivt/students/MaximGotovchits/Storeable/Interpreter.java b/src/ru/fizteh/fivt/students/MaximGotovchits/Storeable/Interpreter.java index 7281615db..33b264c37 100644 --- a/src/ru/fizteh/fivt/students/MaximGotovchits/Storeable/Interpreter.java +++ b/src/ru/fizteh/fivt/students/MaximGotovchits/Storeable/Interpreter.java @@ -124,7 +124,7 @@ private void executionFunction(String[] cmd, boolean fromCmdLine) throws Excepti try { new ObjectTableProvider().removeTable(cmd[1]); } catch (Exception e) { - + System.err.println(e); } ifContinue(fromCmdLine); } From 24bcb5e7bf124add3fd4fe14dfacb81e38f87bd8 Mon Sep 17 00:00:00 2001 From: MaximGotovchits Date: Wed, 24 Dec 2014 13:08:41 +0300 Subject: [PATCH 11/18] =?UTF-8?q?=D0=93=D0=BE=D1=82=D0=BE=D0=B2=D1=87?= =?UTF-8?q?=D0=B8=D1=86=20=D0=9C=D0=B0=D0=BA=D1=81=D0=B8=D0=BC,=20396,=20P?= =?UTF-8?q?arallel?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit No Tests Edition --- .../Parallel/CommandsTools.java | 17 + .../MaximGotovchits/Parallel/Exit.java | 24 ++ .../MaximGotovchits/Parallel/FillTable.java | 37 ++ .../MaximGotovchits/Parallel/Interpreter.java | 222 ++++++++++++ .../MaximGotovchits/Parallel/Main.java | 18 + .../MaximGotovchits/Parallel/MakeDirs.java | 24 ++ .../Parallel/ObjectStoreable.java | 232 +++++++++++++ .../MaximGotovchits/Parallel/ObjectTable.java | 232 +++++++++++++ .../Parallel/ObjectTableProvider.java | 328 ++++++++++++++++++ .../Parallel/ObjectTableProviderFactory.java | 21 ++ .../Parallel/Test/ObjectStoreableTest.java | 109 ++++++ .../Test/ObjectTableProviderFactoryTest.java | 15 + .../Test/ObjectTableProviderTest.java | 86 +++++ .../Parallel/Test/ObjectTableTest.java | 127 +++++++ .../MaximGotovchits/Parallel/Use.java | 71 ++++ 15 files changed, 1563 insertions(+) create mode 100644 src/ru/fizteh/fivt/students/MaximGotovchits/Parallel/CommandsTools.java create mode 100644 src/ru/fizteh/fivt/students/MaximGotovchits/Parallel/Exit.java create mode 100644 src/ru/fizteh/fivt/students/MaximGotovchits/Parallel/FillTable.java create mode 100644 src/ru/fizteh/fivt/students/MaximGotovchits/Parallel/Interpreter.java create mode 100644 src/ru/fizteh/fivt/students/MaximGotovchits/Parallel/Main.java create mode 100644 src/ru/fizteh/fivt/students/MaximGotovchits/Parallel/MakeDirs.java create mode 100644 src/ru/fizteh/fivt/students/MaximGotovchits/Parallel/ObjectStoreable.java create mode 100644 src/ru/fizteh/fivt/students/MaximGotovchits/Parallel/ObjectTable.java create mode 100644 src/ru/fizteh/fivt/students/MaximGotovchits/Parallel/ObjectTableProvider.java create mode 100644 src/ru/fizteh/fivt/students/MaximGotovchits/Parallel/ObjectTableProviderFactory.java create mode 100644 src/ru/fizteh/fivt/students/MaximGotovchits/Parallel/Test/ObjectStoreableTest.java create mode 100644 src/ru/fizteh/fivt/students/MaximGotovchits/Parallel/Test/ObjectTableProviderFactoryTest.java create mode 100644 src/ru/fizteh/fivt/students/MaximGotovchits/Parallel/Test/ObjectTableProviderTest.java create mode 100644 src/ru/fizteh/fivt/students/MaximGotovchits/Parallel/Test/ObjectTableTest.java create mode 100644 src/ru/fizteh/fivt/students/MaximGotovchits/Parallel/Use.java diff --git a/src/ru/fizteh/fivt/students/MaximGotovchits/Parallel/CommandsTools.java b/src/ru/fizteh/fivt/students/MaximGotovchits/Parallel/CommandsTools.java new file mode 100644 index 000000000..82b579f4f --- /dev/null +++ b/src/ru/fizteh/fivt/students/MaximGotovchits/Parallel/CommandsTools.java @@ -0,0 +1,17 @@ +package ru.fizteh.fivt.students.MaximGotovchits.Parallel; + +public abstract class CommandsTools { + static final String JSON_REG_EX = "\\s*,\\s*(?=(?:(?:[^\"]*\"){2})*[^\"]*$)"; // Removes commas + // outside of "...". + static String usingTableName = new String(); + static ObjectTable currentTableObject; + static String dataBaseName = System.getProperty("fizteh.db.dir"); + static String signatureFileName = "signature.tsv"; + static Integer dirNum = 16; + static Integer fileNum = 16; + static String dirExt = ".dir"; + static String fileExt = ".dat"; + static int longestName = 260; + static Boolean tableIsChosen = false; +} + diff --git a/src/ru/fizteh/fivt/students/MaximGotovchits/Parallel/Exit.java b/src/ru/fizteh/fivt/students/MaximGotovchits/Parallel/Exit.java new file mode 100644 index 000000000..9a912dbf3 --- /dev/null +++ b/src/ru/fizteh/fivt/students/MaximGotovchits/Parallel/Exit.java @@ -0,0 +1,24 @@ +package ru.fizteh.fivt.students.MaximGotovchits.Parallel; + +public class Exit extends CommandsTools { + void exitFunction() throws Exception { + if (currentTableObject != null) { + new FillTable().fillTableFunction(currentTableObject); + } + System.exit(0); + } + boolean exitAndUseAvailable() { + if (currentTableObject != null) { + int uncommitedChanges = currentTableObject.storage.get().size() + - currentTableObject.commitStorage.size(); + if (uncommitedChanges == 0 || !tableIsChosen) { + return true; + } + System.out.println(uncommitedChanges + " uncommited changes"); + return false; + } + return true; + } +} + + diff --git a/src/ru/fizteh/fivt/students/MaximGotovchits/Parallel/FillTable.java b/src/ru/fizteh/fivt/students/MaximGotovchits/Parallel/FillTable.java new file mode 100644 index 000000000..b2956e423 --- /dev/null +++ b/src/ru/fizteh/fivt/students/MaximGotovchits/Parallel/FillTable.java @@ -0,0 +1,37 @@ +package ru.fizteh.fivt.students.MaximGotovchits.Parallel; + +import java.io.DataOutputStream; +import java.io.File; +import java.io.FileOutputStream; +import java.nio.charset.StandardCharsets; +import java.nio.file.Path; +import java.nio.file.Paths; +import java.util.Map; + +public class FillTable extends CommandsTools { + public void fillTableFunction(ObjectTable usingTable) throws Exception { + for (Map.Entry entry : usingTable.commitStorage.entrySet()) { + int hashCode = entry.getKey().hashCode(); + Integer nDirectory = hashCode % dirNum; + Integer nFile = hashCode / dirNum % fileNum; + Path fileName = Paths.get(dataBaseName + File.separator + usingTable.getName(), nDirectory + dirExt); + File file = new File(fileName.toString()); + if (!file.exists()) { + file.mkdir(); + } + fileName = Paths.get(fileName.toString(), nFile + fileExt); + file = new File(fileName.toString()); + if (!file.exists()) { + file.createNewFile(); + } + byte[] bytesKey = (" " + entry.getKey() + " ").getBytes(StandardCharsets.UTF_8); + DataOutputStream stream = new DataOutputStream(new FileOutputStream(fileName.toString(), true)); + stream.write((int) bytesKey.length); + stream.write(bytesKey); + byte[] bytesVal = ((" " + entry.getValue().serialisedValue + " ").getBytes(StandardCharsets.UTF_8)); + stream.write((int) bytesVal.length - 1); + stream.write(bytesVal); + stream.close(); + } + } +} diff --git a/src/ru/fizteh/fivt/students/MaximGotovchits/Parallel/Interpreter.java b/src/ru/fizteh/fivt/students/MaximGotovchits/Parallel/Interpreter.java new file mode 100644 index 000000000..a825c686a --- /dev/null +++ b/src/ru/fizteh/fivt/students/MaximGotovchits/Parallel/Interpreter.java @@ -0,0 +1,222 @@ +package ru.fizteh.fivt.students.MaximGotovchits.Parallel; + +import java.util.*; + +public class Interpreter extends CommandsTools { + private final String invitationalSymbol = "$ "; + + void parseDataFromCmdLine(String cmdLine) throws Exception { + String[] splittedLine = cmdLine.split("\\s*;\\s*"); + for (String line : splittedLine) { + String[] cmd = line.split("\\s+"); + executionFunction(cmd, true); // True means that data is from command line. + } + } + + void getCmdFromStream() throws Exception { + Scanner scan = new Scanner(System.in); + System.out.print(invitationalSymbol); + String[] cmd = scan.nextLine().split("\\s+"); + executionFunction(cmd, false); // False means that data is from "System.in". + } + + private void executionFunction(String[] cmd, boolean fromCmdLine) throws Exception { // The main interpreter + // function. + if (cmd[0].equals("create") && cmd.length > 2) { + String createParameter = new String(); // (...) - type list. + String tableName = cmd[1]; + for (int ind = 2; ind < cmd.length; ++ind) { + createParameter += cmd[ind] + " "; + } + createParameter = createParameter.substring(0, createParameter.length() - 1); + List> typeList = new LinkedList<>(); + try { + typeList = getTypeList(createParameter, fromCmdLine); + new ObjectTableProvider().createTable(tableName, typeList); + } catch (Exception e) { + System.err.println(e); + } + ifContinue(fromCmdLine); + } + + if (cmd[0].equals("use") && cmd.length == 2) { + String tableName = cmd[1]; + boolean changeUsingTable = false; + try { + if (tableIsChosen) { + new Use().useFunction(tableName, currentTableObject.getName()); + } else { + tableIsChosen = new Use().useFunction(tableName, null); + } + } catch (Exception e) { + printExceptionMessage(e); + } + ifContinue(fromCmdLine); + } + + if (cmd[0].equals("put") && cmd.length > 2) { + if (tableIsChosen) { + String putParameter = new String(); + String key = cmd[1]; + for (int ind = 2; ind < cmd.length; ++ind) { + putParameter += cmd[ind] + " "; + } + putParameter = putParameter.substring(0, putParameter.length() - 1); + try { + ObjectStoreable value = (ObjectStoreable) new ObjectTableProvider(). + deserialize(currentTableObject, putParameter); + currentTableObject.put(key, value); + } catch (Exception e) { + System.err.println(e); + } + } else { + informToChooseTable(); + } + ifContinue(fromCmdLine); + } + + if (cmd[0].equals("commit") && cmd.length == 1) { + currentTableObject.commit(); + ifContinue(fromCmdLine); + } + + if (cmd[0].equals("show") && cmd[1].equals("tables") && cmd.length == 2) { + new ObjectTableProvider().getTableNames(); + ifContinue(fromCmdLine); + } + + if (cmd[0].equals("get") && cmd.length == 2) { + try { + if (tableIsChosen) { + currentTableObject.get(cmd[1]); + } else { + informToChooseTable(); + } + } catch (Exception e) { + System.out.println(e); + } + ifContinue(fromCmdLine); + } + + if (cmd[0].equals("list") && cmd.length == 1) { + if (tableIsChosen) { + currentTableObject.list(); + } else { + informToChooseTable(); + } + ifContinue(fromCmdLine); + } + + if (cmd[0].equals("remove") && cmd.length == 2) { + if (tableIsChosen) { + try { + currentTableObject.remove(cmd[1]); + } catch (Exception e) { + System.err.println(e); + } + } else { + informToChooseTable(); + } + ifContinue(fromCmdLine); + } + + if (cmd[0].equals("drop") && cmd.length == 2) { + try { + new ObjectTableProvider().removeTable(cmd[1]); + } catch (Exception e) { + System.err.println(e); + } + ifContinue(fromCmdLine); + } + + if (cmd[0].equals("rollback") && cmd.length == 1) { + currentTableObject.rollback(); + ifContinue(fromCmdLine); + } + + if (cmd[0].equals("exit") && cmd.length == 1) { + if (fromCmdLine) { + currentTableObject.commit(); + new Exit().exitFunction(); + } else { + if (new Exit().exitAndUseAvailable()) { + new Exit().exitFunction(); + } + } + ifContinue(fromCmdLine); + } + if (cmd.length != 0) { + syntaxError(); + } + ifContinue(fromCmdLine); + } + + void informToChooseTable() { + System.err.println("table is not chosen"); + } + + void ifContinue(boolean fromCmdLine) throws Exception { + if (fromCmdLine) { + return; + } else { + getCmdFromStream(); + } + } + + private void printExceptionMessage(Exception e) { + System.err.println(e); + } + + private List> getTypeList(String line, boolean fromCmdLine) throws Exception { + List> typeList = new LinkedList>(); + line = line.replaceAll("\\s*\\)\\s*", ""); + line = line.replaceAll("\\s*\\(\\s*", ""); + String[] tmp = line.split("\\s+"); + for (String str : tmp) { + Class type = getType(str); + if (type != null) { + typeList.add(type); + } else { + syntaxError(); + if (fromCmdLine) { + System.exit(1); + } else { + getCmdFromStream(); + } + } + } + return typeList; + } + + private Class getType(String str) { + if (str.equals("int")) { + return int.class; + } + if (str.equals("long")) { + return long.class; + } + if (str.equals("double")) { + return double.class; + } + if (str.equals("float")) { + return float.class; + } + if (str.equals("double")) { + return double.class; + } + if (str.equals("boolean")) { + return boolean.class; + } + if (str.equals("byte")) { + return byte.class; + } + if (str.equals("String")) { + return String.class; + } + return null; + } + + void syntaxError() { + System.err.println("incorrect syntax"); + } +} diff --git a/src/ru/fizteh/fivt/students/MaximGotovchits/Parallel/Main.java b/src/ru/fizteh/fivt/students/MaximGotovchits/Parallel/Main.java new file mode 100644 index 000000000..b6c3953d8 --- /dev/null +++ b/src/ru/fizteh/fivt/students/MaximGotovchits/Parallel/Main.java @@ -0,0 +1,18 @@ +package ru.fizteh.fivt.students.MaximGotovchits.Parallel; + +public class Main { // Using JSON format. + public static void main(final String[] args) throws Exception { + new MakeDirs().makeDirsFunction(); + if (args.length == 0) { + new Interpreter().getCmdFromStream(); + } else { + String cmd = new String(); + for (String arg : args) { + cmd += arg + " "; + } + cmd = cmd.replaceAll("\\s+", " "); + new Interpreter().parseDataFromCmdLine(cmd.substring(0, cmd.length() - 1)); + new Exit().exitFunction(); + } + } +} diff --git a/src/ru/fizteh/fivt/students/MaximGotovchits/Parallel/MakeDirs.java b/src/ru/fizteh/fivt/students/MaximGotovchits/Parallel/MakeDirs.java new file mode 100644 index 000000000..3ce3dfdc5 --- /dev/null +++ b/src/ru/fizteh/fivt/students/MaximGotovchits/Parallel/MakeDirs.java @@ -0,0 +1,24 @@ +package ru.fizteh.fivt.students.MaximGotovchits.Parallel; + +import java.io.File; + +public class MakeDirs extends CommandsTools { + void makeDirsFunction() throws Exception { + File file = new File(dataBaseName); + if (!file.exists()) { + file.mkdirs(); + } else { + if (!file.isDirectory()) { + System.err.println(dataBaseName + " is not a directory"); + System.exit(1); + } else { + for (File sub : file.listFiles()) { + if (!sub.isDirectory() && !sub.isHidden()) { + System.err.println(dataBaseName + File.separator + + sub.getName() + " is not a directory"); + } + } + } + } + } +} diff --git a/src/ru/fizteh/fivt/students/MaximGotovchits/Parallel/ObjectStoreable.java b/src/ru/fizteh/fivt/students/MaximGotovchits/Parallel/ObjectStoreable.java new file mode 100644 index 000000000..588c55982 --- /dev/null +++ b/src/ru/fizteh/fivt/students/MaximGotovchits/Parallel/ObjectStoreable.java @@ -0,0 +1,232 @@ +package ru.fizteh.fivt.students.MaximGotovchits.Parallel; + +import ru.fizteh.fivt.storage.structured.ColumnFormatException; +import ru.fizteh.fivt.storage.structured.Storeable; +import java.text.ParseException; +import java.util.LinkedList; +import java.util.List; +import java.util.Objects; + +public class ObjectStoreable extends CommandsTools implements Storeable { + public List subValueList = new LinkedList<>(); + public String serialisedValue = new String(); + public List> typeKeeper = new LinkedList<>(); + public ObjectStoreable() {} + public ObjectStoreable(List values) { + int ind = 0; + serialisedValue = "["; + for (Object val : values) { + subValueList.add(val); + serialisedValue += val + ", "; + } + serialisedValue = serialisedValue.substring(0, serialisedValue.length() - 2); + serialisedValue += "]"; + } + public ObjectStoreable(Storeable value) { + subValueList = ((ObjectStoreable) value).subValueList; + serialisedValue = ((ObjectStoreable) value).serialisedValue; + typeKeeper = ((ObjectStoreable) value).typeKeeper; + } + public ObjectStoreable(ObjectTable table) { + typeKeeper = table.typeKeeper; + } + public ObjectStoreable(String value) throws ParseException { + ObjectStoreable obj = (ObjectStoreable) new ObjectTableProvider().deserialize(currentTableObject, value); + if (obj == null) { + return; + } + subValueList = obj.subValueList; + serialisedValue = obj.serialisedValue; + typeKeeper = obj.typeKeeper; + } + @Override + public int hashCode() { + return Objects.hashCode(this.serialisedValue); + } + @Override + public boolean equals(Object obj) { + ObjectStoreable storeableObj = (ObjectStoreable) obj; + if (this.serialisedValue.equals(storeableObj.serialisedValue) + && this.typeKeeper.equals(storeableObj.typeKeeper) + && this.subValueList.equals(storeableObj.subValueList)) { + return true; + } + return false; + } + @Override + public void setColumnAt(int columnIndex, Object value) throws ColumnFormatException, IndexOutOfBoundsException { + try { + if (columnIndex >= this.subValueList.size()) { + throw new IndexOutOfBoundsException(); + } + List> toConvert = new LinkedList<>(); + toConvert.add(value.getClass()); + toConvert = convertToPrimitive(toConvert); + if (!typeKeeper.get(columnIndex).equals(toConvert.get(0))) { + throw new ColumnFormatException(); + } + } catch (IndexOutOfBoundsException s) { + System.err.println(s); + return; + } catch (ColumnFormatException s) { + System.err.println(s); + return; + } + this.subValueList.set(columnIndex, value); + this.serialisedValue = ""; + serialisedValue = "["; + for (Object val : this.subValueList) { + serialisedValue += val + ", "; + } + serialisedValue = serialisedValue.substring(0, serialisedValue.length() - 2); // Откусить ", ". + serialisedValue += "]"; + return; + } + @Override + public Object getColumnAt(int columnIndex) throws IndexOutOfBoundsException { + if (subValueList.size() < columnIndex - 1) { + throw new IndexOutOfBoundsException(); + } + return subValueList.get(columnIndex); + } + @Override + public Integer getIntAt(int columnIndex) throws ColumnFormatException, IndexOutOfBoundsException { + if (columnIndex >= subValueList.size()) { + throw new IndexOutOfBoundsException(); + } + if (!this.typeKeeper.get(columnIndex).equals(int.class)) { + throw new ColumnFormatException(); + } + return (Integer) subValueList.get(columnIndex); + } + @Override + public Long getLongAt(int columnIndex) throws ColumnFormatException, IndexOutOfBoundsException { + try { + if (columnIndex >= this.typeKeeper.size()) { + throw new IndexOutOfBoundsException(); + } + if (!typeKeeper.get(columnIndex).equals(long.class)) { + throw new ColumnFormatException(); + } + } catch (IndexOutOfBoundsException s) { + System.err.println(s); + } catch (ColumnFormatException s) { + System.err.println(s); + } + return (Long) subValueList.get(columnIndex); + } + @Override + public Byte getByteAt(int columnIndex) throws ColumnFormatException, IndexOutOfBoundsException { + try { + if (columnIndex >= this.typeKeeper.size()) { + throw new IndexOutOfBoundsException(); + } + if (!typeKeeper.get(columnIndex).equals(byte.class)) { + throw new ColumnFormatException(); + } + } catch (IndexOutOfBoundsException s) { + System.err.println(s); + } catch (ColumnFormatException s) { + System.err.println(s); + } + return (Byte) subValueList.get(columnIndex); + } + @Override + public Float getFloatAt(int columnIndex) throws ColumnFormatException, IndexOutOfBoundsException { + try { + if (columnIndex >= this.typeKeeper.size()) { + throw new IndexOutOfBoundsException(); + } + if (!typeKeeper.get(columnIndex).equals(float.class)) { + throw new ColumnFormatException(); + } + } catch (IndexOutOfBoundsException s) { + System.err.println(s); + } catch (ColumnFormatException s) { + System.err.println(s); + } + return (Float) subValueList.get(columnIndex); + } + @Override + public Double getDoubleAt(int columnIndex) throws ColumnFormatException, IndexOutOfBoundsException { + try { + if (columnIndex >= this.typeKeeper.size()) { + throw new IndexOutOfBoundsException(); + } + if (!typeKeeper.get(columnIndex).equals(double.class)) { + throw new ColumnFormatException(); + } + } catch (IndexOutOfBoundsException s) { + System.err.println(s); + } catch (ColumnFormatException s) { + System.err.println(s); + } + return (Double) subValueList.get(columnIndex); + } + @Override + public Boolean getBooleanAt(int columnIndex) throws ColumnFormatException, IndexOutOfBoundsException { + try { + if (columnIndex >= this.typeKeeper.size()) { + throw new IndexOutOfBoundsException(); + } + if (!typeKeeper.get(columnIndex).equals(boolean.class)) { + throw new ColumnFormatException(); + } + } catch (IndexOutOfBoundsException s) { + System.err.println(s); + } catch (ColumnFormatException s) { + System.err.println(s); + } + return (Boolean) subValueList.get(columnIndex); + } + @Override + public String getStringAt(int columnIndex) throws ColumnFormatException, IndexOutOfBoundsException { + try { + if (columnIndex >= this.typeKeeper.size()) { + throw new IndexOutOfBoundsException(); + } + if (!typeKeeper.get(columnIndex).equals(String.class)) { + throw new ColumnFormatException(); + } + } catch (IndexOutOfBoundsException s) { + System.err.println(s); + } catch (ColumnFormatException s) { + System.err.println(s); + } + return subValueList.get(columnIndex).toString(); + } + private List> convertToPrimitive(List> list) { + List> toReturn = new LinkedList<>(); + for (Class object : list) { + if (object.equals(Integer.class)) { + toReturn.add(int.class); + continue; + } + if (object.equals(Long.class)) { + toReturn.add(long.class); + continue; + } + if (object.equals(Boolean.class)) { + toReturn.add(boolean.class); + continue; + } + if (object.equals(String.class)) { + toReturn.add(String.class); + continue; + } + if (object.equals(Byte.class)) { + toReturn.add(byte.class); + continue; + } + if (object.equals(Double.class)) { + toReturn.add(double.class); + continue; + } + if (object.equals(Float.class)) { + toReturn.add(float.class); + continue; + } + } + return toReturn; + } +} diff --git a/src/ru/fizteh/fivt/students/MaximGotovchits/Parallel/ObjectTable.java b/src/ru/fizteh/fivt/students/MaximGotovchits/Parallel/ObjectTable.java new file mode 100644 index 000000000..61e5f8b3c --- /dev/null +++ b/src/ru/fizteh/fivt/students/MaximGotovchits/Parallel/ObjectTable.java @@ -0,0 +1,232 @@ +package ru.fizteh.fivt.students.MaximGotovchits.Parallel; + +import ru.fizteh.fivt.storage.structured.ColumnFormatException; +import ru.fizteh.fivt.storage.structured.Storeable; +import ru.fizteh.fivt.storage.structured.Table; +import java.io.File; +import java.io.IOException; +import java.nio.charset.Charset; +import java.nio.file.Files; +import java.nio.file.Paths; +import java.util.*; + +public class ObjectTable extends CommandsTools implements Table { + static int overwriteNum = 0; + + public ThreadLocal lastChanges = new ThreadLocal() { + @Override + protected Stack initialValue() { + return new Stack(); + } + }; + public ThreadLocal> storage = new ThreadLocal>() { + @Override + protected HashMap initialValue() { + return new HashMap(); + } + }; + public Map commitStorage = new HashMap<>(); + public String tableName = new String(); + public List> typeKeeper = new LinkedList>(); + public ObjectTable(Table table) { + ObjectTable temp = (ObjectTable) table; + this.tableName = temp.tableName; + this.typeKeeper = temp.typeKeeper; + } + public ObjectTable(String name) { + if (!new File(name).isAbsolute()) { + name = dataBaseName + File.separator + name; + } + this.tableName = new File(name).getName(); + String content = new String(); + try { + if (!new File(name + File.separator + signatureFileName).isAbsolute()) { + name = dataBaseName + File.separator + name; + } + content = readFile(name + File.separator + signatureFileName, Charset.defaultCharset()); + content.replaceAll("\\s+", " "); + String[] types = content.split(" "); + int ind = 0; + for (String type : types) { + typeKeeper.add(ind, getType(type)); + ++ind; + } + } catch (IOException s) { + System.err.println(s); + } + } + public ObjectTable(String name, List> typeList) { + int ind = 0; + for (Class type : typeList) { + typeKeeper.add(type); + } + tableName = name; + } + @Override + public int hashCode() { + return Objects.hashCode(this.tableName); + } + @Override + public boolean equals(Object obj) { + ObjectTable tableObj = (ObjectTable) obj; + if (this.tableName.equals(tableObj.tableName) && this.typeKeeper.equals(tableObj.typeKeeper)) { + return true; + } + return false; + } + @Override + public String getName() { + return tableName; + } + @Override + public Storeable get(String key) throws IllegalArgumentException { // В документации в Index + // не сказано, когда кидать ParseException, однако согласно интерфейсу тут все-таки написано + // throws ParseException, но на самом деле это исключение тут не бросатется. + if (key == null) { + throw new IllegalArgumentException(); + } + ObjectStoreable value = storage.get().get(key); + if (value == null) { + System.err.println("not found"); + return null; + } + String serializedValue = value.serialisedValue; + System.out.println("found"); + System.out.println(serializedValue); + return value; + } + @Override + public Storeable put(String key, Storeable value) throws ColumnFormatException { + if (key == null || value == null) { + throw new IllegalArgumentException(); + } + if (!this.typeKeeper.equals(((ObjectStoreable) value).typeKeeper)) { + throw new ColumnFormatException(); + } + ObjectStoreable previousValue = storage.get().put(key, (ObjectStoreable) value); + if (previousValue == null) { + lastChanges.get().push(key); + lastChanges.get().push("remove"); + System.out.println("new"); + } else { + System.out.println("overwrite"); + lastChanges.get().push(previousValue); + lastChanges.get().push(key); + lastChanges.get().push("put"); + ++overwriteNum; + System.out.println(previousValue.serialisedValue); + } + return previousValue; + } + @Override + public Storeable remove(String key) { + if (key == null) { + throw new IllegalArgumentException(); + } + ObjectStoreable value = storage.get().remove(key); + commitStorage.remove(key); + if (value != null) { + lastChanges.get().push(value); + lastChanges.get().push(key); + lastChanges.get().push("put"); + System.out.println("removed"); + } else { + System.out.println("not found"); + } + return value; + } + @Override + public int size() { + return storage.get().size(); + } + @Override + public List list() { + LinkedList list = new LinkedList(); + int size = 0; + Set k = storage.get().keySet(); + for (Object iter : k) { + list.add(iter.toString()); + if (size < storage.get().size() - 1) { + System.out.print(iter + ", "); + } else { + System.out.print(iter); + } + ++size; + } + if (size != 0) { + System.out.println(); + } + return list; + } + @Override + public synchronized int commit() { + int savedKeys = Math.abs(storage.get().size() - commitStorage.size()); + commitStorage = new HashMap(storage.get()); + lastChanges.get().clear(); + return savedKeys; + } + @Override + public int rollback() throws IllegalArgumentException { + int changes = Math.abs(storage.get().size() - commitStorage.size() + overwriteNum); + while (!lastChanges.get().isEmpty()) { + Object tmpCmd = lastChanges.get().pop(); + if (tmpCmd.equals("put")) { + String key = lastChanges.get().pop().toString(); + ObjectStoreable value = (ObjectStoreable) lastChanges.get().pop(); + storage.get().put(key, value); + } + if (tmpCmd.equals("remove")) { + String key = lastChanges.get().pop().toString(); + storage.get().remove(key); + } + } + overwriteNum = 0; + return changes; + } + @Override + public int getNumberOfUncommittedChanges() { + int numberOfUncommitedChanges = Math.abs(storage.get().size() - commitStorage.size()); + return numberOfUncommitedChanges; + } + @Override + public int getColumnsCount() { + return typeKeeper.size(); + } + @Override + public Class getColumnType(int columnIndex) throws IndexOutOfBoundsException { + if (this.getColumnsCount() < columnIndex - 1) { + throw new IndexOutOfBoundsException(); + } + Class objectToReturn = typeKeeper.get(columnIndex); + return objectToReturn; + } + static String readFile(String path, Charset encoding) throws IOException { + byte[] encoded = Files.readAllBytes(Paths.get(path)); + String temp = new String(encoded, encoding); + return temp.replaceAll("^\\s*|\\s*$", ""); + } + private Class getType(String typeName) { + if (typeName.equals("int")) { + return int.class; + } + if (typeName.equals("long")) { + return long.class; + } + if (typeName.equals("byte")) { + return byte.class; + } + if (typeName.equals("float")) { + return float.class; + } + if (typeName.equals("double")) { + return double.class; + } + if (typeName.equals("boolean")) { + return boolean.class; + } + if (typeName.equals("String")) { + return String.class; + } + return null; + } +} diff --git a/src/ru/fizteh/fivt/students/MaximGotovchits/Parallel/ObjectTableProvider.java b/src/ru/fizteh/fivt/students/MaximGotovchits/Parallel/ObjectTableProvider.java new file mode 100644 index 000000000..2ca92ac25 --- /dev/null +++ b/src/ru/fizteh/fivt/students/MaximGotovchits/Parallel/ObjectTableProvider.java @@ -0,0 +1,328 @@ +package ru.fizteh.fivt.students.MaximGotovchits.Parallel; + +import ru.fizteh.fivt.storage.structured.ColumnFormatException; +import ru.fizteh.fivt.storage.structured.Storeable; +import ru.fizteh.fivt.storage.structured.Table; +import ru.fizteh.fivt.storage.structured.TableProvider; +import java.io.*; +import java.nio.charset.StandardCharsets; +import java.text.ParseException; +import java.util.LinkedList; +import java.util.List; +import java.util.Objects; +import java.util.concurrent.locks.ReadWriteLock; +import java.util.concurrent.locks.ReentrantReadWriteLock; + +public class ObjectTableProvider extends CommandsTools implements TableProvider { + private volatile boolean writeSectionIsInUse = false; + private String rootDirectory = new String(); + public ObjectTableProvider() { + rootDirectory = dataBaseName; + } + public ObjectTableProvider(String dir) { + dataBaseName = dir; + rootDirectory = dir; + } + public int hashCode() { + return Objects.hashCode(this.rootDirectory); + } + @Override + public boolean equals(Object obj) { + ObjectTableProvider tempObj = (ObjectTableProvider) obj; + return tempObj.rootDirectory.equals(this.rootDirectory); + } + @Override + public Table getTable(String name) throws IllegalArgumentException { + checkException(name); + ReadWriteLock readWriteLock = new ReentrantReadWriteLock(); + if (new File(rootDirectory + File.separator + name).exists()) { + readWriteLock.readLock().lock(); + ObjectTable tableToReturn = new ObjectTable(rootDirectory + File.separator + name); + readWriteLock.readLock().unlock(); + return tableToReturn; + } + return null; + } + @Override + public Table createTable(String name, List> columnTypes) throws IOException, IllegalArgumentException { + ReadWriteLock readWriteLock = new ReentrantReadWriteLock(); + if (writeSectionIsInUse) { + return null; + } + writeSectionIsInUse = true; + readWriteLock.writeLock().lock(); + checkException(name); + File file = new File(rootDirectory + File.separator + name); + File signatureFile = new File(rootDirectory + File.separator + name + File.separator + signatureFileName); + if (file.exists()) { + System.out.println(name + " exists"); + } else { + file.mkdir(); + signatureFile.createNewFile(); + PrintWriter writer = new PrintWriter(signatureFile, "UTF-8"); + String tempTypes = new String(); + for (Class type : columnTypes) { + if (type.equals(String.class)) { + tempTypes += "String "; + } else { + tempTypes += type.getName() + " "; + } + } + tempTypes = tempTypes.substring(0, tempTypes.length() - 1); + writer.println(tempTypes); + writer.close(); + System.out.println("created"); + } + readWriteLock.writeLock().unlock(); + writeSectionIsInUse = false; + return new ObjectTable(name, columnTypes); + } + @Override + public void removeTable(String name) throws IllegalArgumentException, IllegalStateException { + if (name == null || name.length() > longestName) { + throw new IllegalArgumentException(); + } + String tableName = rootDirectory + File.separator + name; + File toBeRemoved = new File(tableName); + if (toBeRemoved.exists()) { + if (tableIsChosen) { + if (usingTableName.equals(name)) { + currentTableObject.storage.get().clear(); + currentTableObject.commitStorage.clear(); + tableIsChosen = false; + usingTableName = null; + } + } + recRem(tableName); + toBeRemoved.delete(); + System.out.println("dropped"); + } else { + throw new IllegalStateException(); + } + } + + @Override + public Storeable deserialize(Table table, String value) throws ParseException { + ObjectTable usingTable = (ObjectTable) table; + ObjectStoreable valueToReturn = new ObjectStoreable(); + String[] splittedValue = value.split(""); + if (!splittedValue[0].equals("[") || !splittedValue[splittedValue.length - 1].equals("]")) { + throw new ParseException(value, 0); + } + valueToReturn.serialisedValue = value; + value = value.replaceAll("^\\s*\\[\\s*|\\s*\\]\\s*$", ""); // Removing [ and ]. + String[] tempValue = value.split(JSON_REG_EX); // Split by comma. + if (usingTable.getColumnsCount() != tempValue.length) { + throw new ParseException(value, 0); + } + int index = 0; + List> typeList = new LinkedList<>(); + for (String str : tempValue) { + Object val = getValue(str, usingTable, usingTable.typeKeeper.get(index)); + if (val.equals("^incorrect$")) { + throw new ParseException(value, 0); + } + valueToReturn.subValueList.add(val); + typeList.add(val.getClass()); + ++index; + } + valueToReturn.typeKeeper = usingTable.typeKeeper; + return valueToReturn; + } + + @Override + public String serialize(Table table, Storeable value) throws ColumnFormatException { + ObjectStoreable valueToSerialize = (ObjectStoreable) value; + ObjectTable tableObj = (ObjectTable) table; + int index = 0; + for (Class type : tableObj.typeKeeper) { + if (!type.equals(valueToSerialize.typeKeeper.get(index))) { + throw new ColumnFormatException(); + } + ++index; + } + return valueToSerialize.serialisedValue; + } + + @Override + public Storeable createFor(Table table) { + return new ObjectStoreable((ObjectTable) table); + } + + @Override + public Storeable createFor(Table table, List values) throws ColumnFormatException, IndexOutOfBoundsException { + int ind = 0; + ObjectTable tempTable = new ObjectTable(table); + List> valTypes = new LinkedList>(); + valTypes = convertToPrimitive(values); + if (values.size() != tempTable.getColumnsCount()) { + throw new IndexOutOfBoundsException(); + } + if (!valTypes.equals(tempTable.typeKeeper)) { + throw new ColumnFormatException(); + } + ObjectStoreable toReturn = new ObjectStoreable(values); + toReturn.typeKeeper = tempTable.typeKeeper; + return toReturn; + } + + @Override + public List getTableNames() { + List list = new LinkedList(); + String currentFile = new String(); + int recordsAmount = 0; + File file = new File(rootDirectory); + for (File sub : file.listFiles()) { + if ((!sub.isHidden()) && sub.isDirectory()) { + recordsAmount = 0; + for (Integer i = 0; i < dirNum; ++i) { + currentFile = rootDirectory + File.separator + sub.getName() + File.separator + + i + dirExt; + File file1 = new File(currentFile); + if (file1.exists()) { + for (Integer j = 0; j < fileNum; ++j) { + currentFile = rootDirectory + File.separator + sub.getName() + File.separator + + i + dirExt + File.separator + j + fileExt; + file1 = new File(currentFile); + try { + if (file1.exists()) { + DataInputStream stream = new DataInputStream(new FileInputStream(currentFile)); + byte[] data = new byte[(int) file1.length()]; + stream.read(data); + String temp = new String(data, StandardCharsets.UTF_8); + recordsAmount += (temp.length() - temp.replaceAll(" ", "").length()) / 4; + } + } catch (FileNotFoundException e) { + return null; + } catch (IOException e) { + return null; + } + } + } + } + currentFile = new File(new File(new File(currentFile).getParent()).getParent()).getName(); + list.add(sub.getName()); + if (sub.getName().equals(usingTableName)) { + System.out.println(sub.getName() + " " + + (recordsAmount + currentTableObject.storage.get().size())); + } else { + System.out.println(sub.getName() + " " + recordsAmount); + } + } + } + return list; + } + + private Object getValue(String str, ObjectTable usingTable, Class expectedType) throws NumberFormatException { + for (Class type : usingTable.typeKeeper) { + if (expectedType.equals(int.class)) { + if (str.equals("null")) { + return null; + } + Integer toReturn = Integer.parseInt(str); + return toReturn; + } + if (expectedType.equals(long.class)) { + if (str.equals("null")) { + return null; + } + Long toReturn = Long.parseLong(str); + return toReturn; + } + if (expectedType.equals(boolean.class)) { + if (str.equals("null")) { + return null; + } + Boolean toReturn = Boolean.parseBoolean(str); + return toReturn; + } + if (expectedType.equals(String.class)) { + if (str.equals("null")) { + return null; + } + String[] tmp = str.split(""); + if (tmp[0].equals("\"") && tmp[tmp.length - 1].equals("\"")) { + return str; + } else { + throw new NumberFormatException(); + } + } + if (expectedType.equals(byte.class)) { + if (str.equals("null")) { + return null; + } + Byte toReturn = Byte.parseByte(str); + return toReturn; + } + if (expectedType.equals(double.class)) { + if (str.equals("null")) { + return null; + } + Double toReturn = Double.parseDouble(str); + return toReturn; + } + if (expectedType.equals(float.class)) { + if (str.equals("null")) { + return null; + } + Float toReturn = Float.parseFloat(str); + return toReturn; + } + } + return "^incorrect@"; + } + + void recRem(String myFile) { + File file = new File(myFile); + if (!file.exists()) { + return; + } + if (file.isDirectory()) { + for (File f : file.listFiles()) { + recRem(f.getAbsolutePath()); + } + } + file.delete(); + } + + public void checkException(String name) throws IllegalArgumentException { + if (name == null || name.length() > longestName) { + throw new IllegalArgumentException(); + } + } + + private List> convertToPrimitive(List list) { + List> toReturn = new LinkedList>(); + for (Object object : list) { + if (object.getClass().equals(Integer.class)) { + toReturn.add(int.class); + continue; + } + if (object.getClass().equals(Long.class)) { + toReturn.add(long.class); + continue; + } + if (object.getClass().equals(Boolean.class)) { + toReturn.add(boolean.class); + continue; + } + if (object.getClass().equals(String.class)) { + toReturn.add(String.class); + continue; + } + if (object.getClass().equals(Byte.class)) { + toReturn.add(byte.class); + continue; + } + if (object.getClass().equals(Double.class)) { + toReturn.add(double.class); + continue; + } + if (object.getClass().equals(Float.class)) { + toReturn.add(float.class); + continue; + } + } + return toReturn; + } +} diff --git a/src/ru/fizteh/fivt/students/MaximGotovchits/Parallel/ObjectTableProviderFactory.java b/src/ru/fizteh/fivt/students/MaximGotovchits/Parallel/ObjectTableProviderFactory.java new file mode 100644 index 000000000..67e3306bf --- /dev/null +++ b/src/ru/fizteh/fivt/students/MaximGotovchits/Parallel/ObjectTableProviderFactory.java @@ -0,0 +1,21 @@ +package ru.fizteh.fivt.students.MaximGotovchits.Parallel; + +import ru.fizteh.fivt.storage.structured.TableProvider; +import ru.fizteh.fivt.storage.structured.TableProviderFactory; + +public class ObjectTableProviderFactory extends CommandsTools implements TableProviderFactory { + String dirName; + @Override + public TableProvider create(String dir) throws IllegalArgumentException { + dirName = dir; + try { + if (dir == null || dir.length() > longestName) { + throw new IllegalArgumentException(); + } + } catch (IllegalArgumentException s) { + System.err.println(s); + return null; + } + return new ObjectTableProvider(dir); + } +} diff --git a/src/ru/fizteh/fivt/students/MaximGotovchits/Parallel/Test/ObjectStoreableTest.java b/src/ru/fizteh/fivt/students/MaximGotovchits/Parallel/Test/ObjectStoreableTest.java new file mode 100644 index 000000000..2b9f32425 --- /dev/null +++ b/src/ru/fizteh/fivt/students/MaximGotovchits/Parallel/Test/ObjectStoreableTest.java @@ -0,0 +1,109 @@ +package ru.fizteh.fivt.students.MaximGotovchits.Parallel.Test; + +import org.junit.After; +import org.junit.Before; +import org.junit.Test; +import ru.fizteh.fivt.students.MaximGotovchits.Parallel.ObjectStoreable; +import ru.fizteh.fivt.students.MaximGotovchits.Parallel.ObjectTable; +import ru.fizteh.fivt.students.MaximGotovchits.Parallel.ObjectTableProvider; +import java.io.IOException; +import java.util.LinkedList; +import java.util.List; + +import static org.junit.Assert.assertEquals; +import static org.junit.Assert.assertNotSame; + +public class ObjectStoreableTest { + public String name; + public List> columnTypes = new LinkedList>(); + //public ObjectTable tableToCompare = new ObjectTable(); + public ObjectStoreable deserializedValue = new ObjectStoreable(); + public ObjectTable table; + public String valueToDeserialize; + public ObjectTable tempTable; + @Before + public void initialization() throws IOException { + name = "TestTable"; + columnTypes.add(int.class); + columnTypes.add(long.class); + columnTypes.add(double.class); + columnTypes.add(float.class); + columnTypes.add(byte.class); + columnTypes.add(boolean.class); + columnTypes.add(String.class); + //tableToCompare.typeKeeper = columnTypes; + //tableToCompare.tableName = name; + deserializedValue.subValueList.add(100500); + deserializedValue.subValueList.add((long) 10000000); + deserializedValue.subValueList.add(123.456); + deserializedValue.subValueList.add((float) 12.45); + deserializedValue.subValueList.add((byte) 100); + deserializedValue.subValueList.add(true); + deserializedValue.subValueList.add("\"ValueToTest\""); + deserializedValue.typeKeeper = columnTypes; + deserializedValue.serialisedValue = "[100500, 10000000, 123.456, 12.45, 100, true, \"ValueToTest\"]"; + tempTable = (ObjectTable) new ObjectTableProvider().createTable(name, columnTypes); + valueToDeserialize = "[100500, 10000000, 123.456, 12.45, 100, true, \"ValueToTest\"]"; + } + @Test + public void setColumnAtTest() { + ObjectStoreable tempStoreable = new ObjectStoreable(); + tempStoreable.subValueList.add(100500); + tempStoreable.subValueList.add((long) 10000000); + tempStoreable.subValueList.add(123.456); + tempStoreable.subValueList.add((float) 12.45); + tempStoreable.subValueList.add((byte) 100); + tempStoreable.subValueList.add(true); + tempStoreable.subValueList.add("\"ValueToTest\""); + tempStoreable.typeKeeper = columnTypes; + tempStoreable.serialisedValue = "[100500, 10000000, 123.456, 12.45, 100, true, \"ValueToTest\"]"; + assertEquals(tempStoreable, deserializedValue); + tempStoreable.subValueList.set(6, "\"AnotherValue\""); + tempStoreable.serialisedValue = "[100500, 10000000, 123.456, 12.45, 100, true, \"AnotherValue\"]"; + assertNotSame(tempStoreable, deserializedValue); + deserializedValue.setColumnAt(6, "\"AnotherValue\""); + assertEquals(tempStoreable, deserializedValue); + } + @Test + public void getColumnAtTest() { + assertEquals(100500, deserializedValue.getColumnAt(0)); + assertEquals((long) 10000000, deserializedValue.getColumnAt(1)); + assertEquals(123.456, deserializedValue.getColumnAt(2)); + assertEquals((float) 12.45, deserializedValue.getColumnAt(3)); + assertEquals((byte) 100, deserializedValue.getColumnAt(4)); + assertEquals(true, deserializedValue.getColumnAt(5)); + assertEquals("\"ValueToTest\"", deserializedValue.getColumnAt(6)); + } + @Test + public void getIntAtTest() { + assertEquals((Integer) 100500, deserializedValue.getIntAt(0)); + } + @Test + public void getLongAtTest() { + assertEquals((Long) Long.parseLong("10000000"), deserializedValue.getLongAt(1)); + } + @Test + public void getByteAtTest() { + assertEquals((Byte) Byte.parseByte("100"), deserializedValue.getByteAt(4)); + } + @Test + public void getFloatAtTest() { + assertEquals((Float) Float.parseFloat("12.45"), deserializedValue.getFloatAt(3)); + } + @Test + public void getDoubleAtTest() { + assertEquals((Double) 123.456, deserializedValue.getDoubleAt(2)); + } + @Test + public void getBooleanAtTest() { + assertEquals(true, deserializedValue.getBooleanAt(5)); + } + @Test + public void getStringAtTest() { + assertEquals("\"ValueToTest\"", deserializedValue.getStringAt(6)); + } + @After + public void cleanUp() { + new ObjectTableProvider().removeTable(name); + } +} diff --git a/src/ru/fizteh/fivt/students/MaximGotovchits/Parallel/Test/ObjectTableProviderFactoryTest.java b/src/ru/fizteh/fivt/students/MaximGotovchits/Parallel/Test/ObjectTableProviderFactoryTest.java new file mode 100644 index 000000000..d84ca4689 --- /dev/null +++ b/src/ru/fizteh/fivt/students/MaximGotovchits/Parallel/Test/ObjectTableProviderFactoryTest.java @@ -0,0 +1,15 @@ +package ru.fizteh.fivt.students.MaximGotovchits.Parallel.Test; + +import org.junit.Test; +import ru.fizteh.fivt.students.MaximGotovchits.Parallel.ObjectTableProvider; +import ru.fizteh.fivt.students.MaximGotovchits.Parallel.ObjectTableProviderFactory; +import static org.junit.Assert.assertEquals; + +public class ObjectTableProviderFactoryTest { + @Test + public void createTest() { + ObjectTableProvider toCompare = new ObjectTableProvider("TestRoot"); + ObjectTableProvider qq = (ObjectTableProvider) new ObjectTableProviderFactory().create("TestRoot"); + assertEquals(toCompare, (ObjectTableProvider) new ObjectTableProviderFactory().create("TestRoot")); + } +} diff --git a/src/ru/fizteh/fivt/students/MaximGotovchits/Parallel/Test/ObjectTableProviderTest.java b/src/ru/fizteh/fivt/students/MaximGotovchits/Parallel/Test/ObjectTableProviderTest.java new file mode 100644 index 000000000..5ff77129d --- /dev/null +++ b/src/ru/fizteh/fivt/students/MaximGotovchits/Parallel/Test/ObjectTableProviderTest.java @@ -0,0 +1,86 @@ +package ru.fizteh.fivt.students.MaximGotovchits.Parallel.Test; + +import static org.junit.Assert.assertEquals; +import org.junit.*; +import ru.fizteh.fivt.students.MaximGotovchits.Parallel.ObjectStoreable; +import ru.fizteh.fivt.students.MaximGotovchits.Parallel.ObjectTable; +import ru.fizteh.fivt.students.MaximGotovchits.Parallel.ObjectTableProvider; +import java.io.IOException; +import java.util.LinkedList; +import java.util.List; + +public class ObjectTableProviderTest extends ObjectTableProvider { + public String name; + public List> columnTypes = new LinkedList>(); + public ObjectStoreable deserializedValue = new ObjectStoreable(); + public ObjectTable testTable; + @Before + public void initialization() throws IOException { + name = "TestTable"; + columnTypes.add(int.class); + columnTypes.add(long.class); + columnTypes.add(double.class); + columnTypes.add(float.class); + columnTypes.add(byte.class); + columnTypes.add(boolean.class); + columnTypes.add(String.class); + testTable = (ObjectTable) new ObjectTableProvider().createTable(name, columnTypes); + deserializedValue.subValueList.add(100500); + deserializedValue.subValueList.add((long) 10000000); + deserializedValue.subValueList.add(123.456); + deserializedValue.subValueList.add((float) 12.45); + deserializedValue.subValueList.add((byte) 100); + deserializedValue.subValueList.add(true); + deserializedValue.subValueList.add("\"ValueToTest\""); + deserializedValue.typeKeeper = columnTypes; + deserializedValue.serialisedValue = "[100500, 10000000, 123.456, 12.45, 100, true, \"ValueToTest\"]"; + } + @Test + public void createAndGetTableTest() throws IOException { + name = "TestTable"; + assertEquals(null, createTable(name, columnTypes)); + assertEquals(testTable, getTable(name)); + } + // @Test + // public void deserializeTest() throws ParseException, IOException { + // assertEquals(deserializedValue, (ObjectStoreable) deserialize(table, valueToDeserialize)); + // } + /*@Test(expected = IllegalArgumentException.class) // Это была попытка сделать тест на исключения. + //В следующей задаче я постараюсь это сделать. Просто нужно изменять кучу кода. + public void createNullTableTest() throws IOException { + createTable(null, columnTypes); + }*/ + /*@Test + public void serializeTest() { + assertEquals(valueToDeserialize, serialize(table, deserializedValue)); + } + @Test + public void createForTest() { + ObjectStoreable tempStoreable = new ObjectStoreable(); + tempStoreable.typeKeeper = table.typeKeeper; + assertEquals(tempStoreable, createFor(table)); + tempStoreable.subValueList = deserializedValue.subValueList; + tempStoreable.serialisedValue = deserializedValue.serialisedValue; + ObjectStoreable qq = (ObjectStoreable) createFor(table, deserializedValue.subValueList); + assertEquals(tempStoreable, (ObjectStoreable) createFor(table, deserializedValue.subValueList)); + } + @Test + public void getTableNamesTest() throws IOException { // Конечно же, стоит удостовериться, + // что в рабочей директории на момент тестирования нет таблиц. + List toCompare = new LinkedList(); + toCompare.add(name); + for (Integer ind = 0; ind < 1000; ++ind) { // Generating tables. + toCompare.add(ind.toString()); + createTable(ind.toString(), columnTypes); + } + assertTrue(toCompare.containsAll(getTableNames())); + for (Integer ind = 0; ind < 1000; ++ind) { + removeTable(ind.toString()); + } + }*/ + @After + public void cleanUp() { // Поясню. Теста на removeTable нет. Если бы метод не работал, то было бы + // сообщение "table_name exists". Его нет. + removeTable(name); + } +} diff --git a/src/ru/fizteh/fivt/students/MaximGotovchits/Parallel/Test/ObjectTableTest.java b/src/ru/fizteh/fivt/students/MaximGotovchits/Parallel/Test/ObjectTableTest.java new file mode 100644 index 000000000..21bc0abaf --- /dev/null +++ b/src/ru/fizteh/fivt/students/MaximGotovchits/Parallel/Test/ObjectTableTest.java @@ -0,0 +1,127 @@ +package ru.fizteh.fivt.students.MaximGotovchits.Parallel.Test; + +import static junit.framework.Assert.assertNull; +import static org.junit.Assert.assertEquals; +import static org.junit.Assert.assertTrue; +import org.junit.*; +import org.junit.Test; +import ru.fizteh.fivt.students.MaximGotovchits.Parallel.*; +import java.io.IOException; +import java.util.LinkedList; +import java.util.List; + +public class ObjectTableTest { + public String name; + public List> columnTypes = new LinkedList>(); + public ObjectStoreable deserializedValue = new ObjectStoreable(); + public ObjectTable testTable; + @Before + public void initialization() throws IOException { + name = "TestTable"; + columnTypes.add(int.class); + columnTypes.add(long.class); + columnTypes.add(double.class); + columnTypes.add(float.class); + columnTypes.add(byte.class); + columnTypes.add(boolean.class); + columnTypes.add(String.class); + testTable = (ObjectTable) new ObjectTableProvider().createTable(name, columnTypes); + //tableToCompare.typeKeeper = columnTypes; + //tableToCompare.tableName = name; + deserializedValue.subValueList.add(100500); + deserializedValue.subValueList.add((long) 10000000); + deserializedValue.subValueList.add(123.456); + deserializedValue.subValueList.add((float) 12.45); + deserializedValue.subValueList.add((byte) 100); + deserializedValue.subValueList.add(true); + deserializedValue.subValueList.add("\"ValueToTest\""); + deserializedValue.typeKeeper = columnTypes; + deserializedValue.serialisedValue = "[100500, 10000000, 123.456, 12.45, 100, true, \"ValueToTest\"]"; + /*testTable = (ObjectTable) new ObjectTableProvider().createTable(name, columnTypes); + valueToDeserialize = "[100500, 10000000, 123.456, 12.45, 100, true, \"ValueToTest\"]";*/ + } + @Test + public void getNameTest() throws Exception { + assertEquals(name, testTable.getName()); + } + @Test + public void putTest() throws Exception { + new Use().useFunction(name, null); + assertNull(testTable.put("Key", deserializedValue)); + assertEquals(deserializedValue, testTable.put("Key", deserializedValue)); + } + @Test + public void getTest() throws Exception { + new Use().useFunction(name, null); + testTable.put("Key", deserializedValue); + assertEquals(deserializedValue, testTable.get("Key")); + } + @Test + public void sizeTest() throws Exception { + new Use().useFunction(name, null); + for (Integer i = 0; i < 1000; ++i) { + testTable.put(i.toString(), deserializedValue); + } + assertEquals(1000, testTable.size()); + } + @Test + public void listTest() throws Exception { + new Use().useFunction(name, null); + List toCompare = new LinkedList(); + for (Integer i = 0; i < 1000; ++i) { + toCompare.add(i.toString()); + testTable.put(i.toString(), deserializedValue); + } + assertTrue(toCompare.containsAll(testTable.list())); + } + @Test + public void removeTest() throws Exception { + new Use().useFunction(name, null); + testTable.put("Key", deserializedValue); + assertEquals(deserializedValue, testTable.remove("Key")); + } + @Test + public void commitTest() { + for (Integer i = 0; i < 1000; ++i) { + testTable.put(i.toString(), deserializedValue); + } + assertEquals(1000, testTable.commit()); + } + @Test + public void rollbackTest() { + for (Integer i = 0; i < 1000; ++i) { + testTable.put(i.toString(), deserializedValue); + } + assertEquals(1001, testTable.rollback()); + } + @Test + public void getNumberOfUncommittedChangesTest() { + for (Integer i = 0; i < 1000; ++i) { + String key = i.toString(); + testTable.put(key, deserializedValue); + } + assertEquals(1000, testTable.getNumberOfUncommittedChanges()); + testTable.commit(); + assertEquals(0, testTable.getNumberOfUncommittedChanges()); + } + @Test + public void getColumnsCountTest() { + assertEquals(7, testTable.getColumnsCount()); + } + @Test + public void getColumnType() throws Exception { + new Use().useFunction(name, null); + assertEquals(int.class, testTable.getColumnType(0)); + assertEquals(long.class, testTable.getColumnType(1)); + assertEquals(double.class, testTable.getColumnType(2)); + assertEquals(float.class, testTable.getColumnType(3)); + assertEquals(byte.class, testTable.getColumnType(4)); + assertEquals(boolean.class, testTable.getColumnType(5)); + assertEquals(String.class, testTable.getColumnType(6)); + } + @After + public void cleanUp() { + new ObjectTableProvider().removeTable(name); + } +} + diff --git a/src/ru/fizteh/fivt/students/MaximGotovchits/Parallel/Use.java b/src/ru/fizteh/fivt/students/MaximGotovchits/Parallel/Use.java new file mode 100644 index 000000000..c603aa881 --- /dev/null +++ b/src/ru/fizteh/fivt/students/MaximGotovchits/Parallel/Use.java @@ -0,0 +1,71 @@ +package ru.fizteh.fivt.students.MaximGotovchits.Parallel; + +import java.io.*; +import java.nio.charset.StandardCharsets; +import java.text.ParseException; + +public class Use extends CommandsTools { + public boolean useFunction(String tableName, String oldTableName) throws Exception { + if (!tableName.equals(oldTableName)) { + String outputName = tableName; + String tablePath = dataBaseName + "/" + tableName; + File file = new File(tablePath); + if (file.exists()) { + usingTableName = tableName; + if (tableIsChosen) { + new FillTable().fillTableFunction(currentTableObject); + currentTableObject.storage.get().clear(); + currentTableObject.commitStorage.clear(); + } + currentTableObject = new ObjectTable(dataBaseName + File.separator + usingTableName); + for (Integer i = 0; i < dirNum; ++i) { + for (Integer j = 0; j < fileNum; ++j) { + tablePath = dataBaseName + File.separator + tableName + File.separator + + i + dirExt + File.separator + j + fileExt; + if (new File(tablePath).exists()) { + fillStorage(tablePath, file); + PrintWriter writer = new PrintWriter(new File(tablePath)); + writer.print(""); + writer.close(); + } + } + } + System.out.println("using " + outputName); + tableIsChosen = true; + } else { + System.err.println(tableName + " not exists"); + return false; + } + } else { + System.out.println("using " + oldTableName); + } + usingTableName = currentTableObject.getName(); + return true; + } + void fillStorage(String datName, File file) throws IOException, ParseException { + DataInputStream stream = new DataInputStream(new FileInputStream(datName)); + file = new File(datName); + byte[] data = new byte[(int) file.length()]; + stream.read(data); + int counter = 0; + int offset = 0; + String keyForMap = ""; + String value = ""; + String aLL = new String(data); + while (counter < file.length()) { + offset = data[counter]; + keyForMap = new String(data, counter + 2, offset - 2, StandardCharsets.UTF_8); + counter = counter + offset + 1; + offset = data[counter]; + value = new String(data, counter + 2, data.length - counter - 3, StandardCharsets.UTF_8); + value = value.replaceAll("^\\s*|\\s*$", ""); + String tableName = new File(new File(datName).getParent()).getParent(); + ObjectStoreable valForMap = (ObjectStoreable) + new ObjectTableProvider().deserialize(new ObjectTable(tableName), value); + currentTableObject.storage.get().put(keyForMap, valForMap); + currentTableObject.commitStorage.put(keyForMap, valForMap); + counter = counter + offset + 3; + } + stream.close(); + } +} From 273695726cefb095b4ab42304108a9c01c0d04bb Mon Sep 17 00:00:00 2001 From: MaximGotovchits Date: Thu, 5 Feb 2015 22:53:45 +0200 Subject: [PATCH 12/18] Parallel --- .../Parallel/{ => BasePKG}/Main.java | 6 +- .../Parallel/CommandsTools.java | 17 -- .../MaximGotovchits/Parallel/Exit.java | 24 -- .../MaximGotovchits/Parallel/Interpreter.java | 222 ------------------ .../Parallel/InterpreterPKG/Commit.java | 7 + .../Parallel/InterpreterPKG/Create.java | 77 ++++++ .../Parallel/InterpreterPKG/Drop.java | 13 + .../Parallel/InterpreterPKG/Exit.java | 24 ++ .../{ => InterpreterPKG}/FillTable.java | 19 +- .../Parallel/InterpreterPKG/Get.java | 23 ++ .../Parallel/InterpreterPKG/Interpreter.java | 132 +++++++++++ .../Parallel/InterpreterPKG/List.java | 11 + .../{ => InterpreterPKG}/MakeDirs.java | 12 +- .../Parallel/InterpreterPKG/Put.java | 31 +++ .../Parallel/InterpreterPKG/Remove.java | 22 ++ .../Parallel/InterpreterPKG/Rollback.java | 7 + .../Parallel/InterpreterPKG/ShowTables.java | 9 + .../Parallel/{ => InterpreterPKG}/Use.java | 39 +-- .../{ => ObjectsPKG}/ObjectStoreable.java | 37 ++- .../{ => ObjectsPKG}/ObjectTable.java | 55 +++-- .../{ => ObjectsPKG}/ObjectTableProvider.java | 36 ++- .../ObjectTableProviderFactory.java | 8 +- .../ObjectStoreableTest.java | 11 +- .../ObjectTableProviderFactoryTest.java | 6 +- .../ObjectTableProviderTest.java | 18 +- .../{Test => TestPKG}/ObjectTableTest.java | 8 +- 26 files changed, 520 insertions(+), 354 deletions(-) rename src/ru/fizteh/fivt/students/MaximGotovchits/Parallel/{ => BasePKG}/Main.java (64%) delete mode 100644 src/ru/fizteh/fivt/students/MaximGotovchits/Parallel/CommandsTools.java delete mode 100644 src/ru/fizteh/fivt/students/MaximGotovchits/Parallel/Exit.java delete mode 100644 src/ru/fizteh/fivt/students/MaximGotovchits/Parallel/Interpreter.java create mode 100644 src/ru/fizteh/fivt/students/MaximGotovchits/Parallel/InterpreterPKG/Commit.java create mode 100644 src/ru/fizteh/fivt/students/MaximGotovchits/Parallel/InterpreterPKG/Create.java create mode 100644 src/ru/fizteh/fivt/students/MaximGotovchits/Parallel/InterpreterPKG/Drop.java create mode 100644 src/ru/fizteh/fivt/students/MaximGotovchits/Parallel/InterpreterPKG/Exit.java rename src/ru/fizteh/fivt/students/MaximGotovchits/Parallel/{ => InterpreterPKG}/FillTable.java (59%) create mode 100644 src/ru/fizteh/fivt/students/MaximGotovchits/Parallel/InterpreterPKG/Get.java create mode 100644 src/ru/fizteh/fivt/students/MaximGotovchits/Parallel/InterpreterPKG/Interpreter.java create mode 100644 src/ru/fizteh/fivt/students/MaximGotovchits/Parallel/InterpreterPKG/List.java rename src/ru/fizteh/fivt/students/MaximGotovchits/Parallel/{ => InterpreterPKG}/MakeDirs.java (54%) create mode 100644 src/ru/fizteh/fivt/students/MaximGotovchits/Parallel/InterpreterPKG/Put.java create mode 100644 src/ru/fizteh/fivt/students/MaximGotovchits/Parallel/InterpreterPKG/Remove.java create mode 100644 src/ru/fizteh/fivt/students/MaximGotovchits/Parallel/InterpreterPKG/Rollback.java create mode 100644 src/ru/fizteh/fivt/students/MaximGotovchits/Parallel/InterpreterPKG/ShowTables.java rename src/ru/fizteh/fivt/students/MaximGotovchits/Parallel/{ => InterpreterPKG}/Use.java (58%) rename src/ru/fizteh/fivt/students/MaximGotovchits/Parallel/{ => ObjectsPKG}/ObjectStoreable.java (93%) rename src/ru/fizteh/fivt/students/MaximGotovchits/Parallel/{ => ObjectsPKG}/ObjectTable.java (89%) rename src/ru/fizteh/fivt/students/MaximGotovchits/Parallel/{ => ObjectsPKG}/ObjectTableProvider.java (90%) rename src/ru/fizteh/fivt/students/MaximGotovchits/Parallel/{ => ObjectsPKG}/ObjectTableProviderFactory.java (66%) rename src/ru/fizteh/fivt/students/MaximGotovchits/Parallel/{Test => TestPKG}/ObjectStoreableTest.java (90%) rename src/ru/fizteh/fivt/students/MaximGotovchits/Parallel/{Test => TestPKG}/ObjectTableProviderFactoryTest.java (64%) rename src/ru/fizteh/fivt/students/MaximGotovchits/Parallel/{Test => TestPKG}/ObjectTableProviderTest.java (87%) rename src/ru/fizteh/fivt/students/MaximGotovchits/Parallel/{Test => TestPKG}/ObjectTableTest.java (92%) diff --git a/src/ru/fizteh/fivt/students/MaximGotovchits/Parallel/Main.java b/src/ru/fizteh/fivt/students/MaximGotovchits/Parallel/BasePKG/Main.java similarity index 64% rename from src/ru/fizteh/fivt/students/MaximGotovchits/Parallel/Main.java rename to src/ru/fizteh/fivt/students/MaximGotovchits/Parallel/BasePKG/Main.java index b6c3953d8..6ef21f62f 100644 --- a/src/ru/fizteh/fivt/students/MaximGotovchits/Parallel/Main.java +++ b/src/ru/fizteh/fivt/students/MaximGotovchits/Parallel/BasePKG/Main.java @@ -1,4 +1,8 @@ -package ru.fizteh.fivt.students.MaximGotovchits.Parallel; +package ru.fizteh.fivt.students.MaximGotovchits.Parallel.BasePKG; + +import ru.fizteh.fivt.students.MaximGotovchits.Parallel.InterpreterPKG.Interpreter; +import ru.fizteh.fivt.students.MaximGotovchits.Parallel.InterpreterPKG.MakeDirs; +import ru.fizteh.fivt.students.MaximGotovchits.Parallel.InterpreterPKG.Exit; public class Main { // Using JSON format. public static void main(final String[] args) throws Exception { diff --git a/src/ru/fizteh/fivt/students/MaximGotovchits/Parallel/CommandsTools.java b/src/ru/fizteh/fivt/students/MaximGotovchits/Parallel/CommandsTools.java deleted file mode 100644 index 82b579f4f..000000000 --- a/src/ru/fizteh/fivt/students/MaximGotovchits/Parallel/CommandsTools.java +++ /dev/null @@ -1,17 +0,0 @@ -package ru.fizteh.fivt.students.MaximGotovchits.Parallel; - -public abstract class CommandsTools { - static final String JSON_REG_EX = "\\s*,\\s*(?=(?:(?:[^\"]*\"){2})*[^\"]*$)"; // Removes commas - // outside of "...". - static String usingTableName = new String(); - static ObjectTable currentTableObject; - static String dataBaseName = System.getProperty("fizteh.db.dir"); - static String signatureFileName = "signature.tsv"; - static Integer dirNum = 16; - static Integer fileNum = 16; - static String dirExt = ".dir"; - static String fileExt = ".dat"; - static int longestName = 260; - static Boolean tableIsChosen = false; -} - diff --git a/src/ru/fizteh/fivt/students/MaximGotovchits/Parallel/Exit.java b/src/ru/fizteh/fivt/students/MaximGotovchits/Parallel/Exit.java deleted file mode 100644 index 9a912dbf3..000000000 --- a/src/ru/fizteh/fivt/students/MaximGotovchits/Parallel/Exit.java +++ /dev/null @@ -1,24 +0,0 @@ -package ru.fizteh.fivt.students.MaximGotovchits.Parallel; - -public class Exit extends CommandsTools { - void exitFunction() throws Exception { - if (currentTableObject != null) { - new FillTable().fillTableFunction(currentTableObject); - } - System.exit(0); - } - boolean exitAndUseAvailable() { - if (currentTableObject != null) { - int uncommitedChanges = currentTableObject.storage.get().size() - - currentTableObject.commitStorage.size(); - if (uncommitedChanges == 0 || !tableIsChosen) { - return true; - } - System.out.println(uncommitedChanges + " uncommited changes"); - return false; - } - return true; - } -} - - diff --git a/src/ru/fizteh/fivt/students/MaximGotovchits/Parallel/Interpreter.java b/src/ru/fizteh/fivt/students/MaximGotovchits/Parallel/Interpreter.java deleted file mode 100644 index a825c686a..000000000 --- a/src/ru/fizteh/fivt/students/MaximGotovchits/Parallel/Interpreter.java +++ /dev/null @@ -1,222 +0,0 @@ -package ru.fizteh.fivt.students.MaximGotovchits.Parallel; - -import java.util.*; - -public class Interpreter extends CommandsTools { - private final String invitationalSymbol = "$ "; - - void parseDataFromCmdLine(String cmdLine) throws Exception { - String[] splittedLine = cmdLine.split("\\s*;\\s*"); - for (String line : splittedLine) { - String[] cmd = line.split("\\s+"); - executionFunction(cmd, true); // True means that data is from command line. - } - } - - void getCmdFromStream() throws Exception { - Scanner scan = new Scanner(System.in); - System.out.print(invitationalSymbol); - String[] cmd = scan.nextLine().split("\\s+"); - executionFunction(cmd, false); // False means that data is from "System.in". - } - - private void executionFunction(String[] cmd, boolean fromCmdLine) throws Exception { // The main interpreter - // function. - if (cmd[0].equals("create") && cmd.length > 2) { - String createParameter = new String(); // (...) - type list. - String tableName = cmd[1]; - for (int ind = 2; ind < cmd.length; ++ind) { - createParameter += cmd[ind] + " "; - } - createParameter = createParameter.substring(0, createParameter.length() - 1); - List> typeList = new LinkedList<>(); - try { - typeList = getTypeList(createParameter, fromCmdLine); - new ObjectTableProvider().createTable(tableName, typeList); - } catch (Exception e) { - System.err.println(e); - } - ifContinue(fromCmdLine); - } - - if (cmd[0].equals("use") && cmd.length == 2) { - String tableName = cmd[1]; - boolean changeUsingTable = false; - try { - if (tableIsChosen) { - new Use().useFunction(tableName, currentTableObject.getName()); - } else { - tableIsChosen = new Use().useFunction(tableName, null); - } - } catch (Exception e) { - printExceptionMessage(e); - } - ifContinue(fromCmdLine); - } - - if (cmd[0].equals("put") && cmd.length > 2) { - if (tableIsChosen) { - String putParameter = new String(); - String key = cmd[1]; - for (int ind = 2; ind < cmd.length; ++ind) { - putParameter += cmd[ind] + " "; - } - putParameter = putParameter.substring(0, putParameter.length() - 1); - try { - ObjectStoreable value = (ObjectStoreable) new ObjectTableProvider(). - deserialize(currentTableObject, putParameter); - currentTableObject.put(key, value); - } catch (Exception e) { - System.err.println(e); - } - } else { - informToChooseTable(); - } - ifContinue(fromCmdLine); - } - - if (cmd[0].equals("commit") && cmd.length == 1) { - currentTableObject.commit(); - ifContinue(fromCmdLine); - } - - if (cmd[0].equals("show") && cmd[1].equals("tables") && cmd.length == 2) { - new ObjectTableProvider().getTableNames(); - ifContinue(fromCmdLine); - } - - if (cmd[0].equals("get") && cmd.length == 2) { - try { - if (tableIsChosen) { - currentTableObject.get(cmd[1]); - } else { - informToChooseTable(); - } - } catch (Exception e) { - System.out.println(e); - } - ifContinue(fromCmdLine); - } - - if (cmd[0].equals("list") && cmd.length == 1) { - if (tableIsChosen) { - currentTableObject.list(); - } else { - informToChooseTable(); - } - ifContinue(fromCmdLine); - } - - if (cmd[0].equals("remove") && cmd.length == 2) { - if (tableIsChosen) { - try { - currentTableObject.remove(cmd[1]); - } catch (Exception e) { - System.err.println(e); - } - } else { - informToChooseTable(); - } - ifContinue(fromCmdLine); - } - - if (cmd[0].equals("drop") && cmd.length == 2) { - try { - new ObjectTableProvider().removeTable(cmd[1]); - } catch (Exception e) { - System.err.println(e); - } - ifContinue(fromCmdLine); - } - - if (cmd[0].equals("rollback") && cmd.length == 1) { - currentTableObject.rollback(); - ifContinue(fromCmdLine); - } - - if (cmd[0].equals("exit") && cmd.length == 1) { - if (fromCmdLine) { - currentTableObject.commit(); - new Exit().exitFunction(); - } else { - if (new Exit().exitAndUseAvailable()) { - new Exit().exitFunction(); - } - } - ifContinue(fromCmdLine); - } - if (cmd.length != 0) { - syntaxError(); - } - ifContinue(fromCmdLine); - } - - void informToChooseTable() { - System.err.println("table is not chosen"); - } - - void ifContinue(boolean fromCmdLine) throws Exception { - if (fromCmdLine) { - return; - } else { - getCmdFromStream(); - } - } - - private void printExceptionMessage(Exception e) { - System.err.println(e); - } - - private List> getTypeList(String line, boolean fromCmdLine) throws Exception { - List> typeList = new LinkedList>(); - line = line.replaceAll("\\s*\\)\\s*", ""); - line = line.replaceAll("\\s*\\(\\s*", ""); - String[] tmp = line.split("\\s+"); - for (String str : tmp) { - Class type = getType(str); - if (type != null) { - typeList.add(type); - } else { - syntaxError(); - if (fromCmdLine) { - System.exit(1); - } else { - getCmdFromStream(); - } - } - } - return typeList; - } - - private Class getType(String str) { - if (str.equals("int")) { - return int.class; - } - if (str.equals("long")) { - return long.class; - } - if (str.equals("double")) { - return double.class; - } - if (str.equals("float")) { - return float.class; - } - if (str.equals("double")) { - return double.class; - } - if (str.equals("boolean")) { - return boolean.class; - } - if (str.equals("byte")) { - return byte.class; - } - if (str.equals("String")) { - return String.class; - } - return null; - } - - void syntaxError() { - System.err.println("incorrect syntax"); - } -} diff --git a/src/ru/fizteh/fivt/students/MaximGotovchits/Parallel/InterpreterPKG/Commit.java b/src/ru/fizteh/fivt/students/MaximGotovchits/Parallel/InterpreterPKG/Commit.java new file mode 100644 index 000000000..a1a630fca --- /dev/null +++ b/src/ru/fizteh/fivt/students/MaximGotovchits/Parallel/InterpreterPKG/Commit.java @@ -0,0 +1,7 @@ +package ru.fizteh.fivt.students.MaximGotovchits.Parallel.InterpreterPKG; + +public class Commit { + void commitFunction() { + Interpreter.currentTableObject.commit(); + } +} diff --git a/src/ru/fizteh/fivt/students/MaximGotovchits/Parallel/InterpreterPKG/Create.java b/src/ru/fizteh/fivt/students/MaximGotovchits/Parallel/InterpreterPKG/Create.java new file mode 100644 index 000000000..166a5c58d --- /dev/null +++ b/src/ru/fizteh/fivt/students/MaximGotovchits/Parallel/InterpreterPKG/Create.java @@ -0,0 +1,77 @@ +package ru.fizteh.fivt.students.MaximGotovchits.Parallel.InterpreterPKG; + +import ru.fizteh.fivt.students.MaximGotovchits.Parallel.ObjectsPKG.ObjectTableProvider; + +import java.util.LinkedList; +import java.util.List; + +public class Create { + private static final String SPLIT_BY_RIGHT_BRACKET = "\\s*\\)\\s*"; + private static final String SPLIT_BY_LEFT_BRACKET = "\\s*\\(\\s*"; + private static final String SPLIT_BY_SPACE = "\\s+"; + + void createFunction(String[] cmd, boolean fromCmdLine) { + String createParameter = new String(); // (...) - type list. + String tableName = cmd[1]; + for (int ind = 2; ind < cmd.length; ++ind) { + createParameter += cmd[ind] + " "; + } + createParameter = createParameter.substring(0, createParameter.length() - 1); + List> typeList = new LinkedList<>(); + try { + typeList = getTypeList(createParameter, fromCmdLine); + new ObjectTableProvider().createTable(tableName, typeList); + } catch (Exception e) { + System.err.println(e); + } + } + + private List> getTypeList(String line, boolean fromCmdLine) throws Exception { + List> typeList = new LinkedList>(); + line = line.replaceAll(SPLIT_BY_RIGHT_BRACKET, ""); + line = line.replaceAll(SPLIT_BY_LEFT_BRACKET, ""); + String[] tmp = line.split(SPLIT_BY_SPACE); + for (String str : tmp) { + Class type = getType(str); + if (type != null) { + typeList.add(type); + } else { + Interpreter.syntaxError(); + if (fromCmdLine) { + System.exit(1); + } else { + Interpreter.getCmdFromStream(); + } + } + } + return typeList; + } + + private Class getType(String str) { + if (str.equals("int")) { + return int.class; + } + if (str.equals("long")) { + return long.class; + } + if (str.equals("double")) { + return double.class; + } + if (str.equals("float")) { + return float.class; + } + if (str.equals("double")) { + return double.class; + } + if (str.equals("boolean")) { + return boolean.class; + } + if (str.equals("byte")) { + return byte.class; + } + if (str.equals("String")) { + return String.class; + } + return null; + } +} diff --git a/src/ru/fizteh/fivt/students/MaximGotovchits/Parallel/InterpreterPKG/Drop.java b/src/ru/fizteh/fivt/students/MaximGotovchits/Parallel/InterpreterPKG/Drop.java new file mode 100644 index 000000000..3e2039c6e --- /dev/null +++ b/src/ru/fizteh/fivt/students/MaximGotovchits/Parallel/InterpreterPKG/Drop.java @@ -0,0 +1,13 @@ +package ru.fizteh.fivt.students.MaximGotovchits.Parallel.InterpreterPKG; + +import ru.fizteh.fivt.students.MaximGotovchits.Parallel.ObjectsPKG.ObjectTableProvider; + +public class Drop { + void dropFunction(String[] cmd) { + try { + new ObjectTableProvider().removeTable(cmd[1]); + } catch (Exception e) { + System.err.println(e); + } + } +} diff --git a/src/ru/fizteh/fivt/students/MaximGotovchits/Parallel/InterpreterPKG/Exit.java b/src/ru/fizteh/fivt/students/MaximGotovchits/Parallel/InterpreterPKG/Exit.java new file mode 100644 index 000000000..79a3516d2 --- /dev/null +++ b/src/ru/fizteh/fivt/students/MaximGotovchits/Parallel/InterpreterPKG/Exit.java @@ -0,0 +1,24 @@ +package ru.fizteh.fivt.students.MaximGotovchits.Parallel.InterpreterPKG; + +public class Exit { + public void exitFunction() throws Exception { + if (Interpreter.currentTableObject != null) { + new FillTable().fillTableFunction(Interpreter.currentTableObject); + } + System.exit(0); + } + public boolean exitAndUseAvailable() { + if (Interpreter.currentTableObject != null) { + int uncommitedChanges = Interpreter.currentTableObject.storage.get().size() + - Interpreter.currentTableObject.commitStorage.size(); + if (uncommitedChanges == 0 || !Interpreter.tableIsChosen) { + return true; + } + System.out.println(uncommitedChanges + " uncommited changes"); + return false; + } + return true; + } +} + + diff --git a/src/ru/fizteh/fivt/students/MaximGotovchits/Parallel/FillTable.java b/src/ru/fizteh/fivt/students/MaximGotovchits/Parallel/InterpreterPKG/FillTable.java similarity index 59% rename from src/ru/fizteh/fivt/students/MaximGotovchits/Parallel/FillTable.java rename to src/ru/fizteh/fivt/students/MaximGotovchits/Parallel/InterpreterPKG/FillTable.java index b2956e423..742bec0bf 100644 --- a/src/ru/fizteh/fivt/students/MaximGotovchits/Parallel/FillTable.java +++ b/src/ru/fizteh/fivt/students/MaximGotovchits/Parallel/InterpreterPKG/FillTable.java @@ -1,5 +1,7 @@ -package ru.fizteh.fivt.students.MaximGotovchits.Parallel; +package ru.fizteh.fivt.students.MaximGotovchits.Parallel.InterpreterPKG; +import ru.fizteh.fivt.students.MaximGotovchits.Parallel.ObjectsPKG.ObjectStoreable; +import ru.fizteh.fivt.students.MaximGotovchits.Parallel.ObjectsPKG.ObjectTable; import java.io.DataOutputStream; import java.io.File; import java.io.FileOutputStream; @@ -8,18 +10,23 @@ import java.nio.file.Paths; import java.util.Map; -public class FillTable extends CommandsTools { +public class FillTable { + private static final String FILE_EXT = ".dat"; + private static final Integer FILE_NUM = 16; + private static final String DIR_EXT = ".dir"; + private static final Integer DIR_NUM = 16; + private static final String DATA_BASE_NAME = System.getProperty("fizteh.db.dir"); public void fillTableFunction(ObjectTable usingTable) throws Exception { for (Map.Entry entry : usingTable.commitStorage.entrySet()) { int hashCode = entry.getKey().hashCode(); - Integer nDirectory = hashCode % dirNum; - Integer nFile = hashCode / dirNum % fileNum; - Path fileName = Paths.get(dataBaseName + File.separator + usingTable.getName(), nDirectory + dirExt); + Integer nDirectory = hashCode % DIR_NUM; + Integer nFile = hashCode / DIR_NUM % FILE_NUM; + Path fileName = Paths.get(DATA_BASE_NAME + File.separator + usingTable.getName(), nDirectory + DIR_EXT); File file = new File(fileName.toString()); if (!file.exists()) { file.mkdir(); } - fileName = Paths.get(fileName.toString(), nFile + fileExt); + fileName = Paths.get(fileName.toString(), nFile + FILE_EXT); file = new File(fileName.toString()); if (!file.exists()) { file.createNewFile(); diff --git a/src/ru/fizteh/fivt/students/MaximGotovchits/Parallel/InterpreterPKG/Get.java b/src/ru/fizteh/fivt/students/MaximGotovchits/Parallel/InterpreterPKG/Get.java new file mode 100644 index 000000000..6d07eb3eb --- /dev/null +++ b/src/ru/fizteh/fivt/students/MaximGotovchits/Parallel/InterpreterPKG/Get.java @@ -0,0 +1,23 @@ +package ru.fizteh.fivt.students.MaximGotovchits.Parallel.InterpreterPKG; + +import ru.fizteh.fivt.students.MaximGotovchits.Parallel.ObjectsPKG.ObjectStoreable; + +public class Get { + void getFunction(String[] cmd, boolean fromCmdLine) { + try { + if (Interpreter.tableIsChosen) { + ObjectStoreable temp = (ObjectStoreable) Interpreter.currentTableObject.get(cmd[1]); + if (temp == null) { + System.err.println("not found"); + } else { + System.out.println("found"); + System.out.println(temp.serialisedValue); + } + } else { + Interpreter.informToChooseTable(); + } + } catch (Exception e) { + System.out.println(e); + } + } +} diff --git a/src/ru/fizteh/fivt/students/MaximGotovchits/Parallel/InterpreterPKG/Interpreter.java b/src/ru/fizteh/fivt/students/MaximGotovchits/Parallel/InterpreterPKG/Interpreter.java new file mode 100644 index 000000000..5965dd355 --- /dev/null +++ b/src/ru/fizteh/fivt/students/MaximGotovchits/Parallel/InterpreterPKG/Interpreter.java @@ -0,0 +1,132 @@ +package ru.fizteh.fivt.students.MaximGotovchits.Parallel.InterpreterPKG; + +import ru.fizteh.fivt.students.MaximGotovchits.Parallel.ObjectsPKG.ObjectTable; +import java.util.*; + +public class Interpreter { + static Boolean tableIsChosen = false; + static Integer dirNum = 16; + static Integer fileNum = 16; + static String dirExt = ".dir"; + static String fileExt = ".dat"; + static final String INVITATIONAL_SYMBOL = "$ "; + private static final String SPLIT_BY_COMMA = "\\s*;\\s*"; + private static final String SPLIT_BY_SPACE = "\\s+"; + static String usingTableName; + static ObjectTable currentTableObject; + protected static final String DATA_BASE_NAME = System.getProperty("fizteh.db.dir"); + + public void parseDataFromCmdLine(String cmdLine) throws Exception { + String[] splittedLine = cmdLine.split(SPLIT_BY_COMMA); + for (String line : splittedLine) { + String[] cmd = line.split(SPLIT_BY_SPACE); + executionFunction(cmd, true); // True means that data is from command line. + } + } + + public static void getCmdFromStream() throws Exception { + Scanner scan = new Scanner(System.in); + System.out.print(INVITATIONAL_SYMBOL); + String[] cmd = scan.nextLine().split(SPLIT_BY_SPACE); + executionFunction(cmd, false); // False means that data is from "System.in". + } + + static void executionFunction(String[] cmd, boolean fromCmdLine) throws Exception { // The main interpreter + // function. + if (cmd[0].equals("create") && cmd.length > 2) { + new Create().createFunction(cmd, fromCmdLine); + ifContinue(fromCmdLine); + } + + if (cmd[0].equals("use") && cmd.length == 2) { + String tableName = cmd[1]; + boolean changeUsingTable = false; + try { + if (tableIsChosen) { + new Use().useFunction(tableName, currentTableObject.getName()); + } else { + tableIsChosen = new Use().useFunction(tableName, null); + } + } catch (Exception e) { + printExceptionMessage(e); + } + ifContinue(fromCmdLine); + } + + if (cmd[0].equals("put") && cmd.length > 2) { + new Put().putFunction(cmd, fromCmdLine); + ifContinue(fromCmdLine); + } + + if (cmd[0].equals("commit") && cmd.length == 1) { + new Commit().commitFunction(); + ifContinue(fromCmdLine); + } + + if (cmd[0].equals("show") && cmd[1].equals("tables") && cmd.length == 2) { + new ShowTables().showTablesFunction(); + ifContinue(fromCmdLine); + } + + if (cmd[0].equals("get") && cmd.length == 2) { + new Get().getFunction(cmd, fromCmdLine); + ifContinue(fromCmdLine); + } + + if (cmd[0].equals("list") && cmd.length == 1) { + new List().listFunction(); + ifContinue(fromCmdLine); + } + + if (cmd[0].equals("remove") && cmd.length == 2) { + new Remove().removeFunction(cmd); + ifContinue(fromCmdLine); + } + + if (cmd[0].equals("drop") && cmd.length == 2) { + new Drop().dropFunction(cmd); + ifContinue(fromCmdLine); + } + + if (cmd[0].equals("rollback") && cmd.length == 1) { + new Rollback().rollbackFunction(); + ifContinue(fromCmdLine); + } + + if (cmd[0].equals("exit") && cmd.length == 1) { + if (fromCmdLine) { + currentTableObject.commit(); + new Exit().exitFunction(); + } else { + if (new Exit().exitAndUseAvailable()) { + new Exit().exitFunction(); + } + } + ifContinue(fromCmdLine); + } + if (cmd.length != 0) { + syntaxError(); + } + ifContinue(fromCmdLine); + } + + static void informToChooseTable() { + System.err.println("table is not chosen"); + } + + static void ifContinue(boolean fromCmdLine) throws Exception { + if (fromCmdLine) { + return; + } else { + getCmdFromStream(); + } + } + + static void printExceptionMessage(Exception e) { + System.err.println(e); + } + + static void syntaxError() { + System.err.println("incorrect syntax"); + } +} diff --git a/src/ru/fizteh/fivt/students/MaximGotovchits/Parallel/InterpreterPKG/List.java b/src/ru/fizteh/fivt/students/MaximGotovchits/Parallel/InterpreterPKG/List.java new file mode 100644 index 000000000..6da432cc8 --- /dev/null +++ b/src/ru/fizteh/fivt/students/MaximGotovchits/Parallel/InterpreterPKG/List.java @@ -0,0 +1,11 @@ +package ru.fizteh.fivt.students.MaximGotovchits.Parallel.InterpreterPKG; + +public class List { + void listFunction() { + if (Interpreter.tableIsChosen) { + Interpreter.currentTableObject.list(); + } else { + Interpreter.informToChooseTable(); + } + } +} diff --git a/src/ru/fizteh/fivt/students/MaximGotovchits/Parallel/MakeDirs.java b/src/ru/fizteh/fivt/students/MaximGotovchits/Parallel/InterpreterPKG/MakeDirs.java similarity index 54% rename from src/ru/fizteh/fivt/students/MaximGotovchits/Parallel/MakeDirs.java rename to src/ru/fizteh/fivt/students/MaximGotovchits/Parallel/InterpreterPKG/MakeDirs.java index 3ce3dfdc5..5d1da06ab 100644 --- a/src/ru/fizteh/fivt/students/MaximGotovchits/Parallel/MakeDirs.java +++ b/src/ru/fizteh/fivt/students/MaximGotovchits/Parallel/InterpreterPKG/MakeDirs.java @@ -1,20 +1,20 @@ -package ru.fizteh.fivt.students.MaximGotovchits.Parallel; +package ru.fizteh.fivt.students.MaximGotovchits.Parallel.InterpreterPKG; import java.io.File; -public class MakeDirs extends CommandsTools { - void makeDirsFunction() throws Exception { - File file = new File(dataBaseName); +public class MakeDirs { + public void makeDirsFunction() throws Exception { + File file = new File(Interpreter.DATA_BASE_NAME); if (!file.exists()) { file.mkdirs(); } else { if (!file.isDirectory()) { - System.err.println(dataBaseName + " is not a directory"); + System.err.println(Interpreter.DATA_BASE_NAME + " is not a directory"); System.exit(1); } else { for (File sub : file.listFiles()) { if (!sub.isDirectory() && !sub.isHidden()) { - System.err.println(dataBaseName + File.separator + System.err.println(Interpreter.DATA_BASE_NAME + File.separator + sub.getName() + " is not a directory"); } } diff --git a/src/ru/fizteh/fivt/students/MaximGotovchits/Parallel/InterpreterPKG/Put.java b/src/ru/fizteh/fivt/students/MaximGotovchits/Parallel/InterpreterPKG/Put.java new file mode 100644 index 000000000..be47b08cf --- /dev/null +++ b/src/ru/fizteh/fivt/students/MaximGotovchits/Parallel/InterpreterPKG/Put.java @@ -0,0 +1,31 @@ +package ru.fizteh.fivt.students.MaximGotovchits.Parallel.InterpreterPKG; + +import ru.fizteh.fivt.students.MaximGotovchits.Parallel.ObjectsPKG.ObjectStoreable; +import ru.fizteh.fivt.students.MaximGotovchits.Parallel.ObjectsPKG.ObjectTableProvider; + +public class Put { + void putFunction(String[] cmd, boolean fromCmdLine) { + if (Interpreter.tableIsChosen) { + String putParameter = new String(); + String key = cmd[1]; + for (int ind = 2; ind < cmd.length; ++ind) { + putParameter += cmd[ind] + " "; + } + putParameter = putParameter.substring(0, putParameter.length() - 1); + try { + ObjectStoreable value = (ObjectStoreable) new ObjectTableProvider(). + deserialize(Interpreter.currentTableObject, putParameter); + ObjectStoreable temp = (ObjectStoreable) Interpreter.currentTableObject.put(key, value); + if (temp == null) { + System.out.println("new"); + } else { + System.out.println("overwrite"); + } + } catch (Exception e) { + System.err.println(e); + } + } else { + Interpreter.informToChooseTable(); + } + } +} diff --git a/src/ru/fizteh/fivt/students/MaximGotovchits/Parallel/InterpreterPKG/Remove.java b/src/ru/fizteh/fivt/students/MaximGotovchits/Parallel/InterpreterPKG/Remove.java new file mode 100644 index 000000000..54c7c4071 --- /dev/null +++ b/src/ru/fizteh/fivt/students/MaximGotovchits/Parallel/InterpreterPKG/Remove.java @@ -0,0 +1,22 @@ +package ru.fizteh.fivt.students.MaximGotovchits.Parallel.InterpreterPKG; + +import ru.fizteh.fivt.students.MaximGotovchits.Parallel.ObjectsPKG.ObjectStoreable; + +public class Remove { + void removeFunction(String[] cmd) { + if (Interpreter.tableIsChosen) { + try { + ObjectStoreable temp = (ObjectStoreable) Interpreter.currentTableObject.remove(cmd[1]); + if (temp == null) { + System.out.println("not found"); + } else { + System.out.println("removed"); + } + } catch (Exception e) { + System.err.println(e); + } + } else { + Interpreter.informToChooseTable(); + } + } +} diff --git a/src/ru/fizteh/fivt/students/MaximGotovchits/Parallel/InterpreterPKG/Rollback.java b/src/ru/fizteh/fivt/students/MaximGotovchits/Parallel/InterpreterPKG/Rollback.java new file mode 100644 index 000000000..294c990bf --- /dev/null +++ b/src/ru/fizteh/fivt/students/MaximGotovchits/Parallel/InterpreterPKG/Rollback.java @@ -0,0 +1,7 @@ +package ru.fizteh.fivt.students.MaximGotovchits.Parallel.InterpreterPKG; + +public class Rollback { + void rollbackFunction() { + Interpreter.currentTableObject.rollback(); + } +} diff --git a/src/ru/fizteh/fivt/students/MaximGotovchits/Parallel/InterpreterPKG/ShowTables.java b/src/ru/fizteh/fivt/students/MaximGotovchits/Parallel/InterpreterPKG/ShowTables.java new file mode 100644 index 000000000..0ab1a4740 --- /dev/null +++ b/src/ru/fizteh/fivt/students/MaximGotovchits/Parallel/InterpreterPKG/ShowTables.java @@ -0,0 +1,9 @@ +package ru.fizteh.fivt.students.MaximGotovchits.Parallel.InterpreterPKG; + +import ru.fizteh.fivt.students.MaximGotovchits.Parallel.ObjectsPKG.ObjectTableProvider; + +public class ShowTables { + void showTablesFunction() { + new ObjectTableProvider().getTableNames(); + } +} diff --git a/src/ru/fizteh/fivt/students/MaximGotovchits/Parallel/Use.java b/src/ru/fizteh/fivt/students/MaximGotovchits/Parallel/InterpreterPKG/Use.java similarity index 58% rename from src/ru/fizteh/fivt/students/MaximGotovchits/Parallel/Use.java rename to src/ru/fizteh/fivt/students/MaximGotovchits/Parallel/InterpreterPKG/Use.java index c603aa881..546fb7340 100644 --- a/src/ru/fizteh/fivt/students/MaximGotovchits/Parallel/Use.java +++ b/src/ru/fizteh/fivt/students/MaximGotovchits/Parallel/InterpreterPKG/Use.java @@ -1,27 +1,31 @@ -package ru.fizteh.fivt.students.MaximGotovchits.Parallel; +package ru.fizteh.fivt.students.MaximGotovchits.Parallel.InterpreterPKG; +import ru.fizteh.fivt.students.MaximGotovchits.Parallel.ObjectsPKG.ObjectStoreable; +import ru.fizteh.fivt.students.MaximGotovchits.Parallel.ObjectsPKG.ObjectTable; +import ru.fizteh.fivt.students.MaximGotovchits.Parallel.ObjectsPKG.ObjectTableProvider; import java.io.*; import java.nio.charset.StandardCharsets; import java.text.ParseException; -public class Use extends CommandsTools { +public class Use { public boolean useFunction(String tableName, String oldTableName) throws Exception { if (!tableName.equals(oldTableName)) { String outputName = tableName; - String tablePath = dataBaseName + "/" + tableName; + String tablePath = Interpreter.DATA_BASE_NAME + File.separator + tableName; File file = new File(tablePath); if (file.exists()) { - usingTableName = tableName; - if (tableIsChosen) { - new FillTable().fillTableFunction(currentTableObject); - currentTableObject.storage.get().clear(); - currentTableObject.commitStorage.clear(); + Interpreter.usingTableName = tableName; + if (Interpreter.tableIsChosen) { + new FillTable().fillTableFunction(Interpreter.currentTableObject); + Interpreter.currentTableObject.storage.get().clear(); + Interpreter.currentTableObject.commitStorage.clear(); } - currentTableObject = new ObjectTable(dataBaseName + File.separator + usingTableName); - for (Integer i = 0; i < dirNum; ++i) { - for (Integer j = 0; j < fileNum; ++j) { - tablePath = dataBaseName + File.separator + tableName + File.separator - + i + dirExt + File.separator + j + fileExt; + Interpreter.currentTableObject = new ObjectTable(Interpreter.DATA_BASE_NAME + File.separator + + Interpreter.usingTableName); + for (Integer i = 0; i < Interpreter.dirNum; ++i) { + for (Integer j = 0; j < Interpreter.fileNum; ++j) { + tablePath = Interpreter.DATA_BASE_NAME + File.separator + tableName + File.separator + + i + Interpreter.dirExt + File.separator + j + Interpreter.fileExt; if (new File(tablePath).exists()) { fillStorage(tablePath, file); PrintWriter writer = new PrintWriter(new File(tablePath)); @@ -31,7 +35,7 @@ public boolean useFunction(String tableName, String oldTableName) throws Excepti } } System.out.println("using " + outputName); - tableIsChosen = true; + Interpreter.tableIsChosen = true; } else { System.err.println(tableName + " not exists"); return false; @@ -39,9 +43,10 @@ public boolean useFunction(String tableName, String oldTableName) throws Excepti } else { System.out.println("using " + oldTableName); } - usingTableName = currentTableObject.getName(); + Interpreter.usingTableName = Interpreter.currentTableObject.getName(); return true; } + void fillStorage(String datName, File file) throws IOException, ParseException { DataInputStream stream = new DataInputStream(new FileInputStream(datName)); file = new File(datName); @@ -62,8 +67,8 @@ void fillStorage(String datName, File file) throws IOException, ParseException { String tableName = new File(new File(datName).getParent()).getParent(); ObjectStoreable valForMap = (ObjectStoreable) new ObjectTableProvider().deserialize(new ObjectTable(tableName), value); - currentTableObject.storage.get().put(keyForMap, valForMap); - currentTableObject.commitStorage.put(keyForMap, valForMap); + Interpreter.currentTableObject.storage.get().put(keyForMap, valForMap); + Interpreter.currentTableObject.commitStorage.put(keyForMap, valForMap); counter = counter + offset + 3; } stream.close(); diff --git a/src/ru/fizteh/fivt/students/MaximGotovchits/Parallel/ObjectStoreable.java b/src/ru/fizteh/fivt/students/MaximGotovchits/Parallel/ObjectsPKG/ObjectStoreable.java similarity index 93% rename from src/ru/fizteh/fivt/students/MaximGotovchits/Parallel/ObjectStoreable.java rename to src/ru/fizteh/fivt/students/MaximGotovchits/Parallel/ObjectsPKG/ObjectStoreable.java index 588c55982..1283da515 100644 --- a/src/ru/fizteh/fivt/students/MaximGotovchits/Parallel/ObjectStoreable.java +++ b/src/ru/fizteh/fivt/students/MaximGotovchits/Parallel/ObjectsPKG/ObjectStoreable.java @@ -1,4 +1,4 @@ -package ru.fizteh.fivt.students.MaximGotovchits.Parallel; +package ru.fizteh.fivt.students.MaximGotovchits.Parallel.ObjectsPKG; import ru.fizteh.fivt.storage.structured.ColumnFormatException; import ru.fizteh.fivt.storage.structured.Storeable; @@ -7,29 +7,38 @@ import java.util.List; import java.util.Objects; -public class ObjectStoreable extends CommandsTools implements Storeable { +public class ObjectStoreable implements Storeable { + private static final String LEFT_BRACE = "["; + private static final String RIGHT_BRACE = "]"; + private static final String COMMA_AND_SPACE = ", "; public List subValueList = new LinkedList<>(); + private static ObjectTable currentTableObject; public String serialisedValue = new String(); public List> typeKeeper = new LinkedList<>(); + public ObjectStoreable() {} + public ObjectStoreable(List values) { int ind = 0; - serialisedValue = "["; + serialisedValue = LEFT_BRACE; for (Object val : values) { subValueList.add(val); - serialisedValue += val + ", "; + serialisedValue += val + COMMA_AND_SPACE; } serialisedValue = serialisedValue.substring(0, serialisedValue.length() - 2); - serialisedValue += "]"; + serialisedValue += RIGHT_BRACE; } + public ObjectStoreable(Storeable value) { subValueList = ((ObjectStoreable) value).subValueList; serialisedValue = ((ObjectStoreable) value).serialisedValue; typeKeeper = ((ObjectStoreable) value).typeKeeper; } + public ObjectStoreable(ObjectTable table) { typeKeeper = table.typeKeeper; } + public ObjectStoreable(String value) throws ParseException { ObjectStoreable obj = (ObjectStoreable) new ObjectTableProvider().deserialize(currentTableObject, value); if (obj == null) { @@ -39,10 +48,12 @@ public ObjectStoreable(String value) throws ParseException { serialisedValue = obj.serialisedValue; typeKeeper = obj.typeKeeper; } + @Override public int hashCode() { return Objects.hashCode(this.serialisedValue); } + @Override public boolean equals(Object obj) { ObjectStoreable storeableObj = (ObjectStoreable) obj; @@ -53,6 +64,7 @@ public boolean equals(Object obj) { } return false; } + @Override public void setColumnAt(int columnIndex, Object value) throws ColumnFormatException, IndexOutOfBoundsException { try { @@ -74,14 +86,15 @@ public void setColumnAt(int columnIndex, Object value) throws ColumnFormatExcept } this.subValueList.set(columnIndex, value); this.serialisedValue = ""; - serialisedValue = "["; + serialisedValue = LEFT_BRACE; for (Object val : this.subValueList) { - serialisedValue += val + ", "; + serialisedValue += val + COMMA_AND_SPACE; } serialisedValue = serialisedValue.substring(0, serialisedValue.length() - 2); // Откусить ", ". - serialisedValue += "]"; + serialisedValue += RIGHT_BRACE; return; } + @Override public Object getColumnAt(int columnIndex) throws IndexOutOfBoundsException { if (subValueList.size() < columnIndex - 1) { @@ -89,6 +102,7 @@ public Object getColumnAt(int columnIndex) throws IndexOutOfBoundsException { } return subValueList.get(columnIndex); } + @Override public Integer getIntAt(int columnIndex) throws ColumnFormatException, IndexOutOfBoundsException { if (columnIndex >= subValueList.size()) { @@ -99,6 +113,7 @@ public Integer getIntAt(int columnIndex) throws ColumnFormatException, IndexOutO } return (Integer) subValueList.get(columnIndex); } + @Override public Long getLongAt(int columnIndex) throws ColumnFormatException, IndexOutOfBoundsException { try { @@ -115,6 +130,7 @@ public Long getLongAt(int columnIndex) throws ColumnFormatException, IndexOutOfB } return (Long) subValueList.get(columnIndex); } + @Override public Byte getByteAt(int columnIndex) throws ColumnFormatException, IndexOutOfBoundsException { try { @@ -131,6 +147,7 @@ public Byte getByteAt(int columnIndex) throws ColumnFormatException, IndexOutOfB } return (Byte) subValueList.get(columnIndex); } + @Override public Float getFloatAt(int columnIndex) throws ColumnFormatException, IndexOutOfBoundsException { try { @@ -147,6 +164,7 @@ public Float getFloatAt(int columnIndex) throws ColumnFormatException, IndexOutO } return (Float) subValueList.get(columnIndex); } + @Override public Double getDoubleAt(int columnIndex) throws ColumnFormatException, IndexOutOfBoundsException { try { @@ -163,6 +181,7 @@ public Double getDoubleAt(int columnIndex) throws ColumnFormatException, IndexOu } return (Double) subValueList.get(columnIndex); } + @Override public Boolean getBooleanAt(int columnIndex) throws ColumnFormatException, IndexOutOfBoundsException { try { @@ -179,6 +198,7 @@ public Boolean getBooleanAt(int columnIndex) throws ColumnFormatException, Index } return (Boolean) subValueList.get(columnIndex); } + @Override public String getStringAt(int columnIndex) throws ColumnFormatException, IndexOutOfBoundsException { try { @@ -195,6 +215,7 @@ public String getStringAt(int columnIndex) throws ColumnFormatException, IndexOu } return subValueList.get(columnIndex).toString(); } + private List> convertToPrimitive(List> list) { List> toReturn = new LinkedList<>(); for (Class object : list) { diff --git a/src/ru/fizteh/fivt/students/MaximGotovchits/Parallel/ObjectTable.java b/src/ru/fizteh/fivt/students/MaximGotovchits/Parallel/ObjectsPKG/ObjectTable.java similarity index 89% rename from src/ru/fizteh/fivt/students/MaximGotovchits/Parallel/ObjectTable.java rename to src/ru/fizteh/fivt/students/MaximGotovchits/Parallel/ObjectsPKG/ObjectTable.java index 61e5f8b3c..9c079a3f7 100644 --- a/src/ru/fizteh/fivt/students/MaximGotovchits/Parallel/ObjectTable.java +++ b/src/ru/fizteh/fivt/students/MaximGotovchits/Parallel/ObjectsPKG/ObjectTable.java @@ -1,8 +1,9 @@ -package ru.fizteh.fivt.students.MaximGotovchits.Parallel; +package ru.fizteh.fivt.students.MaximGotovchits.Parallel.ObjectsPKG; import ru.fizteh.fivt.storage.structured.ColumnFormatException; import ru.fizteh.fivt.storage.structured.Storeable; import ru.fizteh.fivt.storage.structured.Table; + import java.io.File; import java.io.IOException; import java.nio.charset.Charset; @@ -10,8 +11,13 @@ import java.nio.file.Paths; import java.util.*; -public class ObjectTable extends CommandsTools implements Table { +public class ObjectTable implements Table { static int overwriteNum = 0; + private static final String JSON_REG_EX = "\\s*,\\s*(?=(?:(?:[^\"]*\"){2})*[^\"]*$)"; // Removes commas + // outside of "...". + public static String usingTableName = new String(); // OR public static String usingTableName; + private static final String DATA_BASE_NAME = System.getProperty("fizteh.db.dir"); + private static final String SIGNATURE_FILENAME = "signature.tsv"; public ThreadLocal lastChanges = new ThreadLocal() { @Override @@ -19,53 +25,57 @@ protected Stack initialValue() { return new Stack(); } }; + public ThreadLocal> storage = new ThreadLocal>() { @Override protected HashMap initialValue() { return new HashMap(); } }; + public Map commitStorage = new HashMap<>(); public String tableName = new String(); public List> typeKeeper = new LinkedList>(); + public ObjectTable(Table table) { ObjectTable temp = (ObjectTable) table; this.tableName = temp.tableName; this.typeKeeper = temp.typeKeeper; } + public ObjectTable(String name) { if (!new File(name).isAbsolute()) { - name = dataBaseName + File.separator + name; + name = DATA_BASE_NAME + File.separator + name; } this.tableName = new File(name).getName(); String content = new String(); try { - if (!new File(name + File.separator + signatureFileName).isAbsolute()) { - name = dataBaseName + File.separator + name; + if (!new File(name + File.separator + SIGNATURE_FILENAME).isAbsolute()) { + name = DATA_BASE_NAME + File.separator + name; } - content = readFile(name + File.separator + signatureFileName, Charset.defaultCharset()); + content = readFile(name + File.separator + SIGNATURE_FILENAME, Charset.defaultCharset()); content.replaceAll("\\s+", " "); String[] types = content.split(" "); - int ind = 0; for (String type : types) { - typeKeeper.add(ind, getType(type)); - ++ind; + typeKeeper.add(getType(type)); } } catch (IOException s) { System.err.println(s); } } + public ObjectTable(String name, List> typeList) { - int ind = 0; for (Class type : typeList) { typeKeeper.add(type); } tableName = name; } + @Override public int hashCode() { return Objects.hashCode(this.tableName); } + @Override public boolean equals(Object obj) { ObjectTable tableObj = (ObjectTable) obj; @@ -74,10 +84,12 @@ public boolean equals(Object obj) { } return false; } + @Override public String getName() { return tableName; } + @Override public Storeable get(String key) throws IllegalArgumentException { // В документации в Index // не сказано, когда кидать ParseException, однако согласно интерфейсу тут все-таки написано @@ -87,14 +99,12 @@ public Storeable get(String key) throws IllegalArgumentException { // В док } ObjectStoreable value = storage.get().get(key); if (value == null) { - System.err.println("not found"); return null; } String serializedValue = value.serialisedValue; - System.out.println("found"); - System.out.println(serializedValue); return value; } + @Override public Storeable put(String key, Storeable value) throws ColumnFormatException { if (key == null || value == null) { @@ -107,9 +117,7 @@ public Storeable put(String key, Storeable value) throws ColumnFormatException { if (previousValue == null) { lastChanges.get().push(key); lastChanges.get().push("remove"); - System.out.println("new"); } else { - System.out.println("overwrite"); lastChanges.get().push(previousValue); lastChanges.get().push(key); lastChanges.get().push("put"); @@ -118,6 +126,7 @@ public Storeable put(String key, Storeable value) throws ColumnFormatException { } return previousValue; } + @Override public Storeable remove(String key) { if (key == null) { @@ -129,16 +138,15 @@ public Storeable remove(String key) { lastChanges.get().push(value); lastChanges.get().push(key); lastChanges.get().push("put"); - System.out.println("removed"); - } else { - System.out.println("not found"); } return value; } + @Override public int size() { return storage.get().size(); } + @Override public List list() { LinkedList list = new LinkedList(); @@ -158,13 +166,15 @@ public List list() { } return list; } + @Override - public synchronized int commit() { + public int commit() { int savedKeys = Math.abs(storage.get().size() - commitStorage.size()); commitStorage = new HashMap(storage.get()); lastChanges.get().clear(); return savedKeys; } + @Override public int rollback() throws IllegalArgumentException { int changes = Math.abs(storage.get().size() - commitStorage.size() + overwriteNum); @@ -183,15 +193,18 @@ public int rollback() throws IllegalArgumentException { overwriteNum = 0; return changes; } + @Override public int getNumberOfUncommittedChanges() { int numberOfUncommitedChanges = Math.abs(storage.get().size() - commitStorage.size()); return numberOfUncommitedChanges; } + @Override public int getColumnsCount() { return typeKeeper.size(); } + @Override public Class getColumnType(int columnIndex) throws IndexOutOfBoundsException { if (this.getColumnsCount() < columnIndex - 1) { @@ -200,11 +213,15 @@ public Class getColumnType(int columnIndex) throws IndexOutOfBoundsException Class objectToReturn = typeKeeper.get(columnIndex); return objectToReturn; } + static String readFile(String path, Charset encoding) throws IOException { byte[] encoded = Files.readAllBytes(Paths.get(path)); String temp = new String(encoded, encoding); return temp.replaceAll("^\\s*|\\s*$", ""); } + + + private Class getType(String typeName) { if (typeName.equals("int")) { return int.class; diff --git a/src/ru/fizteh/fivt/students/MaximGotovchits/Parallel/ObjectTableProvider.java b/src/ru/fizteh/fivt/students/MaximGotovchits/Parallel/ObjectsPKG/ObjectTableProvider.java similarity index 90% rename from src/ru/fizteh/fivt/students/MaximGotovchits/Parallel/ObjectTableProvider.java rename to src/ru/fizteh/fivt/students/MaximGotovchits/Parallel/ObjectsPKG/ObjectTableProvider.java index 2ca92ac25..2fa504c46 100644 --- a/src/ru/fizteh/fivt/students/MaximGotovchits/Parallel/ObjectTableProvider.java +++ b/src/ru/fizteh/fivt/students/MaximGotovchits/Parallel/ObjectsPKG/ObjectTableProvider.java @@ -1,4 +1,4 @@ -package ru.fizteh.fivt.students.MaximGotovchits.Parallel; +package ru.fizteh.fivt.students.MaximGotovchits.Parallel.ObjectsPKG; import ru.fizteh.fivt.storage.structured.ColumnFormatException; import ru.fizteh.fivt.storage.structured.Storeable; @@ -13,19 +13,35 @@ import java.util.concurrent.locks.ReadWriteLock; import java.util.concurrent.locks.ReentrantReadWriteLock; -public class ObjectTableProvider extends CommandsTools implements TableProvider { +public class ObjectTableProvider implements TableProvider { + private static final String BRACES_KILLER = "^\\s*\\[\\s*|\\s*\\]\\s*$"; + private static final String FILE_EXT = ".dat"; + private static final Integer FILE_NUM = 16; + private static final String DIR_EXT = ".dir"; + private static final Integer DIR_NUM = 16; + private static final String JSON_REG_EX = "\\s*,\\s*(?=(?:(?:[^\"]*\"){2})*[^\"]*$)"; + private static String usingTableName; + private static ObjectTable currentTableObject; + private static final int LONGEST_NAME = 260; + private static final String SIGNATURE_FILENAME = "signature.tsv"; + private static Boolean tableIsChosen = false; + private static String dataBaseName = System.getProperty("fizteh.db.dir"); private volatile boolean writeSectionIsInUse = false; private String rootDirectory = new String(); + public ObjectTableProvider() { rootDirectory = dataBaseName; } + public ObjectTableProvider(String dir) { dataBaseName = dir; rootDirectory = dir; } + public int hashCode() { return Objects.hashCode(this.rootDirectory); } + @Override public boolean equals(Object obj) { ObjectTableProvider tempObj = (ObjectTableProvider) obj; @@ -53,7 +69,7 @@ public Table createTable(String name, List> columnTypes) throws IOExcep readWriteLock.writeLock().lock(); checkException(name); File file = new File(rootDirectory + File.separator + name); - File signatureFile = new File(rootDirectory + File.separator + name + File.separator + signatureFileName); + File signatureFile = new File(rootDirectory + File.separator + name + File.separator + SIGNATURE_FILENAME); if (file.exists()) { System.out.println(name + " exists"); } else { @@ -79,7 +95,7 @@ public Table createTable(String name, List> columnTypes) throws IOExcep } @Override public void removeTable(String name) throws IllegalArgumentException, IllegalStateException { - if (name == null || name.length() > longestName) { + if (name == null || name.length() > LONGEST_NAME) { throw new IllegalArgumentException(); } String tableName = rootDirectory + File.separator + name; @@ -110,7 +126,7 @@ public Storeable deserialize(Table table, String value) throws ParseException { throw new ParseException(value, 0); } valueToReturn.serialisedValue = value; - value = value.replaceAll("^\\s*\\[\\s*|\\s*\\]\\s*$", ""); // Removing [ and ]. + value = value.replaceAll(BRACES_KILLER, ""); // Removing [ and ]. String[] tempValue = value.split(JSON_REG_EX); // Split by comma. if (usingTable.getColumnsCount() != tempValue.length) { throw new ParseException(value, 0); @@ -175,14 +191,14 @@ public List getTableNames() { for (File sub : file.listFiles()) { if ((!sub.isHidden()) && sub.isDirectory()) { recordsAmount = 0; - for (Integer i = 0; i < dirNum; ++i) { + for (Integer i = 0; i < DIR_NUM; ++i) { currentFile = rootDirectory + File.separator + sub.getName() + File.separator - + i + dirExt; + + i + DIR_EXT; File file1 = new File(currentFile); if (file1.exists()) { - for (Integer j = 0; j < fileNum; ++j) { + for (Integer j = 0; j < FILE_NUM; ++j) { currentFile = rootDirectory + File.separator + sub.getName() + File.separator - + i + dirExt + File.separator + j + fileExt; + + i + DIR_EXT + File.separator + j + FILE_EXT; file1 = new File(currentFile); try { if (file1.exists()) { @@ -286,7 +302,7 @@ void recRem(String myFile) { } public void checkException(String name) throws IllegalArgumentException { - if (name == null || name.length() > longestName) { + if (name == null || name.length() > LONGEST_NAME) { throw new IllegalArgumentException(); } } diff --git a/src/ru/fizteh/fivt/students/MaximGotovchits/Parallel/ObjectTableProviderFactory.java b/src/ru/fizteh/fivt/students/MaximGotovchits/Parallel/ObjectsPKG/ObjectTableProviderFactory.java similarity index 66% rename from src/ru/fizteh/fivt/students/MaximGotovchits/Parallel/ObjectTableProviderFactory.java rename to src/ru/fizteh/fivt/students/MaximGotovchits/Parallel/ObjectsPKG/ObjectTableProviderFactory.java index 67e3306bf..76ceaac37 100644 --- a/src/ru/fizteh/fivt/students/MaximGotovchits/Parallel/ObjectTableProviderFactory.java +++ b/src/ru/fizteh/fivt/students/MaximGotovchits/Parallel/ObjectsPKG/ObjectTableProviderFactory.java @@ -1,15 +1,17 @@ -package ru.fizteh.fivt.students.MaximGotovchits.Parallel; +package ru.fizteh.fivt.students.MaximGotovchits.Parallel.ObjectsPKG; import ru.fizteh.fivt.storage.structured.TableProvider; import ru.fizteh.fivt.storage.structured.TableProviderFactory; -public class ObjectTableProviderFactory extends CommandsTools implements TableProviderFactory { +public class ObjectTableProviderFactory implements TableProviderFactory { + private static final int LONGEST_NAME = 260; String dirName; + @Override public TableProvider create(String dir) throws IllegalArgumentException { dirName = dir; try { - if (dir == null || dir.length() > longestName) { + if (dir == null || dir.length() > LONGEST_NAME) { throw new IllegalArgumentException(); } } catch (IllegalArgumentException s) { diff --git a/src/ru/fizteh/fivt/students/MaximGotovchits/Parallel/Test/ObjectStoreableTest.java b/src/ru/fizteh/fivt/students/MaximGotovchits/Parallel/TestPKG/ObjectStoreableTest.java similarity index 90% rename from src/ru/fizteh/fivt/students/MaximGotovchits/Parallel/Test/ObjectStoreableTest.java rename to src/ru/fizteh/fivt/students/MaximGotovchits/Parallel/TestPKG/ObjectStoreableTest.java index 2b9f32425..a9227f715 100644 --- a/src/ru/fizteh/fivt/students/MaximGotovchits/Parallel/Test/ObjectStoreableTest.java +++ b/src/ru/fizteh/fivt/students/MaximGotovchits/Parallel/TestPKG/ObjectStoreableTest.java @@ -1,11 +1,11 @@ -package ru.fizteh.fivt.students.MaximGotovchits.Parallel.Test; +package ru.fizteh.fivt.students.MaximGotovchits.Parallel.TestPKG; import org.junit.After; import org.junit.Before; import org.junit.Test; -import ru.fizteh.fivt.students.MaximGotovchits.Parallel.ObjectStoreable; -import ru.fizteh.fivt.students.MaximGotovchits.Parallel.ObjectTable; -import ru.fizteh.fivt.students.MaximGotovchits.Parallel.ObjectTableProvider; +import ru.fizteh.fivt.students.MaximGotovchits.Parallel.ObjectsPKG.ObjectStoreable; +import ru.fizteh.fivt.students.MaximGotovchits.Parallel.ObjectsPKG.ObjectTable; +import ru.fizteh.fivt.students.MaximGotovchits.Parallel.ObjectsPKG.ObjectTableProvider; import java.io.IOException; import java.util.LinkedList; import java.util.List; @@ -16,7 +16,6 @@ public class ObjectStoreableTest { public String name; public List> columnTypes = new LinkedList>(); - //public ObjectTable tableToCompare = new ObjectTable(); public ObjectStoreable deserializedValue = new ObjectStoreable(); public ObjectTable table; public String valueToDeserialize; @@ -31,8 +30,6 @@ public void initialization() throws IOException { columnTypes.add(byte.class); columnTypes.add(boolean.class); columnTypes.add(String.class); - //tableToCompare.typeKeeper = columnTypes; - //tableToCompare.tableName = name; deserializedValue.subValueList.add(100500); deserializedValue.subValueList.add((long) 10000000); deserializedValue.subValueList.add(123.456); diff --git a/src/ru/fizteh/fivt/students/MaximGotovchits/Parallel/Test/ObjectTableProviderFactoryTest.java b/src/ru/fizteh/fivt/students/MaximGotovchits/Parallel/TestPKG/ObjectTableProviderFactoryTest.java similarity index 64% rename from src/ru/fizteh/fivt/students/MaximGotovchits/Parallel/Test/ObjectTableProviderFactoryTest.java rename to src/ru/fizteh/fivt/students/MaximGotovchits/Parallel/TestPKG/ObjectTableProviderFactoryTest.java index d84ca4689..b9349180e 100644 --- a/src/ru/fizteh/fivt/students/MaximGotovchits/Parallel/Test/ObjectTableProviderFactoryTest.java +++ b/src/ru/fizteh/fivt/students/MaximGotovchits/Parallel/TestPKG/ObjectTableProviderFactoryTest.java @@ -1,8 +1,8 @@ -package ru.fizteh.fivt.students.MaximGotovchits.Parallel.Test; +package ru.fizteh.fivt.students.MaximGotovchits.Parallel.TestPKG; import org.junit.Test; -import ru.fizteh.fivt.students.MaximGotovchits.Parallel.ObjectTableProvider; -import ru.fizteh.fivt.students.MaximGotovchits.Parallel.ObjectTableProviderFactory; +import ru.fizteh.fivt.students.MaximGotovchits.Parallel.ObjectsPKG.ObjectTableProvider; +import ru.fizteh.fivt.students.MaximGotovchits.Parallel.ObjectsPKG.ObjectTableProviderFactory; import static org.junit.Assert.assertEquals; public class ObjectTableProviderFactoryTest { diff --git a/src/ru/fizteh/fivt/students/MaximGotovchits/Parallel/Test/ObjectTableProviderTest.java b/src/ru/fizteh/fivt/students/MaximGotovchits/Parallel/TestPKG/ObjectTableProviderTest.java similarity index 87% rename from src/ru/fizteh/fivt/students/MaximGotovchits/Parallel/Test/ObjectTableProviderTest.java rename to src/ru/fizteh/fivt/students/MaximGotovchits/Parallel/TestPKG/ObjectTableProviderTest.java index 5ff77129d..248b35bd5 100644 --- a/src/ru/fizteh/fivt/students/MaximGotovchits/Parallel/Test/ObjectTableProviderTest.java +++ b/src/ru/fizteh/fivt/students/MaximGotovchits/Parallel/TestPKG/ObjectTableProviderTest.java @@ -1,10 +1,10 @@ -package ru.fizteh.fivt.students.MaximGotovchits.Parallel.Test; +package ru.fizteh.fivt.students.MaximGotovchits.Parallel.TestPKG; import static org.junit.Assert.assertEquals; import org.junit.*; -import ru.fizteh.fivt.students.MaximGotovchits.Parallel.ObjectStoreable; -import ru.fizteh.fivt.students.MaximGotovchits.Parallel.ObjectTable; -import ru.fizteh.fivt.students.MaximGotovchits.Parallel.ObjectTableProvider; +import ru.fizteh.fivt.students.MaximGotovchits.Parallel.ObjectsPKG.ObjectStoreable; +import ru.fizteh.fivt.students.MaximGotovchits.Parallel.ObjectsPKG.ObjectTable; +import ru.fizteh.fivt.students.MaximGotovchits.Parallel.ObjectsPKG.ObjectTableProvider; import java.io.IOException; import java.util.LinkedList; import java.util.List; @@ -41,20 +41,20 @@ public void createAndGetTableTest() throws IOException { assertEquals(null, createTable(name, columnTypes)); assertEquals(testTable, getTable(name)); } - // @Test + // @TestPKG // public void deserializeTest() throws ParseException, IOException { // assertEquals(deserializedValue, (ObjectStoreable) deserialize(table, valueToDeserialize)); // } - /*@Test(expected = IllegalArgumentException.class) // Это была попытка сделать тест на исключения. + /*@TestPKG(expected = IllegalArgumentException.class) // Это была попытка сделать тест на исключения. //В следующей задаче я постараюсь это сделать. Просто нужно изменять кучу кода. public void createNullTableTest() throws IOException { createTable(null, columnTypes); }*/ - /*@Test + /*@TestPKG public void serializeTest() { assertEquals(valueToDeserialize, serialize(table, deserializedValue)); } - @Test + @TestPKG public void createForTest() { ObjectStoreable tempStoreable = new ObjectStoreable(); tempStoreable.typeKeeper = table.typeKeeper; @@ -64,7 +64,7 @@ public void createForTest() { ObjectStoreable qq = (ObjectStoreable) createFor(table, deserializedValue.subValueList); assertEquals(tempStoreable, (ObjectStoreable) createFor(table, deserializedValue.subValueList)); } - @Test + @TestPKG public void getTableNamesTest() throws IOException { // Конечно же, стоит удостовериться, // что в рабочей директории на момент тестирования нет таблиц. List toCompare = new LinkedList(); diff --git a/src/ru/fizteh/fivt/students/MaximGotovchits/Parallel/Test/ObjectTableTest.java b/src/ru/fizteh/fivt/students/MaximGotovchits/Parallel/TestPKG/ObjectTableTest.java similarity index 92% rename from src/ru/fizteh/fivt/students/MaximGotovchits/Parallel/Test/ObjectTableTest.java rename to src/ru/fizteh/fivt/students/MaximGotovchits/Parallel/TestPKG/ObjectTableTest.java index 21bc0abaf..b090f751a 100644 --- a/src/ru/fizteh/fivt/students/MaximGotovchits/Parallel/Test/ObjectTableTest.java +++ b/src/ru/fizteh/fivt/students/MaximGotovchits/Parallel/TestPKG/ObjectTableTest.java @@ -1,11 +1,15 @@ -package ru.fizteh.fivt.students.MaximGotovchits.Parallel.Test; +package ru.fizteh.fivt.students.MaximGotovchits.Parallel.TestPKG; import static junit.framework.Assert.assertNull; import static org.junit.Assert.assertEquals; import static org.junit.Assert.assertTrue; import org.junit.*; import org.junit.Test; -import ru.fizteh.fivt.students.MaximGotovchits.Parallel.*; +import ru.fizteh.fivt.students.MaximGotovchits.Parallel.InterpreterPKG.Use; +import ru.fizteh.fivt.students.MaximGotovchits.Parallel.ObjectsPKG.ObjectStoreable; +import ru.fizteh.fivt.students.MaximGotovchits.Parallel.ObjectsPKG.ObjectTable; +import ru.fizteh.fivt.students.MaximGotovchits.Parallel.ObjectsPKG.ObjectTableProvider; + import java.io.IOException; import java.util.LinkedList; import java.util.List; From 674eeece79e88de8b9c73980a0af036f26056bf5 Mon Sep 17 00:00:00 2001 From: MaximGotovchits Date: Fri, 13 Feb 2015 22:23:09 +0300 Subject: [PATCH 13/18] New structure --- .../Parallel/BasePKG/Main.java | 22 --- .../Parallel/InterpreterPKG/Commit.java | 7 - .../Parallel/InterpreterPKG/Create.java | 77 ---------- .../Parallel/InterpreterPKG/Drop.java | 13 -- .../Parallel/InterpreterPKG/Exit.java | 24 ---- .../Parallel/InterpreterPKG/FillTable.java | 44 ------ .../Parallel/InterpreterPKG/Get.java | 23 --- .../Parallel/InterpreterPKG/Interpreter.java | 132 ------------------ .../Parallel/InterpreterPKG/List.java | 11 -- .../Parallel/InterpreterPKG/MakeDirs.java | 24 ---- .../Parallel/InterpreterPKG/Put.java | 31 ---- .../Parallel/InterpreterPKG/Remove.java | 22 --- .../Parallel/InterpreterPKG/Rollback.java | 7 - .../Parallel/InterpreterPKG/ShowTables.java | 9 -- .../MaximGotovchits/Parallel/base/Main.java | 51 +++++++ .../Parallel/base/commands/CommadTools.java | 19 +++ .../Parallel/base/commands/Commit.java | 20 +++ .../Parallel/base/commands/Create.java | 65 +++++++++ .../Parallel/base/commands/Drop.java | 24 ++++ .../Parallel/base/commands/Exit.java | 34 +++++ .../Parallel/base/commands/FillTable.java | 54 +++++++ .../Parallel/base/commands/Get.java | 33 +++++ .../Parallel/base/commands/List.java | 23 +++ .../Parallel/base/commands/MakeDirs.java | 33 +++++ .../Parallel/base/commands/Put.java | 41 ++++++ .../Parallel/base/commands/Remove.java | 32 +++++ .../Parallel/base/commands/Rollback.java | 19 +++ .../Parallel/base/commands/ShowTables.java | 20 +++ .../commands}/Use.java | 57 +++++--- .../Parallel/interpreter/Command.java | 9 ++ .../Parallel/interpreter/Interpreter.java | 61 ++++++++ .../ObjectStoreable.java | 18 ++- .../{ObjectsPKG => objects}/ObjectTable.java | 8 +- .../ObjectTableProvider.java | 2 +- .../ObjectTableProviderFactory.java | 2 +- .../ObjectStoreableTest.java | 8 +- .../ObjectTableProviderFactoryTest.java | 6 +- .../ObjectTableProviderTest.java | 18 +-- .../{TestPKG => test}/ObjectTableTest.java | 10 +- 39 files changed, 609 insertions(+), 504 deletions(-) delete mode 100644 src/ru/fizteh/fivt/students/MaximGotovchits/Parallel/BasePKG/Main.java delete mode 100644 src/ru/fizteh/fivt/students/MaximGotovchits/Parallel/InterpreterPKG/Commit.java delete mode 100644 src/ru/fizteh/fivt/students/MaximGotovchits/Parallel/InterpreterPKG/Create.java delete mode 100644 src/ru/fizteh/fivt/students/MaximGotovchits/Parallel/InterpreterPKG/Drop.java delete mode 100644 src/ru/fizteh/fivt/students/MaximGotovchits/Parallel/InterpreterPKG/Exit.java delete mode 100644 src/ru/fizteh/fivt/students/MaximGotovchits/Parallel/InterpreterPKG/FillTable.java delete mode 100644 src/ru/fizteh/fivt/students/MaximGotovchits/Parallel/InterpreterPKG/Get.java delete mode 100644 src/ru/fizteh/fivt/students/MaximGotovchits/Parallel/InterpreterPKG/Interpreter.java delete mode 100644 src/ru/fizteh/fivt/students/MaximGotovchits/Parallel/InterpreterPKG/List.java delete mode 100644 src/ru/fizteh/fivt/students/MaximGotovchits/Parallel/InterpreterPKG/MakeDirs.java delete mode 100644 src/ru/fizteh/fivt/students/MaximGotovchits/Parallel/InterpreterPKG/Put.java delete mode 100644 src/ru/fizteh/fivt/students/MaximGotovchits/Parallel/InterpreterPKG/Remove.java delete mode 100644 src/ru/fizteh/fivt/students/MaximGotovchits/Parallel/InterpreterPKG/Rollback.java delete mode 100644 src/ru/fizteh/fivt/students/MaximGotovchits/Parallel/InterpreterPKG/ShowTables.java create mode 100644 src/ru/fizteh/fivt/students/MaximGotovchits/Parallel/base/Main.java create mode 100644 src/ru/fizteh/fivt/students/MaximGotovchits/Parallel/base/commands/CommadTools.java create mode 100644 src/ru/fizteh/fivt/students/MaximGotovchits/Parallel/base/commands/Commit.java create mode 100644 src/ru/fizteh/fivt/students/MaximGotovchits/Parallel/base/commands/Create.java create mode 100644 src/ru/fizteh/fivt/students/MaximGotovchits/Parallel/base/commands/Drop.java create mode 100644 src/ru/fizteh/fivt/students/MaximGotovchits/Parallel/base/commands/Exit.java create mode 100644 src/ru/fizteh/fivt/students/MaximGotovchits/Parallel/base/commands/FillTable.java create mode 100644 src/ru/fizteh/fivt/students/MaximGotovchits/Parallel/base/commands/Get.java create mode 100644 src/ru/fizteh/fivt/students/MaximGotovchits/Parallel/base/commands/List.java create mode 100644 src/ru/fizteh/fivt/students/MaximGotovchits/Parallel/base/commands/MakeDirs.java create mode 100644 src/ru/fizteh/fivt/students/MaximGotovchits/Parallel/base/commands/Put.java create mode 100644 src/ru/fizteh/fivt/students/MaximGotovchits/Parallel/base/commands/Remove.java create mode 100644 src/ru/fizteh/fivt/students/MaximGotovchits/Parallel/base/commands/Rollback.java create mode 100644 src/ru/fizteh/fivt/students/MaximGotovchits/Parallel/base/commands/ShowTables.java rename src/ru/fizteh/fivt/students/MaximGotovchits/Parallel/{InterpreterPKG => base/commands}/Use.java (55%) create mode 100644 src/ru/fizteh/fivt/students/MaximGotovchits/Parallel/interpreter/Command.java create mode 100644 src/ru/fizteh/fivt/students/MaximGotovchits/Parallel/interpreter/Interpreter.java rename src/ru/fizteh/fivt/students/MaximGotovchits/Parallel/{ObjectsPKG => objects}/ObjectStoreable.java (95%) rename src/ru/fizteh/fivt/students/MaximGotovchits/Parallel/{ObjectsPKG => objects}/ObjectTable.java (98%) rename src/ru/fizteh/fivt/students/MaximGotovchits/Parallel/{ObjectsPKG => objects}/ObjectTableProvider.java (99%) rename src/ru/fizteh/fivt/students/MaximGotovchits/Parallel/{ObjectsPKG => objects}/ObjectTableProviderFactory.java (90%) rename src/ru/fizteh/fivt/students/MaximGotovchits/Parallel/{TestPKG => test}/ObjectStoreableTest.java (92%) rename src/ru/fizteh/fivt/students/MaximGotovchits/Parallel/{TestPKG => test}/ObjectTableProviderFactoryTest.java (64%) rename src/ru/fizteh/fivt/students/MaximGotovchits/Parallel/{TestPKG => test}/ObjectTableProviderTest.java (87%) rename src/ru/fizteh/fivt/students/MaximGotovchits/Parallel/{TestPKG => test}/ObjectTableTest.java (92%) diff --git a/src/ru/fizteh/fivt/students/MaximGotovchits/Parallel/BasePKG/Main.java b/src/ru/fizteh/fivt/students/MaximGotovchits/Parallel/BasePKG/Main.java deleted file mode 100644 index 6ef21f62f..000000000 --- a/src/ru/fizteh/fivt/students/MaximGotovchits/Parallel/BasePKG/Main.java +++ /dev/null @@ -1,22 +0,0 @@ -package ru.fizteh.fivt.students.MaximGotovchits.Parallel.BasePKG; - -import ru.fizteh.fivt.students.MaximGotovchits.Parallel.InterpreterPKG.Interpreter; -import ru.fizteh.fivt.students.MaximGotovchits.Parallel.InterpreterPKG.MakeDirs; -import ru.fizteh.fivt.students.MaximGotovchits.Parallel.InterpreterPKG.Exit; - -public class Main { // Using JSON format. - public static void main(final String[] args) throws Exception { - new MakeDirs().makeDirsFunction(); - if (args.length == 0) { - new Interpreter().getCmdFromStream(); - } else { - String cmd = new String(); - for (String arg : args) { - cmd += arg + " "; - } - cmd = cmd.replaceAll("\\s+", " "); - new Interpreter().parseDataFromCmdLine(cmd.substring(0, cmd.length() - 1)); - new Exit().exitFunction(); - } - } -} diff --git a/src/ru/fizteh/fivt/students/MaximGotovchits/Parallel/InterpreterPKG/Commit.java b/src/ru/fizteh/fivt/students/MaximGotovchits/Parallel/InterpreterPKG/Commit.java deleted file mode 100644 index a1a630fca..000000000 --- a/src/ru/fizteh/fivt/students/MaximGotovchits/Parallel/InterpreterPKG/Commit.java +++ /dev/null @@ -1,7 +0,0 @@ -package ru.fizteh.fivt.students.MaximGotovchits.Parallel.InterpreterPKG; - -public class Commit { - void commitFunction() { - Interpreter.currentTableObject.commit(); - } -} diff --git a/src/ru/fizteh/fivt/students/MaximGotovchits/Parallel/InterpreterPKG/Create.java b/src/ru/fizteh/fivt/students/MaximGotovchits/Parallel/InterpreterPKG/Create.java deleted file mode 100644 index 166a5c58d..000000000 --- a/src/ru/fizteh/fivt/students/MaximGotovchits/Parallel/InterpreterPKG/Create.java +++ /dev/null @@ -1,77 +0,0 @@ -package ru.fizteh.fivt.students.MaximGotovchits.Parallel.InterpreterPKG; - -import ru.fizteh.fivt.students.MaximGotovchits.Parallel.ObjectsPKG.ObjectTableProvider; - -import java.util.LinkedList; -import java.util.List; - -public class Create { - private static final String SPLIT_BY_RIGHT_BRACKET = "\\s*\\)\\s*"; - private static final String SPLIT_BY_LEFT_BRACKET = "\\s*\\(\\s*"; - private static final String SPLIT_BY_SPACE = "\\s+"; - - void createFunction(String[] cmd, boolean fromCmdLine) { - String createParameter = new String(); // (...) - type list. - String tableName = cmd[1]; - for (int ind = 2; ind < cmd.length; ++ind) { - createParameter += cmd[ind] + " "; - } - createParameter = createParameter.substring(0, createParameter.length() - 1); - List> typeList = new LinkedList<>(); - try { - typeList = getTypeList(createParameter, fromCmdLine); - new ObjectTableProvider().createTable(tableName, typeList); - } catch (Exception e) { - System.err.println(e); - } - } - - private List> getTypeList(String line, boolean fromCmdLine) throws Exception { - List> typeList = new LinkedList>(); - line = line.replaceAll(SPLIT_BY_RIGHT_BRACKET, ""); - line = line.replaceAll(SPLIT_BY_LEFT_BRACKET, ""); - String[] tmp = line.split(SPLIT_BY_SPACE); - for (String str : tmp) { - Class type = getType(str); - if (type != null) { - typeList.add(type); - } else { - Interpreter.syntaxError(); - if (fromCmdLine) { - System.exit(1); - } else { - Interpreter.getCmdFromStream(); - } - } - } - return typeList; - } - - private Class getType(String str) { - if (str.equals("int")) { - return int.class; - } - if (str.equals("long")) { - return long.class; - } - if (str.equals("double")) { - return double.class; - } - if (str.equals("float")) { - return float.class; - } - if (str.equals("double")) { - return double.class; - } - if (str.equals("boolean")) { - return boolean.class; - } - if (str.equals("byte")) { - return byte.class; - } - if (str.equals("String")) { - return String.class; - } - return null; - } -} diff --git a/src/ru/fizteh/fivt/students/MaximGotovchits/Parallel/InterpreterPKG/Drop.java b/src/ru/fizteh/fivt/students/MaximGotovchits/Parallel/InterpreterPKG/Drop.java deleted file mode 100644 index 3e2039c6e..000000000 --- a/src/ru/fizteh/fivt/students/MaximGotovchits/Parallel/InterpreterPKG/Drop.java +++ /dev/null @@ -1,13 +0,0 @@ -package ru.fizteh.fivt.students.MaximGotovchits.Parallel.InterpreterPKG; - -import ru.fizteh.fivt.students.MaximGotovchits.Parallel.ObjectsPKG.ObjectTableProvider; - -public class Drop { - void dropFunction(String[] cmd) { - try { - new ObjectTableProvider().removeTable(cmd[1]); - } catch (Exception e) { - System.err.println(e); - } - } -} diff --git a/src/ru/fizteh/fivt/students/MaximGotovchits/Parallel/InterpreterPKG/Exit.java b/src/ru/fizteh/fivt/students/MaximGotovchits/Parallel/InterpreterPKG/Exit.java deleted file mode 100644 index 79a3516d2..000000000 --- a/src/ru/fizteh/fivt/students/MaximGotovchits/Parallel/InterpreterPKG/Exit.java +++ /dev/null @@ -1,24 +0,0 @@ -package ru.fizteh.fivt.students.MaximGotovchits.Parallel.InterpreterPKG; - -public class Exit { - public void exitFunction() throws Exception { - if (Interpreter.currentTableObject != null) { - new FillTable().fillTableFunction(Interpreter.currentTableObject); - } - System.exit(0); - } - public boolean exitAndUseAvailable() { - if (Interpreter.currentTableObject != null) { - int uncommitedChanges = Interpreter.currentTableObject.storage.get().size() - - Interpreter.currentTableObject.commitStorage.size(); - if (uncommitedChanges == 0 || !Interpreter.tableIsChosen) { - return true; - } - System.out.println(uncommitedChanges + " uncommited changes"); - return false; - } - return true; - } -} - - diff --git a/src/ru/fizteh/fivt/students/MaximGotovchits/Parallel/InterpreterPKG/FillTable.java b/src/ru/fizteh/fivt/students/MaximGotovchits/Parallel/InterpreterPKG/FillTable.java deleted file mode 100644 index 742bec0bf..000000000 --- a/src/ru/fizteh/fivt/students/MaximGotovchits/Parallel/InterpreterPKG/FillTable.java +++ /dev/null @@ -1,44 +0,0 @@ -package ru.fizteh.fivt.students.MaximGotovchits.Parallel.InterpreterPKG; - -import ru.fizteh.fivt.students.MaximGotovchits.Parallel.ObjectsPKG.ObjectStoreable; -import ru.fizteh.fivt.students.MaximGotovchits.Parallel.ObjectsPKG.ObjectTable; -import java.io.DataOutputStream; -import java.io.File; -import java.io.FileOutputStream; -import java.nio.charset.StandardCharsets; -import java.nio.file.Path; -import java.nio.file.Paths; -import java.util.Map; - -public class FillTable { - private static final String FILE_EXT = ".dat"; - private static final Integer FILE_NUM = 16; - private static final String DIR_EXT = ".dir"; - private static final Integer DIR_NUM = 16; - private static final String DATA_BASE_NAME = System.getProperty("fizteh.db.dir"); - public void fillTableFunction(ObjectTable usingTable) throws Exception { - for (Map.Entry entry : usingTable.commitStorage.entrySet()) { - int hashCode = entry.getKey().hashCode(); - Integer nDirectory = hashCode % DIR_NUM; - Integer nFile = hashCode / DIR_NUM % FILE_NUM; - Path fileName = Paths.get(DATA_BASE_NAME + File.separator + usingTable.getName(), nDirectory + DIR_EXT); - File file = new File(fileName.toString()); - if (!file.exists()) { - file.mkdir(); - } - fileName = Paths.get(fileName.toString(), nFile + FILE_EXT); - file = new File(fileName.toString()); - if (!file.exists()) { - file.createNewFile(); - } - byte[] bytesKey = (" " + entry.getKey() + " ").getBytes(StandardCharsets.UTF_8); - DataOutputStream stream = new DataOutputStream(new FileOutputStream(fileName.toString(), true)); - stream.write((int) bytesKey.length); - stream.write(bytesKey); - byte[] bytesVal = ((" " + entry.getValue().serialisedValue + " ").getBytes(StandardCharsets.UTF_8)); - stream.write((int) bytesVal.length - 1); - stream.write(bytesVal); - stream.close(); - } - } -} diff --git a/src/ru/fizteh/fivt/students/MaximGotovchits/Parallel/InterpreterPKG/Get.java b/src/ru/fizteh/fivt/students/MaximGotovchits/Parallel/InterpreterPKG/Get.java deleted file mode 100644 index 6d07eb3eb..000000000 --- a/src/ru/fizteh/fivt/students/MaximGotovchits/Parallel/InterpreterPKG/Get.java +++ /dev/null @@ -1,23 +0,0 @@ -package ru.fizteh.fivt.students.MaximGotovchits.Parallel.InterpreterPKG; - -import ru.fizteh.fivt.students.MaximGotovchits.Parallel.ObjectsPKG.ObjectStoreable; - -public class Get { - void getFunction(String[] cmd, boolean fromCmdLine) { - try { - if (Interpreter.tableIsChosen) { - ObjectStoreable temp = (ObjectStoreable) Interpreter.currentTableObject.get(cmd[1]); - if (temp == null) { - System.err.println("not found"); - } else { - System.out.println("found"); - System.out.println(temp.serialisedValue); - } - } else { - Interpreter.informToChooseTable(); - } - } catch (Exception e) { - System.out.println(e); - } - } -} diff --git a/src/ru/fizteh/fivt/students/MaximGotovchits/Parallel/InterpreterPKG/Interpreter.java b/src/ru/fizteh/fivt/students/MaximGotovchits/Parallel/InterpreterPKG/Interpreter.java deleted file mode 100644 index 5965dd355..000000000 --- a/src/ru/fizteh/fivt/students/MaximGotovchits/Parallel/InterpreterPKG/Interpreter.java +++ /dev/null @@ -1,132 +0,0 @@ -package ru.fizteh.fivt.students.MaximGotovchits.Parallel.InterpreterPKG; - -import ru.fizteh.fivt.students.MaximGotovchits.Parallel.ObjectsPKG.ObjectTable; -import java.util.*; - -public class Interpreter { - static Boolean tableIsChosen = false; - static Integer dirNum = 16; - static Integer fileNum = 16; - static String dirExt = ".dir"; - static String fileExt = ".dat"; - static final String INVITATIONAL_SYMBOL = "$ "; - private static final String SPLIT_BY_COMMA = "\\s*;\\s*"; - private static final String SPLIT_BY_SPACE = "\\s+"; - static String usingTableName; - static ObjectTable currentTableObject; - protected static final String DATA_BASE_NAME = System.getProperty("fizteh.db.dir"); - - public void parseDataFromCmdLine(String cmdLine) throws Exception { - String[] splittedLine = cmdLine.split(SPLIT_BY_COMMA); - for (String line : splittedLine) { - String[] cmd = line.split(SPLIT_BY_SPACE); - executionFunction(cmd, true); // True means that data is from command line. - } - } - - public static void getCmdFromStream() throws Exception { - Scanner scan = new Scanner(System.in); - System.out.print(INVITATIONAL_SYMBOL); - String[] cmd = scan.nextLine().split(SPLIT_BY_SPACE); - executionFunction(cmd, false); // False means that data is from "System.in". - } - - static void executionFunction(String[] cmd, boolean fromCmdLine) throws Exception { // The main interpreter - // function. - if (cmd[0].equals("create") && cmd.length > 2) { - new Create().createFunction(cmd, fromCmdLine); - ifContinue(fromCmdLine); - } - - if (cmd[0].equals("use") && cmd.length == 2) { - String tableName = cmd[1]; - boolean changeUsingTable = false; - try { - if (tableIsChosen) { - new Use().useFunction(tableName, currentTableObject.getName()); - } else { - tableIsChosen = new Use().useFunction(tableName, null); - } - } catch (Exception e) { - printExceptionMessage(e); - } - ifContinue(fromCmdLine); - } - - if (cmd[0].equals("put") && cmd.length > 2) { - new Put().putFunction(cmd, fromCmdLine); - ifContinue(fromCmdLine); - } - - if (cmd[0].equals("commit") && cmd.length == 1) { - new Commit().commitFunction(); - ifContinue(fromCmdLine); - } - - if (cmd[0].equals("show") && cmd[1].equals("tables") && cmd.length == 2) { - new ShowTables().showTablesFunction(); - ifContinue(fromCmdLine); - } - - if (cmd[0].equals("get") && cmd.length == 2) { - new Get().getFunction(cmd, fromCmdLine); - ifContinue(fromCmdLine); - } - - if (cmd[0].equals("list") && cmd.length == 1) { - new List().listFunction(); - ifContinue(fromCmdLine); - } - - if (cmd[0].equals("remove") && cmd.length == 2) { - new Remove().removeFunction(cmd); - ifContinue(fromCmdLine); - } - - if (cmd[0].equals("drop") && cmd.length == 2) { - new Drop().dropFunction(cmd); - ifContinue(fromCmdLine); - } - - if (cmd[0].equals("rollback") && cmd.length == 1) { - new Rollback().rollbackFunction(); - ifContinue(fromCmdLine); - } - - if (cmd[0].equals("exit") && cmd.length == 1) { - if (fromCmdLine) { - currentTableObject.commit(); - new Exit().exitFunction(); - } else { - if (new Exit().exitAndUseAvailable()) { - new Exit().exitFunction(); - } - } - ifContinue(fromCmdLine); - } - if (cmd.length != 0) { - syntaxError(); - } - ifContinue(fromCmdLine); - } - - static void informToChooseTable() { - System.err.println("table is not chosen"); - } - - static void ifContinue(boolean fromCmdLine) throws Exception { - if (fromCmdLine) { - return; - } else { - getCmdFromStream(); - } - } - - static void printExceptionMessage(Exception e) { - System.err.println(e); - } - - static void syntaxError() { - System.err.println("incorrect syntax"); - } -} diff --git a/src/ru/fizteh/fivt/students/MaximGotovchits/Parallel/InterpreterPKG/List.java b/src/ru/fizteh/fivt/students/MaximGotovchits/Parallel/InterpreterPKG/List.java deleted file mode 100644 index 6da432cc8..000000000 --- a/src/ru/fizteh/fivt/students/MaximGotovchits/Parallel/InterpreterPKG/List.java +++ /dev/null @@ -1,11 +0,0 @@ -package ru.fizteh.fivt.students.MaximGotovchits.Parallel.InterpreterPKG; - -public class List { - void listFunction() { - if (Interpreter.tableIsChosen) { - Interpreter.currentTableObject.list(); - } else { - Interpreter.informToChooseTable(); - } - } -} diff --git a/src/ru/fizteh/fivt/students/MaximGotovchits/Parallel/InterpreterPKG/MakeDirs.java b/src/ru/fizteh/fivt/students/MaximGotovchits/Parallel/InterpreterPKG/MakeDirs.java deleted file mode 100644 index 5d1da06ab..000000000 --- a/src/ru/fizteh/fivt/students/MaximGotovchits/Parallel/InterpreterPKG/MakeDirs.java +++ /dev/null @@ -1,24 +0,0 @@ -package ru.fizteh.fivt.students.MaximGotovchits.Parallel.InterpreterPKG; - -import java.io.File; - -public class MakeDirs { - public void makeDirsFunction() throws Exception { - File file = new File(Interpreter.DATA_BASE_NAME); - if (!file.exists()) { - file.mkdirs(); - } else { - if (!file.isDirectory()) { - System.err.println(Interpreter.DATA_BASE_NAME + " is not a directory"); - System.exit(1); - } else { - for (File sub : file.listFiles()) { - if (!sub.isDirectory() && !sub.isHidden()) { - System.err.println(Interpreter.DATA_BASE_NAME + File.separator - + sub.getName() + " is not a directory"); - } - } - } - } - } -} diff --git a/src/ru/fizteh/fivt/students/MaximGotovchits/Parallel/InterpreterPKG/Put.java b/src/ru/fizteh/fivt/students/MaximGotovchits/Parallel/InterpreterPKG/Put.java deleted file mode 100644 index be47b08cf..000000000 --- a/src/ru/fizteh/fivt/students/MaximGotovchits/Parallel/InterpreterPKG/Put.java +++ /dev/null @@ -1,31 +0,0 @@ -package ru.fizteh.fivt.students.MaximGotovchits.Parallel.InterpreterPKG; - -import ru.fizteh.fivt.students.MaximGotovchits.Parallel.ObjectsPKG.ObjectStoreable; -import ru.fizteh.fivt.students.MaximGotovchits.Parallel.ObjectsPKG.ObjectTableProvider; - -public class Put { - void putFunction(String[] cmd, boolean fromCmdLine) { - if (Interpreter.tableIsChosen) { - String putParameter = new String(); - String key = cmd[1]; - for (int ind = 2; ind < cmd.length; ++ind) { - putParameter += cmd[ind] + " "; - } - putParameter = putParameter.substring(0, putParameter.length() - 1); - try { - ObjectStoreable value = (ObjectStoreable) new ObjectTableProvider(). - deserialize(Interpreter.currentTableObject, putParameter); - ObjectStoreable temp = (ObjectStoreable) Interpreter.currentTableObject.put(key, value); - if (temp == null) { - System.out.println("new"); - } else { - System.out.println("overwrite"); - } - } catch (Exception e) { - System.err.println(e); - } - } else { - Interpreter.informToChooseTable(); - } - } -} diff --git a/src/ru/fizteh/fivt/students/MaximGotovchits/Parallel/InterpreterPKG/Remove.java b/src/ru/fizteh/fivt/students/MaximGotovchits/Parallel/InterpreterPKG/Remove.java deleted file mode 100644 index 54c7c4071..000000000 --- a/src/ru/fizteh/fivt/students/MaximGotovchits/Parallel/InterpreterPKG/Remove.java +++ /dev/null @@ -1,22 +0,0 @@ -package ru.fizteh.fivt.students.MaximGotovchits.Parallel.InterpreterPKG; - -import ru.fizteh.fivt.students.MaximGotovchits.Parallel.ObjectsPKG.ObjectStoreable; - -public class Remove { - void removeFunction(String[] cmd) { - if (Interpreter.tableIsChosen) { - try { - ObjectStoreable temp = (ObjectStoreable) Interpreter.currentTableObject.remove(cmd[1]); - if (temp == null) { - System.out.println("not found"); - } else { - System.out.println("removed"); - } - } catch (Exception e) { - System.err.println(e); - } - } else { - Interpreter.informToChooseTable(); - } - } -} diff --git a/src/ru/fizteh/fivt/students/MaximGotovchits/Parallel/InterpreterPKG/Rollback.java b/src/ru/fizteh/fivt/students/MaximGotovchits/Parallel/InterpreterPKG/Rollback.java deleted file mode 100644 index 294c990bf..000000000 --- a/src/ru/fizteh/fivt/students/MaximGotovchits/Parallel/InterpreterPKG/Rollback.java +++ /dev/null @@ -1,7 +0,0 @@ -package ru.fizteh.fivt.students.MaximGotovchits.Parallel.InterpreterPKG; - -public class Rollback { - void rollbackFunction() { - Interpreter.currentTableObject.rollback(); - } -} diff --git a/src/ru/fizteh/fivt/students/MaximGotovchits/Parallel/InterpreterPKG/ShowTables.java b/src/ru/fizteh/fivt/students/MaximGotovchits/Parallel/InterpreterPKG/ShowTables.java deleted file mode 100644 index 0ab1a4740..000000000 --- a/src/ru/fizteh/fivt/students/MaximGotovchits/Parallel/InterpreterPKG/ShowTables.java +++ /dev/null @@ -1,9 +0,0 @@ -package ru.fizteh.fivt.students.MaximGotovchits.Parallel.InterpreterPKG; - -import ru.fizteh.fivt.students.MaximGotovchits.Parallel.ObjectsPKG.ObjectTableProvider; - -public class ShowTables { - void showTablesFunction() { - new ObjectTableProvider().getTableNames(); - } -} diff --git a/src/ru/fizteh/fivt/students/MaximGotovchits/Parallel/base/Main.java b/src/ru/fizteh/fivt/students/MaximGotovchits/Parallel/base/Main.java new file mode 100644 index 000000000..220ef7206 --- /dev/null +++ b/src/ru/fizteh/fivt/students/MaximGotovchits/Parallel/base/Main.java @@ -0,0 +1,51 @@ +package ru.fizteh.fivt.students.MaximGotovchits.Parallel.base; + +import ru.fizteh.fivt.students.MaximGotovchits.Parallel.base.commands.*; +import ru.fizteh.fivt.students.MaximGotovchits.Parallel.interpreter.Command; +import ru.fizteh.fivt.students.MaximGotovchits.Parallel.interpreter.Interpreter; +import ru.fizteh.fivt.students.MaximGotovchits.Parallel.objects.ObjectTable; +import java.util.HashSet; +import java.util.Set; + +public class Main { // Using JSON format. + public static void main(final String[] args) throws Exception { + new MakeDirs().execute(null); + Set commandSet = new HashSet<>(); + ObjectTable currentTableObject = null; + boolean fromCmdLine; + if (args.length == 0) { + fromCmdLine = false; + fillCommandSet(commandSet, currentTableObject, fromCmdLine); + Interpreter interpreter = new Interpreter(commandSet); + interpreter.startUp(null, false); + } else { + fromCmdLine = true; + fillCommandSet(commandSet, currentTableObject, fromCmdLine); + Interpreter interpreter = new Interpreter(commandSet); + String cmd = new String(); + for (String arg : args) { + cmd = cmd.join(" ", cmd, arg); + } + cmd = cmd.replaceAll("\\s+", " "); + System.out.println(cmd); + interpreter.startUp(cmd, fromCmdLine); + new Exit().execute(null); + } + } + + private static void fillCommandSet(Set commandSet, ObjectTable currentTableObject, boolean fromCmdLine) { + commandSet.add(new Commit()); + commandSet.add(new Create()); + commandSet.add(new Drop()); + commandSet.add(new Exit()); + commandSet.add(new FillTable()); + commandSet.add(new Get()); + commandSet.add(new List()); + commandSet.add(new MakeDirs()); + commandSet.add(new Put()); + commandSet.add(new Remove()); + commandSet.add(new Rollback()); + commandSet.add(new ShowTables()); + commandSet.add(new Use()); + } +} diff --git a/src/ru/fizteh/fivt/students/MaximGotovchits/Parallel/base/commands/CommadTools.java b/src/ru/fizteh/fivt/students/MaximGotovchits/Parallel/base/commands/CommadTools.java new file mode 100644 index 000000000..cbae30ea8 --- /dev/null +++ b/src/ru/fizteh/fivt/students/MaximGotovchits/Parallel/base/commands/CommadTools.java @@ -0,0 +1,19 @@ +package ru.fizteh.fivt.students.MaximGotovchits.Parallel.base.commands; + +import ru.fizteh.fivt.students.MaximGotovchits.Parallel.objects.ObjectTable; + +public class CommadTools { + static final String INVITATIONAL_SYMBOL = "$ "; + private static final String SPLIT_BY_COMMA = "\\s*;\\s*"; + protected static final String DATA_BASE_NAME = System.getProperty("fizteh.db.dir"); + static boolean tableIsChosen = false; + static final int DIR_NUM = 16; + static final int FILE_NUM = 16; + static final String DIR_EXT = ".dir"; + static final String FILE_EXT = ".dat"; + static String usingTableName; + static ObjectTable currentTable; + public static void informToChooseTable() { + System.err.println("table is not chosen"); + } +} diff --git a/src/ru/fizteh/fivt/students/MaximGotovchits/Parallel/base/commands/Commit.java b/src/ru/fizteh/fivt/students/MaximGotovchits/Parallel/base/commands/Commit.java new file mode 100644 index 000000000..69939f409 --- /dev/null +++ b/src/ru/fizteh/fivt/students/MaximGotovchits/Parallel/base/commands/Commit.java @@ -0,0 +1,20 @@ +package ru.fizteh.fivt.students.MaximGotovchits.Parallel.base.commands; + +import ru.fizteh.fivt.students.MaximGotovchits.Parallel.interpreter.Command; + +public class Commit extends Command { + public Commit() {} + @Override + public boolean execute(String[] cmd) { + if (cmd.length == 1) { + CommadTools.currentTable.commit(); + return true; + } + return false; + } + + @Override + public String getCmdName() { + return "commit"; + } +} diff --git a/src/ru/fizteh/fivt/students/MaximGotovchits/Parallel/base/commands/Create.java b/src/ru/fizteh/fivt/students/MaximGotovchits/Parallel/base/commands/Create.java new file mode 100644 index 000000000..01713d243 --- /dev/null +++ b/src/ru/fizteh/fivt/students/MaximGotovchits/Parallel/base/commands/Create.java @@ -0,0 +1,65 @@ +package ru.fizteh.fivt.students.MaximGotovchits.Parallel.base.commands; + +import ru.fizteh.fivt.students.MaximGotovchits.Parallel.interpreter.Command; +import ru.fizteh.fivt.students.MaximGotovchits.Parallel.objects.ObjectTable; +import ru.fizteh.fivt.students.MaximGotovchits.Parallel.objects.ObjectTableProvider; + +import java.io.IOException; +import java.util.LinkedList; +import java.util.List; + +import static java.util.Arrays.copyOfRange; + +public class Create extends Command { + private static final String SPLIT_BY_RIGHT_BRACKET = "\\s*\\)\\s*"; + private static final String SPLIT_BY_LEFT_BRACKET = "\\s*\\(\\s*"; + private static final String SPLIT_BY_SPACE = "\\s+"; + + @Override + public String getCmdName() { + return "create"; + } + + @Override + public boolean execute(String[] cmd) throws Exception { + if (cmd.length > 2) { + String createParameter = new String(); // (...) - type list. + String tableName = cmd[1]; + String[] qq = copyOfRange(cmd, 2, cmd.length); + for (int ind = 2; ind < cmd.length; ++ind) { + createParameter += cmd[ind] + " "; + } + createParameter = createParameter.substring(0, createParameter.length() - 1); + List> typeList = new LinkedList<>(); + try { + typeList = getTypeList(createParameter); + if (typeList != null) { + new ObjectTableProvider().createTable(tableName, typeList); + } else { + return false; + } + } catch (IOException e) { + System.err.println(e); + } + return true; + } + return false; + } + + public List> getTypeList(String line) throws Exception { + ObjectTable temp = new ObjectTable(); + List> typeList = new LinkedList>(); + line = line.replaceAll(SPLIT_BY_RIGHT_BRACKET, ""); + line = line.replaceAll(SPLIT_BY_LEFT_BRACKET, ""); + String[] tmp = line.split(SPLIT_BY_SPACE); + for (String str : tmp) { + Class type = temp.getType(str); + if (type != null) { + typeList.add(type); + } else { + return null; + } + } + return typeList; + } +} diff --git a/src/ru/fizteh/fivt/students/MaximGotovchits/Parallel/base/commands/Drop.java b/src/ru/fizteh/fivt/students/MaximGotovchits/Parallel/base/commands/Drop.java new file mode 100644 index 000000000..eb4502927 --- /dev/null +++ b/src/ru/fizteh/fivt/students/MaximGotovchits/Parallel/base/commands/Drop.java @@ -0,0 +1,24 @@ +package ru.fizteh.fivt.students.MaximGotovchits.Parallel.base.commands; + +import ru.fizteh.fivt.students.MaximGotovchits.Parallel.interpreter.Command; +import ru.fizteh.fivt.students.MaximGotovchits.Parallel.objects.ObjectTableProvider; + +public class Drop extends Command { + @Override + public boolean execute(String[] cmd) { + if (cmd.length == 2) { + try { + new ObjectTableProvider().removeTable(cmd[1]); + } catch (Exception e) { + System.err.println(e); + } + return true; + } + return false; + } + + @Override + public String getCmdName() { + return "drop"; + } +} diff --git a/src/ru/fizteh/fivt/students/MaximGotovchits/Parallel/base/commands/Exit.java b/src/ru/fizteh/fivt/students/MaximGotovchits/Parallel/base/commands/Exit.java new file mode 100644 index 000000000..c688eb9c5 --- /dev/null +++ b/src/ru/fizteh/fivt/students/MaximGotovchits/Parallel/base/commands/Exit.java @@ -0,0 +1,34 @@ +package ru.fizteh.fivt.students.MaximGotovchits.Parallel.base.commands; + +import ru.fizteh.fivt.students.MaximGotovchits.Parallel.interpreter.Command; + +public class Exit extends Command { + @Override + public boolean execute(String[] cmd) throws Exception { + if (CommadTools.currentTable != null) { + new FillTable().execute(null); + } + System.exit(0); + return true; + } + + public boolean exitAndUseAvailable() { + if (CommadTools.currentTable != null) { + int uncommitedChanges = CommadTools.currentTable.storage.get().size() + - CommadTools.currentTable.commitStorage.size(); + if (uncommitedChanges == 0 || !CommadTools.tableIsChosen) { + return true; + } + System.out.println(uncommitedChanges + " uncommited changes"); + return false; + } + return true; + } + + @Override + public String getCmdName() { + return "exit"; + } +} + + diff --git a/src/ru/fizteh/fivt/students/MaximGotovchits/Parallel/base/commands/FillTable.java b/src/ru/fizteh/fivt/students/MaximGotovchits/Parallel/base/commands/FillTable.java new file mode 100644 index 000000000..5584ef864 --- /dev/null +++ b/src/ru/fizteh/fivt/students/MaximGotovchits/Parallel/base/commands/FillTable.java @@ -0,0 +1,54 @@ +package ru.fizteh.fivt.students.MaximGotovchits.Parallel.base.commands; + +import ru.fizteh.fivt.students.MaximGotovchits.Parallel.interpreter.Command; +import ru.fizteh.fivt.students.MaximGotovchits.Parallel.objects.ObjectStoreable; +import java.io.DataOutputStream; +import java.io.File; +import java.io.FileOutputStream; +import java.nio.charset.Charset; +import java.nio.charset.StandardCharsets; +import java.nio.file.Path; +import java.nio.file.Paths; +import java.util.Map; + +public class FillTable extends Command { +private final Charset coding = StandardCharsets.UTF_8; + + @Override + public boolean execute(String[] cmd) throws Exception { + for (Map.Entry entry : CommadTools.currentTable.commitStorage.entrySet()) { + int hashCode = entry.getKey().hashCode(); + Integer nDirectory = hashCode % CommadTools.DIR_NUM; + Integer nFile = hashCode / CommadTools.DIR_NUM % CommadTools.FILE_NUM; + Path fileName = Paths.get(CommadTools.DATA_BASE_NAME, CommadTools.currentTable.getName(), nDirectory + + CommadTools.DIR_EXT); + File file = new File(fileName.toString()); + if (!file.exists()) { + file.mkdir(); + } + fileName = Paths.get(fileName.toString(), nFile + CommadTools.FILE_EXT); + file = new File(fileName.toString()); + if (!file.exists()) { + file.createNewFile(); + } + byte[] bytesKey = (" " + entry.getKey() + " ").getBytes(coding); + DataOutputStream stream = new DataOutputStream(new FileOutputStream(fileName.toString(), true)); + stream.write((int) bytesKey.length); + stream.write(bytesKey); + byte[] bytesVal = ((" " + entry.getValue().serialisedValue + " ").getBytes(coding)); + stream.write((int) bytesVal.length - 1); + stream.write(bytesVal); + stream.close(); + } + return true; + } + + @Override + public String getCmdName() { + return "fill table"; + } + + private void streamWrite() { + + } +} diff --git a/src/ru/fizteh/fivt/students/MaximGotovchits/Parallel/base/commands/Get.java b/src/ru/fizteh/fivt/students/MaximGotovchits/Parallel/base/commands/Get.java new file mode 100644 index 000000000..4aaba8204 --- /dev/null +++ b/src/ru/fizteh/fivt/students/MaximGotovchits/Parallel/base/commands/Get.java @@ -0,0 +1,33 @@ +package ru.fizteh.fivt.students.MaximGotovchits.Parallel.base.commands; + +import ru.fizteh.fivt.students.MaximGotovchits.Parallel.interpreter.Command; +import ru.fizteh.fivt.students.MaximGotovchits.Parallel.objects.ObjectStoreable; + +public class Get extends Command { + @Override + public boolean execute(String[] cmd) { + if (cmd.length == 2) { + try { + if (CommadTools.tableIsChosen) { + ObjectStoreable temp = (ObjectStoreable) CommadTools.currentTable.get(cmd[1]); + if (temp == null) { + System.err.println("not found"); + } else { + System.out.println("found"); + System.out.println(temp.serialisedValue); + } + } else { + CommadTools.informToChooseTable(); + } + } catch (Exception e) { + System.out.println(e); + } + return true; + } + return false; + } + @Override + public String getCmdName() { + return "get"; + } +} diff --git a/src/ru/fizteh/fivt/students/MaximGotovchits/Parallel/base/commands/List.java b/src/ru/fizteh/fivt/students/MaximGotovchits/Parallel/base/commands/List.java new file mode 100644 index 000000000..181557041 --- /dev/null +++ b/src/ru/fizteh/fivt/students/MaximGotovchits/Parallel/base/commands/List.java @@ -0,0 +1,23 @@ +package ru.fizteh.fivt.students.MaximGotovchits.Parallel.base.commands; + +import ru.fizteh.fivt.students.MaximGotovchits.Parallel.interpreter.Command; + +public class List extends Command { + @Override + public boolean execute(String[] cmd) { + if (cmd.length == 1) { + if (CommadTools.tableIsChosen) { + CommadTools.currentTable.list(); + } else { + CommadTools.informToChooseTable(); + } + return true; + } + return false; + } + + @Override + public String getCmdName() { + return "list"; + } +} diff --git a/src/ru/fizteh/fivt/students/MaximGotovchits/Parallel/base/commands/MakeDirs.java b/src/ru/fizteh/fivt/students/MaximGotovchits/Parallel/base/commands/MakeDirs.java new file mode 100644 index 000000000..1f6a603b4 --- /dev/null +++ b/src/ru/fizteh/fivt/students/MaximGotovchits/Parallel/base/commands/MakeDirs.java @@ -0,0 +1,33 @@ +package ru.fizteh.fivt.students.MaximGotovchits.Parallel.base.commands; + +import ru.fizteh.fivt.students.MaximGotovchits.Parallel.interpreter.Command; + +import java.io.File; + +public class MakeDirs extends Command { + @Override + public boolean execute(String[] cmd) throws Exception { + File file = new File(CommadTools.DATA_BASE_NAME); + if (!file.exists()) { + file.mkdirs(); + } else { + if (!file.isDirectory()) { + System.err.println(CommadTools.DATA_BASE_NAME + " is not a directory"); + System.exit(1); + } else { + for (File sub : file.listFiles()) { + if (!sub.isDirectory() && !sub.isHidden()) { + System.err.println(CommadTools.DATA_BASE_NAME + File.separator + + sub.getName() + " is not a directory"); + } + } + } + } + return true; + } + + @Override + public String getCmdName() { + return "make"; + } +} diff --git a/src/ru/fizteh/fivt/students/MaximGotovchits/Parallel/base/commands/Put.java b/src/ru/fizteh/fivt/students/MaximGotovchits/Parallel/base/commands/Put.java new file mode 100644 index 000000000..1fdc08ba4 --- /dev/null +++ b/src/ru/fizteh/fivt/students/MaximGotovchits/Parallel/base/commands/Put.java @@ -0,0 +1,41 @@ +package ru.fizteh.fivt.students.MaximGotovchits.Parallel.base.commands; + +import ru.fizteh.fivt.students.MaximGotovchits.Parallel.interpreter.Command; +import ru.fizteh.fivt.students.MaximGotovchits.Parallel.objects.ObjectStoreable; +import ru.fizteh.fivt.students.MaximGotovchits.Parallel.objects.ObjectTableProvider; + +public class Put extends Command { + public boolean execute(String[] cmd) { + if (cmd.length > 3) { + if (CommadTools.tableIsChosen) { + String putParameter = new String(); + String key = cmd[1]; + for (int ind = 2; ind < cmd.length; ++ind) { + putParameter += cmd[ind] + " "; + } + putParameter = putParameter.substring(0, putParameter.length() - 1); + try { + ObjectStoreable value = (ObjectStoreable) new ObjectTableProvider(). + deserialize(CommadTools.currentTable, putParameter); + ObjectStoreable temp = (ObjectStoreable) CommadTools.currentTable.put(key, value); + if (temp == null) { + System.out.println("new"); + } else { + System.out.println("overwrite"); + } + } catch (Exception e) { + System.err.println(e); + } + } else { + CommadTools.informToChooseTable(); + } + return true; + } + return false; + } + + @Override + public String getCmdName() { + return "put"; + } +} diff --git a/src/ru/fizteh/fivt/students/MaximGotovchits/Parallel/base/commands/Remove.java b/src/ru/fizteh/fivt/students/MaximGotovchits/Parallel/base/commands/Remove.java new file mode 100644 index 000000000..4a6408a6c --- /dev/null +++ b/src/ru/fizteh/fivt/students/MaximGotovchits/Parallel/base/commands/Remove.java @@ -0,0 +1,32 @@ +package ru.fizteh.fivt.students.MaximGotovchits.Parallel.base.commands; + +import ru.fizteh.fivt.students.MaximGotovchits.Parallel.interpreter.Command; +import ru.fizteh.fivt.students.MaximGotovchits.Parallel.objects.ObjectStoreable; + +public class Remove extends Command { + public boolean execute(String[] cmd) { + if (cmd.length == 2) { + if (CommadTools.tableIsChosen) { + try { + ObjectStoreable temp = (ObjectStoreable) CommadTools.currentTable.remove(cmd[1]); + if (temp == null) { + System.out.println("not found"); + } else { + System.out.println("removed"); + } + } catch (Exception e) { + System.err.println(e); + } + } else { + CommadTools.informToChooseTable(); + } + return true; + } + return false; + } + + @Override + public String getCmdName() { + return "remove"; + } +} diff --git a/src/ru/fizteh/fivt/students/MaximGotovchits/Parallel/base/commands/Rollback.java b/src/ru/fizteh/fivt/students/MaximGotovchits/Parallel/base/commands/Rollback.java new file mode 100644 index 000000000..64f16a845 --- /dev/null +++ b/src/ru/fizteh/fivt/students/MaximGotovchits/Parallel/base/commands/Rollback.java @@ -0,0 +1,19 @@ +package ru.fizteh.fivt.students.MaximGotovchits.Parallel.base.commands; + +import ru.fizteh.fivt.students.MaximGotovchits.Parallel.interpreter.Command; + +public class Rollback extends Command { + @Override + public boolean execute(String[] cmd) { + if (cmd.length == 1) { + CommadTools.currentTable.rollback(); + return true; + } + return false; + } + + @Override + public String getCmdName() { + return "rollback"; + } +} diff --git a/src/ru/fizteh/fivt/students/MaximGotovchits/Parallel/base/commands/ShowTables.java b/src/ru/fizteh/fivt/students/MaximGotovchits/Parallel/base/commands/ShowTables.java new file mode 100644 index 000000000..df907d768 --- /dev/null +++ b/src/ru/fizteh/fivt/students/MaximGotovchits/Parallel/base/commands/ShowTables.java @@ -0,0 +1,20 @@ +package ru.fizteh.fivt.students.MaximGotovchits.Parallel.base.commands; + +import ru.fizteh.fivt.students.MaximGotovchits.Parallel.interpreter.Command; +import ru.fizteh.fivt.students.MaximGotovchits.Parallel.objects.ObjectTableProvider; + +public class ShowTables extends Command { + @Override + public boolean execute(String[] cmd) { + if (cmd.length == 2) { + new ObjectTableProvider().getTableNames(); + return true; + } + return false; + } + + @Override + public String getCmdName() { + return "show"; + } +} diff --git a/src/ru/fizteh/fivt/students/MaximGotovchits/Parallel/InterpreterPKG/Use.java b/src/ru/fizteh/fivt/students/MaximGotovchits/Parallel/base/commands/Use.java similarity index 55% rename from src/ru/fizteh/fivt/students/MaximGotovchits/Parallel/InterpreterPKG/Use.java rename to src/ru/fizteh/fivt/students/MaximGotovchits/Parallel/base/commands/Use.java index 546fb7340..a7d68f6aa 100644 --- a/src/ru/fizteh/fivt/students/MaximGotovchits/Parallel/InterpreterPKG/Use.java +++ b/src/ru/fizteh/fivt/students/MaximGotovchits/Parallel/base/commands/Use.java @@ -1,31 +1,46 @@ -package ru.fizteh.fivt.students.MaximGotovchits.Parallel.InterpreterPKG; +package ru.fizteh.fivt.students.MaximGotovchits.Parallel.base.commands; -import ru.fizteh.fivt.students.MaximGotovchits.Parallel.ObjectsPKG.ObjectStoreable; -import ru.fizteh.fivt.students.MaximGotovchits.Parallel.ObjectsPKG.ObjectTable; -import ru.fizteh.fivt.students.MaximGotovchits.Parallel.ObjectsPKG.ObjectTableProvider; +import ru.fizteh.fivt.students.MaximGotovchits.Parallel.interpreter.Command; +import ru.fizteh.fivt.students.MaximGotovchits.Parallel.objects.ObjectStoreable; +import ru.fizteh.fivt.students.MaximGotovchits.Parallel.objects.ObjectTable; +import ru.fizteh.fivt.students.MaximGotovchits.Parallel.objects.ObjectTableProvider; import java.io.*; import java.nio.charset.StandardCharsets; import java.text.ParseException; -public class Use { +public class Use extends Command { + @Override + public String getCmdName() { + return "use"; + } + + @Override + public boolean execute(String[] cmd) throws Exception { + if (cmd.length == 2) { + useFunction(cmd[1], CommadTools.usingTableName); + return true; + } + return false; + } + public boolean useFunction(String tableName, String oldTableName) throws Exception { if (!tableName.equals(oldTableName)) { String outputName = tableName; - String tablePath = Interpreter.DATA_BASE_NAME + File.separator + tableName; + String tablePath = CommadTools.DATA_BASE_NAME + File.separator + tableName; File file = new File(tablePath); if (file.exists()) { - Interpreter.usingTableName = tableName; - if (Interpreter.tableIsChosen) { - new FillTable().fillTableFunction(Interpreter.currentTableObject); - Interpreter.currentTableObject.storage.get().clear(); - Interpreter.currentTableObject.commitStorage.clear(); + CommadTools.usingTableName = tableName; + if (CommadTools.tableIsChosen) { + new FillTable().execute(null); + CommadTools.currentTable.storage.get().clear(); + CommadTools.currentTable.commitStorage.clear(); } - Interpreter.currentTableObject = new ObjectTable(Interpreter.DATA_BASE_NAME + File.separator - + Interpreter.usingTableName); - for (Integer i = 0; i < Interpreter.dirNum; ++i) { - for (Integer j = 0; j < Interpreter.fileNum; ++j) { - tablePath = Interpreter.DATA_BASE_NAME + File.separator + tableName + File.separator - + i + Interpreter.dirExt + File.separator + j + Interpreter.fileExt; + CommadTools.currentTable = new ObjectTable(CommadTools.DATA_BASE_NAME + File.separator + + CommadTools.usingTableName); + for (Integer i = 0; i < CommadTools.DIR_NUM; ++i) { + for (Integer j = 0; j < CommadTools.FILE_NUM; ++j) { + tablePath = CommadTools.DATA_BASE_NAME + File.separator + tableName + File.separator + + i + CommadTools.DIR_EXT + File.separator + j + CommadTools.FILE_EXT; if (new File(tablePath).exists()) { fillStorage(tablePath, file); PrintWriter writer = new PrintWriter(new File(tablePath)); @@ -35,7 +50,7 @@ public boolean useFunction(String tableName, String oldTableName) throws Excepti } } System.out.println("using " + outputName); - Interpreter.tableIsChosen = true; + CommadTools.tableIsChosen = true; } else { System.err.println(tableName + " not exists"); return false; @@ -43,7 +58,7 @@ public boolean useFunction(String tableName, String oldTableName) throws Excepti } else { System.out.println("using " + oldTableName); } - Interpreter.usingTableName = Interpreter.currentTableObject.getName(); + CommadTools.usingTableName = CommadTools.currentTable.getName(); return true; } @@ -67,8 +82,8 @@ void fillStorage(String datName, File file) throws IOException, ParseException { String tableName = new File(new File(datName).getParent()).getParent(); ObjectStoreable valForMap = (ObjectStoreable) new ObjectTableProvider().deserialize(new ObjectTable(tableName), value); - Interpreter.currentTableObject.storage.get().put(keyForMap, valForMap); - Interpreter.currentTableObject.commitStorage.put(keyForMap, valForMap); + CommadTools.currentTable.storage.get().put(keyForMap, valForMap); + CommadTools.currentTable.commitStorage.put(keyForMap, valForMap); counter = counter + offset + 3; } stream.close(); diff --git a/src/ru/fizteh/fivt/students/MaximGotovchits/Parallel/interpreter/Command.java b/src/ru/fizteh/fivt/students/MaximGotovchits/Parallel/interpreter/Command.java new file mode 100644 index 000000000..990d18890 --- /dev/null +++ b/src/ru/fizteh/fivt/students/MaximGotovchits/Parallel/interpreter/Command.java @@ -0,0 +1,9 @@ +package ru.fizteh.fivt.students.MaximGotovchits.Parallel.interpreter; + +import ru.fizteh.fivt.students.MaximGotovchits.Parallel.base.commands.*; + +public abstract class Command { + public abstract String getCmdName(); + + public abstract boolean execute(String[] cmd) throws Exception; +} diff --git a/src/ru/fizteh/fivt/students/MaximGotovchits/Parallel/interpreter/Interpreter.java b/src/ru/fizteh/fivt/students/MaximGotovchits/Parallel/interpreter/Interpreter.java new file mode 100644 index 000000000..d1a792342 --- /dev/null +++ b/src/ru/fizteh/fivt/students/MaximGotovchits/Parallel/interpreter/Interpreter.java @@ -0,0 +1,61 @@ +package ru.fizteh.fivt.students.MaximGotovchits.Parallel.interpreter; + +import ru.fizteh.fivt.students.MaximGotovchits.Parallel.base.commands.*; +import java.util.*; + +public class Interpreter { + private static final String SPLIT_BY_SEMICOLON = "\\s*;\\s*"; + private static final String INVITATIONAL_SYMBOL = "$ "; + private static final String SPLIT_BY_SPACE = "\\s+"; + private Map commands = new HashMap<>(); + + public Interpreter(Set commandSet) { + for (Command cmd: commandSet) { + commands.put(cmd.getCmdName(), cmd); + } + } + + public void startUp(String cmdLine, boolean isFromCmdLine) throws Exception { + boolean correctCmdName = false; + if (isFromCmdLine) { // Batch mode. + String[] splittedLine = cmdLine.split(SPLIT_BY_SEMICOLON); + for (String line : splittedLine) { + String[] cmd = line.split(SPLIT_BY_SPACE); + parseStep(commands, cmd, isFromCmdLine); + } + } else { // Interactive mode. + while (true) { + Scanner scan = new Scanner(System.in); + System.out.print(INVITATIONAL_SYMBOL); + String[] cmd = scan.nextLine().split(SPLIT_BY_SPACE); + parseStep(commands, cmd, isFromCmdLine); + } + + } + } + + private void parseStep(Map commands, String[] cmd, boolean isFromCmdLine) throws Exception { + boolean correctCmdName = false; + for (Map.Entry entry : commands.entrySet()) { + String key = entry.getKey(); + if (key.equals(cmd[0])) { + correctCmdName = true; + Command currentCmd = entry.getValue(); + currentCmd.execute(cmd); + break; + } + } + if (!correctCmdName) { + if (isFromCmdLine) { + System.err.println("no such command, try again..."); + } else { + String[] exit = new String[1]; + exit[0] = "exit"; + new Exit().execute(exit); + } + } + correctCmdName = false; + } + + //Interpreter(cmd, fromCmdLine); +} diff --git a/src/ru/fizteh/fivt/students/MaximGotovchits/Parallel/ObjectsPKG/ObjectStoreable.java b/src/ru/fizteh/fivt/students/MaximGotovchits/Parallel/objects/ObjectStoreable.java similarity index 95% rename from src/ru/fizteh/fivt/students/MaximGotovchits/Parallel/ObjectsPKG/ObjectStoreable.java rename to src/ru/fizteh/fivt/students/MaximGotovchits/Parallel/objects/ObjectStoreable.java index 1283da515..256032d55 100644 --- a/src/ru/fizteh/fivt/students/MaximGotovchits/Parallel/ObjectsPKG/ObjectStoreable.java +++ b/src/ru/fizteh/fivt/students/MaximGotovchits/Parallel/objects/ObjectStoreable.java @@ -1,4 +1,4 @@ -package ru.fizteh.fivt.students.MaximGotovchits.Parallel.ObjectsPKG; +package ru.fizteh.fivt.students.MaximGotovchits.Parallel.objects; import ru.fizteh.fivt.storage.structured.ColumnFormatException; import ru.fizteh.fivt.storage.structured.Storeable; @@ -10,30 +10,29 @@ public class ObjectStoreable implements Storeable { private static final String LEFT_BRACE = "["; private static final String RIGHT_BRACE = "]"; - private static final String COMMA_AND_SPACE = ", "; + private static final String VALUE_SEPARATOR = ", "; public List subValueList = new LinkedList<>(); private static ObjectTable currentTableObject; - public String serialisedValue = new String(); + public String serialisedValue; public List> typeKeeper = new LinkedList<>(); public ObjectStoreable() {} public ObjectStoreable(List values) { - int ind = 0; serialisedValue = LEFT_BRACE; for (Object val : values) { subValueList.add(val); - serialisedValue += val + COMMA_AND_SPACE; + serialisedValue += val + VALUE_SEPARATOR; } serialisedValue = serialisedValue.substring(0, serialisedValue.length() - 2); serialisedValue += RIGHT_BRACE; } - public ObjectStoreable(Storeable value) { + /*public ObjectStoreable(Storeable value) { subValueList = ((ObjectStoreable) value).subValueList; serialisedValue = ((ObjectStoreable) value).serialisedValue; typeKeeper = ((ObjectStoreable) value).typeKeeper; - } + }*/ public ObjectStoreable(ObjectTable table) { typeKeeper = table.typeKeeper; @@ -88,11 +87,10 @@ public void setColumnAt(int columnIndex, Object value) throws ColumnFormatExcept this.serialisedValue = ""; serialisedValue = LEFT_BRACE; for (Object val : this.subValueList) { - serialisedValue += val + COMMA_AND_SPACE; + serialisedValue += val + VALUE_SEPARATOR; } - serialisedValue = serialisedValue.substring(0, serialisedValue.length() - 2); // Откусить ", ". + serialisedValue = serialisedValue.substring(0, serialisedValue.length() - 2); serialisedValue += RIGHT_BRACE; - return; } @Override diff --git a/src/ru/fizteh/fivt/students/MaximGotovchits/Parallel/ObjectsPKG/ObjectTable.java b/src/ru/fizteh/fivt/students/MaximGotovchits/Parallel/objects/ObjectTable.java similarity index 98% rename from src/ru/fizteh/fivt/students/MaximGotovchits/Parallel/ObjectsPKG/ObjectTable.java rename to src/ru/fizteh/fivt/students/MaximGotovchits/Parallel/objects/ObjectTable.java index 9c079a3f7..e20490476 100644 --- a/src/ru/fizteh/fivt/students/MaximGotovchits/Parallel/ObjectsPKG/ObjectTable.java +++ b/src/ru/fizteh/fivt/students/MaximGotovchits/Parallel/objects/ObjectTable.java @@ -1,4 +1,4 @@ -package ru.fizteh.fivt.students.MaximGotovchits.Parallel.ObjectsPKG; +package ru.fizteh.fivt.students.MaximGotovchits.Parallel.objects; import ru.fizteh.fivt.storage.structured.ColumnFormatException; import ru.fizteh.fivt.storage.structured.Storeable; @@ -37,6 +37,8 @@ protected HashMap initialValue() { public String tableName = new String(); public List> typeKeeper = new LinkedList>(); + public ObjectTable() { } + public ObjectTable(Table table) { ObjectTable temp = (ObjectTable) table; this.tableName = temp.tableName; @@ -220,9 +222,7 @@ static String readFile(String path, Charset encoding) throws IOException { return temp.replaceAll("^\\s*|\\s*$", ""); } - - - private Class getType(String typeName) { + public Class getType(String typeName) { if (typeName.equals("int")) { return int.class; } diff --git a/src/ru/fizteh/fivt/students/MaximGotovchits/Parallel/ObjectsPKG/ObjectTableProvider.java b/src/ru/fizteh/fivt/students/MaximGotovchits/Parallel/objects/ObjectTableProvider.java similarity index 99% rename from src/ru/fizteh/fivt/students/MaximGotovchits/Parallel/ObjectsPKG/ObjectTableProvider.java rename to src/ru/fizteh/fivt/students/MaximGotovchits/Parallel/objects/ObjectTableProvider.java index 2fa504c46..57c831d5f 100644 --- a/src/ru/fizteh/fivt/students/MaximGotovchits/Parallel/ObjectsPKG/ObjectTableProvider.java +++ b/src/ru/fizteh/fivt/students/MaximGotovchits/Parallel/objects/ObjectTableProvider.java @@ -1,4 +1,4 @@ -package ru.fizteh.fivt.students.MaximGotovchits.Parallel.ObjectsPKG; +package ru.fizteh.fivt.students.MaximGotovchits.Parallel.objects; import ru.fizteh.fivt.storage.structured.ColumnFormatException; import ru.fizteh.fivt.storage.structured.Storeable; diff --git a/src/ru/fizteh/fivt/students/MaximGotovchits/Parallel/ObjectsPKG/ObjectTableProviderFactory.java b/src/ru/fizteh/fivt/students/MaximGotovchits/Parallel/objects/ObjectTableProviderFactory.java similarity index 90% rename from src/ru/fizteh/fivt/students/MaximGotovchits/Parallel/ObjectsPKG/ObjectTableProviderFactory.java rename to src/ru/fizteh/fivt/students/MaximGotovchits/Parallel/objects/ObjectTableProviderFactory.java index 76ceaac37..9bcc77941 100644 --- a/src/ru/fizteh/fivt/students/MaximGotovchits/Parallel/ObjectsPKG/ObjectTableProviderFactory.java +++ b/src/ru/fizteh/fivt/students/MaximGotovchits/Parallel/objects/ObjectTableProviderFactory.java @@ -1,4 +1,4 @@ -package ru.fizteh.fivt.students.MaximGotovchits.Parallel.ObjectsPKG; +package ru.fizteh.fivt.students.MaximGotovchits.Parallel.objects; import ru.fizteh.fivt.storage.structured.TableProvider; import ru.fizteh.fivt.storage.structured.TableProviderFactory; diff --git a/src/ru/fizteh/fivt/students/MaximGotovchits/Parallel/TestPKG/ObjectStoreableTest.java b/src/ru/fizteh/fivt/students/MaximGotovchits/Parallel/test/ObjectStoreableTest.java similarity index 92% rename from src/ru/fizteh/fivt/students/MaximGotovchits/Parallel/TestPKG/ObjectStoreableTest.java rename to src/ru/fizteh/fivt/students/MaximGotovchits/Parallel/test/ObjectStoreableTest.java index a9227f715..2423765f3 100644 --- a/src/ru/fizteh/fivt/students/MaximGotovchits/Parallel/TestPKG/ObjectStoreableTest.java +++ b/src/ru/fizteh/fivt/students/MaximGotovchits/Parallel/test/ObjectStoreableTest.java @@ -1,11 +1,11 @@ -package ru.fizteh.fivt.students.MaximGotovchits.Parallel.TestPKG; +package ru.fizteh.fivt.students.MaximGotovchits.Parallel.test; import org.junit.After; import org.junit.Before; import org.junit.Test; -import ru.fizteh.fivt.students.MaximGotovchits.Parallel.ObjectsPKG.ObjectStoreable; -import ru.fizteh.fivt.students.MaximGotovchits.Parallel.ObjectsPKG.ObjectTable; -import ru.fizteh.fivt.students.MaximGotovchits.Parallel.ObjectsPKG.ObjectTableProvider; +import ru.fizteh.fivt.students.MaximGotovchits.Parallel.objects.ObjectStoreable; +import ru.fizteh.fivt.students.MaximGotovchits.Parallel.objects.ObjectTable; +import ru.fizteh.fivt.students.MaximGotovchits.Parallel.objects.ObjectTableProvider; import java.io.IOException; import java.util.LinkedList; import java.util.List; diff --git a/src/ru/fizteh/fivt/students/MaximGotovchits/Parallel/TestPKG/ObjectTableProviderFactoryTest.java b/src/ru/fizteh/fivt/students/MaximGotovchits/Parallel/test/ObjectTableProviderFactoryTest.java similarity index 64% rename from src/ru/fizteh/fivt/students/MaximGotovchits/Parallel/TestPKG/ObjectTableProviderFactoryTest.java rename to src/ru/fizteh/fivt/students/MaximGotovchits/Parallel/test/ObjectTableProviderFactoryTest.java index b9349180e..f1eadff0a 100644 --- a/src/ru/fizteh/fivt/students/MaximGotovchits/Parallel/TestPKG/ObjectTableProviderFactoryTest.java +++ b/src/ru/fizteh/fivt/students/MaximGotovchits/Parallel/test/ObjectTableProviderFactoryTest.java @@ -1,8 +1,8 @@ -package ru.fizteh.fivt.students.MaximGotovchits.Parallel.TestPKG; +package ru.fizteh.fivt.students.MaximGotovchits.Parallel.test; import org.junit.Test; -import ru.fizteh.fivt.students.MaximGotovchits.Parallel.ObjectsPKG.ObjectTableProvider; -import ru.fizteh.fivt.students.MaximGotovchits.Parallel.ObjectsPKG.ObjectTableProviderFactory; +import ru.fizteh.fivt.students.MaximGotovchits.Parallel.objects.ObjectTableProvider; +import ru.fizteh.fivt.students.MaximGotovchits.Parallel.objects.ObjectTableProviderFactory; import static org.junit.Assert.assertEquals; public class ObjectTableProviderFactoryTest { diff --git a/src/ru/fizteh/fivt/students/MaximGotovchits/Parallel/TestPKG/ObjectTableProviderTest.java b/src/ru/fizteh/fivt/students/MaximGotovchits/Parallel/test/ObjectTableProviderTest.java similarity index 87% rename from src/ru/fizteh/fivt/students/MaximGotovchits/Parallel/TestPKG/ObjectTableProviderTest.java rename to src/ru/fizteh/fivt/students/MaximGotovchits/Parallel/test/ObjectTableProviderTest.java index 248b35bd5..3cf6ff761 100644 --- a/src/ru/fizteh/fivt/students/MaximGotovchits/Parallel/TestPKG/ObjectTableProviderTest.java +++ b/src/ru/fizteh/fivt/students/MaximGotovchits/Parallel/test/ObjectTableProviderTest.java @@ -1,10 +1,10 @@ -package ru.fizteh.fivt.students.MaximGotovchits.Parallel.TestPKG; +package ru.fizteh.fivt.students.MaximGotovchits.Parallel.test; import static org.junit.Assert.assertEquals; import org.junit.*; -import ru.fizteh.fivt.students.MaximGotovchits.Parallel.ObjectsPKG.ObjectStoreable; -import ru.fizteh.fivt.students.MaximGotovchits.Parallel.ObjectsPKG.ObjectTable; -import ru.fizteh.fivt.students.MaximGotovchits.Parallel.ObjectsPKG.ObjectTableProvider; +import ru.fizteh.fivt.students.MaximGotovchits.Parallel.objects.ObjectStoreable; +import ru.fizteh.fivt.students.MaximGotovchits.Parallel.objects.ObjectTable; +import ru.fizteh.fivt.students.MaximGotovchits.Parallel.objects.ObjectTableProvider; import java.io.IOException; import java.util.LinkedList; import java.util.List; @@ -41,20 +41,20 @@ public void createAndGetTableTest() throws IOException { assertEquals(null, createTable(name, columnTypes)); assertEquals(testTable, getTable(name)); } - // @TestPKG + // @test // public void deserializeTest() throws ParseException, IOException { // assertEquals(deserializedValue, (ObjectStoreable) deserialize(table, valueToDeserialize)); // } - /*@TestPKG(expected = IllegalArgumentException.class) // Это была попытка сделать тест на исключения. + /*@test(expected = IllegalArgumentException.class) // Это была попытка сделать тест на исключения. //В следующей задаче я постараюсь это сделать. Просто нужно изменять кучу кода. public void createNullTableTest() throws IOException { createTable(null, columnTypes); }*/ - /*@TestPKG + /*@test public void serializeTest() { assertEquals(valueToDeserialize, serialize(table, deserializedValue)); } - @TestPKG + @test public void createForTest() { ObjectStoreable tempStoreable = new ObjectStoreable(); tempStoreable.typeKeeper = table.typeKeeper; @@ -64,7 +64,7 @@ public void createForTest() { ObjectStoreable qq = (ObjectStoreable) createFor(table, deserializedValue.subValueList); assertEquals(tempStoreable, (ObjectStoreable) createFor(table, deserializedValue.subValueList)); } - @TestPKG + @test public void getTableNamesTest() throws IOException { // Конечно же, стоит удостовериться, // что в рабочей директории на момент тестирования нет таблиц. List toCompare = new LinkedList(); diff --git a/src/ru/fizteh/fivt/students/MaximGotovchits/Parallel/TestPKG/ObjectTableTest.java b/src/ru/fizteh/fivt/students/MaximGotovchits/Parallel/test/ObjectTableTest.java similarity index 92% rename from src/ru/fizteh/fivt/students/MaximGotovchits/Parallel/TestPKG/ObjectTableTest.java rename to src/ru/fizteh/fivt/students/MaximGotovchits/Parallel/test/ObjectTableTest.java index b090f751a..845deab1f 100644 --- a/src/ru/fizteh/fivt/students/MaximGotovchits/Parallel/TestPKG/ObjectTableTest.java +++ b/src/ru/fizteh/fivt/students/MaximGotovchits/Parallel/test/ObjectTableTest.java @@ -1,14 +1,14 @@ -package ru.fizteh.fivt.students.MaximGotovchits.Parallel.TestPKG; +package ru.fizteh.fivt.students.MaximGotovchits.Parallel.test; import static junit.framework.Assert.assertNull; import static org.junit.Assert.assertEquals; import static org.junit.Assert.assertTrue; import org.junit.*; import org.junit.Test; -import ru.fizteh.fivt.students.MaximGotovchits.Parallel.InterpreterPKG.Use; -import ru.fizteh.fivt.students.MaximGotovchits.Parallel.ObjectsPKG.ObjectStoreable; -import ru.fizteh.fivt.students.MaximGotovchits.Parallel.ObjectsPKG.ObjectTable; -import ru.fizteh.fivt.students.MaximGotovchits.Parallel.ObjectsPKG.ObjectTableProvider; +import ru.fizteh.fivt.students.MaximGotovchits.Parallel.base.commands.Use; +import ru.fizteh.fivt.students.MaximGotovchits.Parallel.objects.ObjectStoreable; +import ru.fizteh.fivt.students.MaximGotovchits.Parallel.objects.ObjectTable; +import ru.fizteh.fivt.students.MaximGotovchits.Parallel.objects.ObjectTableProvider; import java.io.IOException; import java.util.LinkedList; From df9e427f23f46e9d4091c352f8eea1c7b85b01d9 Mon Sep 17 00:00:00 2001 From: MaximGotovchits Date: Wed, 18 Mar 2015 21:30:19 +0300 Subject: [PATCH 14/18] =?UTF-8?q?=D0=9C=D0=B0=D0=BA=D1=81=D0=B8=D0=BC=20?= =?UTF-8?q?=D0=93=D0=BE=D1=82=D0=BE=D0=B2=D1=87=D0=B8=D1=86,=20Parallel,?= =?UTF-8?q?=20396?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit fixed --- .../{CommadTools.java => CommandTools.java} | 2 +- .../Parallel/base/commands/Commit.java | 2 +- .../Parallel/base/commands/Create.java | 11 +- .../Parallel/base/commands/Drop.java | 1 + .../Parallel/base/commands/Exit.java | 10 +- .../Parallel/base/commands/FillTable.java | 12 +- .../Parallel/base/commands/Get.java | 6 +- .../Parallel/base/commands/List.java | 18 +- .../Parallel/base/commands/MakeDirs.java | 6 +- .../Parallel/base/commands/Put.java | 9 +- .../Parallel/base/commands/Remove.java | 6 +- .../Parallel/base/commands/Rollback.java | 2 +- .../Parallel/base/commands/ShowTables.java | 41 ++++- .../Parallel/base/commands/Use.java | 32 ++-- .../Parallel/interpreter/Interpreter.java | 4 +- .../Parallel/objects/ObjectStoreable.java | 126 ++++--------- .../Parallel/objects/ObjectTable.java | 12 -- .../Parallel/objects/ObjectTableProvider.java | 165 +++++++----------- .../objects/ObjectTableProviderFactory.java | 9 +- .../Parallel/test/ObjectStoreableTest.java | 17 +- .../test/ObjectTableProviderTest.java | 70 ++++---- .../Parallel/test/ObjectTableTest.java | 48 +++-- 22 files changed, 296 insertions(+), 313 deletions(-) rename src/ru/fizteh/fivt/students/MaximGotovchits/Parallel/base/commands/{CommadTools.java => CommandTools.java} (96%) diff --git a/src/ru/fizteh/fivt/students/MaximGotovchits/Parallel/base/commands/CommadTools.java b/src/ru/fizteh/fivt/students/MaximGotovchits/Parallel/base/commands/CommandTools.java similarity index 96% rename from src/ru/fizteh/fivt/students/MaximGotovchits/Parallel/base/commands/CommadTools.java rename to src/ru/fizteh/fivt/students/MaximGotovchits/Parallel/base/commands/CommandTools.java index cbae30ea8..3562eb55c 100644 --- a/src/ru/fizteh/fivt/students/MaximGotovchits/Parallel/base/commands/CommadTools.java +++ b/src/ru/fizteh/fivt/students/MaximGotovchits/Parallel/base/commands/CommandTools.java @@ -2,7 +2,7 @@ import ru.fizteh.fivt.students.MaximGotovchits.Parallel.objects.ObjectTable; -public class CommadTools { +public class CommandTools { static final String INVITATIONAL_SYMBOL = "$ "; private static final String SPLIT_BY_COMMA = "\\s*;\\s*"; protected static final String DATA_BASE_NAME = System.getProperty("fizteh.db.dir"); diff --git a/src/ru/fizteh/fivt/students/MaximGotovchits/Parallel/base/commands/Commit.java b/src/ru/fizteh/fivt/students/MaximGotovchits/Parallel/base/commands/Commit.java index 69939f409..b9488a1aa 100644 --- a/src/ru/fizteh/fivt/students/MaximGotovchits/Parallel/base/commands/Commit.java +++ b/src/ru/fizteh/fivt/students/MaximGotovchits/Parallel/base/commands/Commit.java @@ -7,7 +7,7 @@ public Commit() {} @Override public boolean execute(String[] cmd) { if (cmd.length == 1) { - CommadTools.currentTable.commit(); + CommandTools.currentTable.commit(); return true; } return false; diff --git a/src/ru/fizteh/fivt/students/MaximGotovchits/Parallel/base/commands/Create.java b/src/ru/fizteh/fivt/students/MaximGotovchits/Parallel/base/commands/Create.java index 01713d243..30a386b87 100644 --- a/src/ru/fizteh/fivt/students/MaximGotovchits/Parallel/base/commands/Create.java +++ b/src/ru/fizteh/fivt/students/MaximGotovchits/Parallel/base/commands/Create.java @@ -8,7 +8,7 @@ import java.util.LinkedList; import java.util.List; -import static java.util.Arrays.copyOfRange; +//import static java.util.Arrays.copyOfRange; public class Create extends Command { private static final String SPLIT_BY_RIGHT_BRACKET = "\\s*\\)\\s*"; @@ -25,16 +25,19 @@ public boolean execute(String[] cmd) throws Exception { if (cmd.length > 2) { String createParameter = new String(); // (...) - type list. String tableName = cmd[1]; - String[] qq = copyOfRange(cmd, 2, cmd.length); for (int ind = 2; ind < cmd.length; ++ind) { createParameter += cmd[ind] + " "; } createParameter = createParameter.substring(0, createParameter.length() - 1); - List> typeList = new LinkedList<>(); + List> typeList; try { typeList = getTypeList(createParameter); if (typeList != null) { - new ObjectTableProvider().createTable(tableName, typeList); + if (new ObjectTableProvider().createTable(tableName, typeList) != null) { + System.out.println("created"); + } else { + System.out.println(tableName + " exists"); + } } else { return false; } diff --git a/src/ru/fizteh/fivt/students/MaximGotovchits/Parallel/base/commands/Drop.java b/src/ru/fizteh/fivt/students/MaximGotovchits/Parallel/base/commands/Drop.java index eb4502927..41f73de0d 100644 --- a/src/ru/fizteh/fivt/students/MaximGotovchits/Parallel/base/commands/Drop.java +++ b/src/ru/fizteh/fivt/students/MaximGotovchits/Parallel/base/commands/Drop.java @@ -9,6 +9,7 @@ public boolean execute(String[] cmd) { if (cmd.length == 2) { try { new ObjectTableProvider().removeTable(cmd[1]); + System.out.println("dropped"); } catch (Exception e) { System.err.println(e); } diff --git a/src/ru/fizteh/fivt/students/MaximGotovchits/Parallel/base/commands/Exit.java b/src/ru/fizteh/fivt/students/MaximGotovchits/Parallel/base/commands/Exit.java index c688eb9c5..ea0b46d93 100644 --- a/src/ru/fizteh/fivt/students/MaximGotovchits/Parallel/base/commands/Exit.java +++ b/src/ru/fizteh/fivt/students/MaximGotovchits/Parallel/base/commands/Exit.java @@ -5,7 +5,7 @@ public class Exit extends Command { @Override public boolean execute(String[] cmd) throws Exception { - if (CommadTools.currentTable != null) { + if (CommandTools.currentTable != null) { new FillTable().execute(null); } System.exit(0); @@ -13,10 +13,10 @@ public boolean execute(String[] cmd) throws Exception { } public boolean exitAndUseAvailable() { - if (CommadTools.currentTable != null) { - int uncommitedChanges = CommadTools.currentTable.storage.get().size() - - CommadTools.currentTable.commitStorage.size(); - if (uncommitedChanges == 0 || !CommadTools.tableIsChosen) { + if (CommandTools.currentTable != null) { + int uncommitedChanges = CommandTools.currentTable.storage.get().size() + - CommandTools.currentTable.commitStorage.size(); + if (uncommitedChanges == 0 || !CommandTools.tableIsChosen) { return true; } System.out.println(uncommitedChanges + " uncommited changes"); diff --git a/src/ru/fizteh/fivt/students/MaximGotovchits/Parallel/base/commands/FillTable.java b/src/ru/fizteh/fivt/students/MaximGotovchits/Parallel/base/commands/FillTable.java index 5584ef864..4c65ded0c 100644 --- a/src/ru/fizteh/fivt/students/MaximGotovchits/Parallel/base/commands/FillTable.java +++ b/src/ru/fizteh/fivt/students/MaximGotovchits/Parallel/base/commands/FillTable.java @@ -16,17 +16,17 @@ public class FillTable extends Command { @Override public boolean execute(String[] cmd) throws Exception { - for (Map.Entry entry : CommadTools.currentTable.commitStorage.entrySet()) { + for (Map.Entry entry : CommandTools.currentTable.commitStorage.entrySet()) { int hashCode = entry.getKey().hashCode(); - Integer nDirectory = hashCode % CommadTools.DIR_NUM; - Integer nFile = hashCode / CommadTools.DIR_NUM % CommadTools.FILE_NUM; - Path fileName = Paths.get(CommadTools.DATA_BASE_NAME, CommadTools.currentTable.getName(), nDirectory - + CommadTools.DIR_EXT); + Integer nDirectory = hashCode % CommandTools.DIR_NUM; + Integer nFile = hashCode / CommandTools.DIR_NUM % CommandTools.FILE_NUM; + Path fileName = Paths.get(CommandTools.DATA_BASE_NAME, CommandTools.currentTable.getName(), nDirectory + + CommandTools.DIR_EXT); File file = new File(fileName.toString()); if (!file.exists()) { file.mkdir(); } - fileName = Paths.get(fileName.toString(), nFile + CommadTools.FILE_EXT); + fileName = Paths.get(fileName.toString(), nFile + CommandTools.FILE_EXT); file = new File(fileName.toString()); if (!file.exists()) { file.createNewFile(); diff --git a/src/ru/fizteh/fivt/students/MaximGotovchits/Parallel/base/commands/Get.java b/src/ru/fizteh/fivt/students/MaximGotovchits/Parallel/base/commands/Get.java index 4aaba8204..be9875443 100644 --- a/src/ru/fizteh/fivt/students/MaximGotovchits/Parallel/base/commands/Get.java +++ b/src/ru/fizteh/fivt/students/MaximGotovchits/Parallel/base/commands/Get.java @@ -8,8 +8,8 @@ public class Get extends Command { public boolean execute(String[] cmd) { if (cmd.length == 2) { try { - if (CommadTools.tableIsChosen) { - ObjectStoreable temp = (ObjectStoreable) CommadTools.currentTable.get(cmd[1]); + if (CommandTools.tableIsChosen) { + ObjectStoreable temp = (ObjectStoreable) CommandTools.currentTable.get(cmd[1]); if (temp == null) { System.err.println("not found"); } else { @@ -17,7 +17,7 @@ public boolean execute(String[] cmd) { System.out.println(temp.serialisedValue); } } else { - CommadTools.informToChooseTable(); + CommandTools.informToChooseTable(); } } catch (Exception e) { System.out.println(e); diff --git a/src/ru/fizteh/fivt/students/MaximGotovchits/Parallel/base/commands/List.java b/src/ru/fizteh/fivt/students/MaximGotovchits/Parallel/base/commands/List.java index 181557041..8ce19b62c 100644 --- a/src/ru/fizteh/fivt/students/MaximGotovchits/Parallel/base/commands/List.java +++ b/src/ru/fizteh/fivt/students/MaximGotovchits/Parallel/base/commands/List.java @@ -6,10 +6,22 @@ public class List extends Command { @Override public boolean execute(String[] cmd) { if (cmd.length == 1) { - if (CommadTools.tableIsChosen) { - CommadTools.currentTable.list(); + if (CommandTools.tableIsChosen) { + java.util.List list = CommandTools.currentTable.list(); + int size = 0; + for (Object iter : list) { + if (size < CommandTools.currentTable.storage.get().size() - 1) { + System.out.print(iter + ", "); + } else { + System.out.print(iter); + } + ++size; + } + if (size != 0) { + System.out.println(); + } } else { - CommadTools.informToChooseTable(); + CommandTools.informToChooseTable(); } return true; } diff --git a/src/ru/fizteh/fivt/students/MaximGotovchits/Parallel/base/commands/MakeDirs.java b/src/ru/fizteh/fivt/students/MaximGotovchits/Parallel/base/commands/MakeDirs.java index 1f6a603b4..43db05961 100644 --- a/src/ru/fizteh/fivt/students/MaximGotovchits/Parallel/base/commands/MakeDirs.java +++ b/src/ru/fizteh/fivt/students/MaximGotovchits/Parallel/base/commands/MakeDirs.java @@ -7,17 +7,17 @@ public class MakeDirs extends Command { @Override public boolean execute(String[] cmd) throws Exception { - File file = new File(CommadTools.DATA_BASE_NAME); + File file = new File(CommandTools.DATA_BASE_NAME); if (!file.exists()) { file.mkdirs(); } else { if (!file.isDirectory()) { - System.err.println(CommadTools.DATA_BASE_NAME + " is not a directory"); + System.err.println(CommandTools.DATA_BASE_NAME + " is not a directory"); System.exit(1); } else { for (File sub : file.listFiles()) { if (!sub.isDirectory() && !sub.isHidden()) { - System.err.println(CommadTools.DATA_BASE_NAME + File.separator + System.err.println(CommandTools.DATA_BASE_NAME + File.separator + sub.getName() + " is not a directory"); } } diff --git a/src/ru/fizteh/fivt/students/MaximGotovchits/Parallel/base/commands/Put.java b/src/ru/fizteh/fivt/students/MaximGotovchits/Parallel/base/commands/Put.java index 1fdc08ba4..c4d4e15a2 100644 --- a/src/ru/fizteh/fivt/students/MaximGotovchits/Parallel/base/commands/Put.java +++ b/src/ru/fizteh/fivt/students/MaximGotovchits/Parallel/base/commands/Put.java @@ -7,7 +7,7 @@ public class Put extends Command { public boolean execute(String[] cmd) { if (cmd.length > 3) { - if (CommadTools.tableIsChosen) { + if (CommandTools.tableIsChosen) { String putParameter = new String(); String key = cmd[1]; for (int ind = 2; ind < cmd.length; ++ind) { @@ -16,8 +16,9 @@ public boolean execute(String[] cmd) { putParameter = putParameter.substring(0, putParameter.length() - 1); try { ObjectStoreable value = (ObjectStoreable) new ObjectTableProvider(). - deserialize(CommadTools.currentTable, putParameter); - ObjectStoreable temp = (ObjectStoreable) CommadTools.currentTable.put(key, value); + deserialize(CommandTools.currentTable, putParameter); + ObjectStoreable temp = (ObjectStoreable) CommandTools.currentTable.put(key, value); + System.out.println(temp.serialisedValue); if (temp == null) { System.out.println("new"); } else { @@ -27,7 +28,7 @@ public boolean execute(String[] cmd) { System.err.println(e); } } else { - CommadTools.informToChooseTable(); + CommandTools.informToChooseTable(); } return true; } diff --git a/src/ru/fizteh/fivt/students/MaximGotovchits/Parallel/base/commands/Remove.java b/src/ru/fizteh/fivt/students/MaximGotovchits/Parallel/base/commands/Remove.java index 4a6408a6c..d1901bbb7 100644 --- a/src/ru/fizteh/fivt/students/MaximGotovchits/Parallel/base/commands/Remove.java +++ b/src/ru/fizteh/fivt/students/MaximGotovchits/Parallel/base/commands/Remove.java @@ -6,9 +6,9 @@ public class Remove extends Command { public boolean execute(String[] cmd) { if (cmd.length == 2) { - if (CommadTools.tableIsChosen) { + if (CommandTools.tableIsChosen) { try { - ObjectStoreable temp = (ObjectStoreable) CommadTools.currentTable.remove(cmd[1]); + ObjectStoreable temp = (ObjectStoreable) CommandTools.currentTable.remove(cmd[1]); if (temp == null) { System.out.println("not found"); } else { @@ -18,7 +18,7 @@ public boolean execute(String[] cmd) { System.err.println(e); } } else { - CommadTools.informToChooseTable(); + CommandTools.informToChooseTable(); } return true; } diff --git a/src/ru/fizteh/fivt/students/MaximGotovchits/Parallel/base/commands/Rollback.java b/src/ru/fizteh/fivt/students/MaximGotovchits/Parallel/base/commands/Rollback.java index 64f16a845..bfd6b47ed 100644 --- a/src/ru/fizteh/fivt/students/MaximGotovchits/Parallel/base/commands/Rollback.java +++ b/src/ru/fizteh/fivt/students/MaximGotovchits/Parallel/base/commands/Rollback.java @@ -6,7 +6,7 @@ public class Rollback extends Command { @Override public boolean execute(String[] cmd) { if (cmd.length == 1) { - CommadTools.currentTable.rollback(); + CommandTools.currentTable.rollback(); return true; } return false; diff --git a/src/ru/fizteh/fivt/students/MaximGotovchits/Parallel/base/commands/ShowTables.java b/src/ru/fizteh/fivt/students/MaximGotovchits/Parallel/base/commands/ShowTables.java index df907d768..fccfd937d 100644 --- a/src/ru/fizteh/fivt/students/MaximGotovchits/Parallel/base/commands/ShowTables.java +++ b/src/ru/fizteh/fivt/students/MaximGotovchits/Parallel/base/commands/ShowTables.java @@ -3,11 +3,50 @@ import ru.fizteh.fivt.students.MaximGotovchits.Parallel.interpreter.Command; import ru.fizteh.fivt.students.MaximGotovchits.Parallel.objects.ObjectTableProvider; +import java.io.*; +import java.nio.charset.StandardCharsets; +import java.util.List; + public class ShowTables extends Command { @Override public boolean execute(String[] cmd) { if (cmd.length == 2) { - new ObjectTableProvider().getTableNames(); + List list = new ObjectTableProvider().getTableNames(); + String currentFile; + int recordsAmount; + File file = new File(CommandTools.DATA_BASE_NAME); + for (File sub : file.listFiles()) { + if ((!sub.isHidden()) && sub.isDirectory()) { + recordsAmount = 0; + for (Integer i = 0; i < CommandTools.DIR_NUM; ++i) { + currentFile = CommandTools.DATA_BASE_NAME + File.separator + sub.getName() + File.separator + i + + CommandTools.DIR_EXT; + File file1 = new File(currentFile); + if (file1.exists()) { + for (Integer j = 0; j < CommandTools.FILE_NUM; ++j) { + currentFile = CommandTools.DATA_BASE_NAME + File.separator + sub.getName() + + File.separator + i + CommandTools.DIR_EXT + File.separator + j + + CommandTools.FILE_EXT; + file1 = new File(currentFile); + try { + if (file1.exists()) { + DataInputStream stream = new DataInputStream(new FileInputStream(currentFile)); + byte[] data = new byte[(int) file1.length()]; + stream.read(data); + String temp = new String(data, StandardCharsets.UTF_8); + recordsAmount += (temp.length() - temp.replaceAll(" ", "").length()) / 4; + } + } catch (FileNotFoundException e) { + System.err.println(e); + } catch (IOException e) { + System.err.println(e); + } + } + } + } + System.out.println(sub.getName() + " " + recordsAmount); + } + } return true; } return false; diff --git a/src/ru/fizteh/fivt/students/MaximGotovchits/Parallel/base/commands/Use.java b/src/ru/fizteh/fivt/students/MaximGotovchits/Parallel/base/commands/Use.java index a7d68f6aa..c40d788d0 100644 --- a/src/ru/fizteh/fivt/students/MaximGotovchits/Parallel/base/commands/Use.java +++ b/src/ru/fizteh/fivt/students/MaximGotovchits/Parallel/base/commands/Use.java @@ -17,7 +17,7 @@ public String getCmdName() { @Override public boolean execute(String[] cmd) throws Exception { if (cmd.length == 2) { - useFunction(cmd[1], CommadTools.usingTableName); + useFunction(cmd[1], CommandTools.usingTableName); return true; } return false; @@ -26,21 +26,21 @@ public boolean execute(String[] cmd) throws Exception { public boolean useFunction(String tableName, String oldTableName) throws Exception { if (!tableName.equals(oldTableName)) { String outputName = tableName; - String tablePath = CommadTools.DATA_BASE_NAME + File.separator + tableName; + String tablePath = CommandTools.DATA_BASE_NAME + File.separator + tableName; File file = new File(tablePath); if (file.exists()) { - CommadTools.usingTableName = tableName; - if (CommadTools.tableIsChosen) { + CommandTools.usingTableName = tableName; + if (CommandTools.tableIsChosen) { new FillTable().execute(null); - CommadTools.currentTable.storage.get().clear(); - CommadTools.currentTable.commitStorage.clear(); + CommandTools.currentTable.storage.get().clear(); + CommandTools.currentTable.commitStorage.clear(); } - CommadTools.currentTable = new ObjectTable(CommadTools.DATA_BASE_NAME + File.separator - + CommadTools.usingTableName); - for (Integer i = 0; i < CommadTools.DIR_NUM; ++i) { - for (Integer j = 0; j < CommadTools.FILE_NUM; ++j) { - tablePath = CommadTools.DATA_BASE_NAME + File.separator + tableName + File.separator - + i + CommadTools.DIR_EXT + File.separator + j + CommadTools.FILE_EXT; + CommandTools.currentTable = new ObjectTable(CommandTools.DATA_BASE_NAME + File.separator + + CommandTools.usingTableName); + for (Integer i = 0; i < CommandTools.DIR_NUM; ++i) { + for (Integer j = 0; j < CommandTools.FILE_NUM; ++j) { + tablePath = CommandTools.DATA_BASE_NAME + File.separator + tableName + File.separator + + i + CommandTools.DIR_EXT + File.separator + j + CommandTools.FILE_EXT; if (new File(tablePath).exists()) { fillStorage(tablePath, file); PrintWriter writer = new PrintWriter(new File(tablePath)); @@ -50,7 +50,7 @@ public boolean useFunction(String tableName, String oldTableName) throws Excepti } } System.out.println("using " + outputName); - CommadTools.tableIsChosen = true; + CommandTools.tableIsChosen = true; } else { System.err.println(tableName + " not exists"); return false; @@ -58,7 +58,7 @@ public boolean useFunction(String tableName, String oldTableName) throws Excepti } else { System.out.println("using " + oldTableName); } - CommadTools.usingTableName = CommadTools.currentTable.getName(); + CommandTools.usingTableName = CommandTools.currentTable.getName(); return true; } @@ -82,8 +82,8 @@ void fillStorage(String datName, File file) throws IOException, ParseException { String tableName = new File(new File(datName).getParent()).getParent(); ObjectStoreable valForMap = (ObjectStoreable) new ObjectTableProvider().deserialize(new ObjectTable(tableName), value); - CommadTools.currentTable.storage.get().put(keyForMap, valForMap); - CommadTools.currentTable.commitStorage.put(keyForMap, valForMap); + CommandTools.currentTable.storage.get().put(keyForMap, valForMap); + CommandTools.currentTable.commitStorage.put(keyForMap, valForMap); counter = counter + offset + 3; } stream.close(); diff --git a/src/ru/fizteh/fivt/students/MaximGotovchits/Parallel/interpreter/Interpreter.java b/src/ru/fizteh/fivt/students/MaximGotovchits/Parallel/interpreter/Interpreter.java index d1a792342..fc4910af9 100644 --- a/src/ru/fizteh/fivt/students/MaximGotovchits/Parallel/interpreter/Interpreter.java +++ b/src/ru/fizteh/fivt/students/MaximGotovchits/Parallel/interpreter/Interpreter.java @@ -54,8 +54,6 @@ private void parseStep(Map commands, String[] cmd, boolean isFr new Exit().execute(exit); } } - correctCmdName = false; + //correctCmdName = false; } - - //Interpreter(cmd, fromCmdLine); } diff --git a/src/ru/fizteh/fivt/students/MaximGotovchits/Parallel/objects/ObjectStoreable.java b/src/ru/fizteh/fivt/students/MaximGotovchits/Parallel/objects/ObjectStoreable.java index 256032d55..83a5d7350 100644 --- a/src/ru/fizteh/fivt/students/MaximGotovchits/Parallel/objects/ObjectStoreable.java +++ b/src/ru/fizteh/fivt/students/MaximGotovchits/Parallel/objects/ObjectStoreable.java @@ -28,12 +28,6 @@ public ObjectStoreable(List values) { serialisedValue += RIGHT_BRACE; } - /*public ObjectStoreable(Storeable value) { - subValueList = ((ObjectStoreable) value).subValueList; - serialisedValue = ((ObjectStoreable) value).serialisedValue; - typeKeeper = ((ObjectStoreable) value).typeKeeper; - }*/ - public ObjectStoreable(ObjectTable table) { typeKeeper = table.typeKeeper; } @@ -66,22 +60,14 @@ public boolean equals(Object obj) { @Override public void setColumnAt(int columnIndex, Object value) throws ColumnFormatException, IndexOutOfBoundsException { - try { - if (columnIndex >= this.subValueList.size()) { - throw new IndexOutOfBoundsException(); - } - List> toConvert = new LinkedList<>(); - toConvert.add(value.getClass()); - toConvert = convertToPrimitive(toConvert); - if (!typeKeeper.get(columnIndex).equals(toConvert.get(0))) { - throw new ColumnFormatException(); - } - } catch (IndexOutOfBoundsException s) { - System.err.println(s); - return; - } catch (ColumnFormatException s) { - System.err.println(s); - return; + if (columnIndex >= this.subValueList.size()) { + throw new IndexOutOfBoundsException(); + } + List> toConvert = new LinkedList<>(); + toConvert.add(value.getClass()); + toConvert = convertToPrimitive(toConvert); + if (!typeKeeper.get(columnIndex).equals(toConvert.get(0))) { + throw new ColumnFormatException(); } this.subValueList.set(columnIndex, value); this.serialisedValue = ""; @@ -114,102 +100,66 @@ public Integer getIntAt(int columnIndex) throws ColumnFormatException, IndexOutO @Override public Long getLongAt(int columnIndex) throws ColumnFormatException, IndexOutOfBoundsException { - try { - if (columnIndex >= this.typeKeeper.size()) { - throw new IndexOutOfBoundsException(); - } - if (!typeKeeper.get(columnIndex).equals(long.class)) { - throw new ColumnFormatException(); - } - } catch (IndexOutOfBoundsException s) { - System.err.println(s); - } catch (ColumnFormatException s) { - System.err.println(s); + if (columnIndex >= this.typeKeeper.size()) { + throw new IndexOutOfBoundsException(); + } + if (!typeKeeper.get(columnIndex).equals(long.class)) { + throw new ColumnFormatException(); } return (Long) subValueList.get(columnIndex); } @Override public Byte getByteAt(int columnIndex) throws ColumnFormatException, IndexOutOfBoundsException { - try { - if (columnIndex >= this.typeKeeper.size()) { - throw new IndexOutOfBoundsException(); - } - if (!typeKeeper.get(columnIndex).equals(byte.class)) { - throw new ColumnFormatException(); - } - } catch (IndexOutOfBoundsException s) { - System.err.println(s); - } catch (ColumnFormatException s) { - System.err.println(s); + if (columnIndex >= this.typeKeeper.size()) { + throw new IndexOutOfBoundsException(); + } + if (!typeKeeper.get(columnIndex).equals(byte.class)) { + throw new ColumnFormatException(); } return (Byte) subValueList.get(columnIndex); } @Override public Float getFloatAt(int columnIndex) throws ColumnFormatException, IndexOutOfBoundsException { - try { - if (columnIndex >= this.typeKeeper.size()) { - throw new IndexOutOfBoundsException(); - } - if (!typeKeeper.get(columnIndex).equals(float.class)) { - throw new ColumnFormatException(); - } - } catch (IndexOutOfBoundsException s) { - System.err.println(s); - } catch (ColumnFormatException s) { - System.err.println(s); + if (columnIndex >= this.typeKeeper.size()) { + throw new IndexOutOfBoundsException(); + } + if (!typeKeeper.get(columnIndex).equals(float.class)) { + throw new ColumnFormatException(); } return (Float) subValueList.get(columnIndex); } @Override public Double getDoubleAt(int columnIndex) throws ColumnFormatException, IndexOutOfBoundsException { - try { - if (columnIndex >= this.typeKeeper.size()) { - throw new IndexOutOfBoundsException(); - } - if (!typeKeeper.get(columnIndex).equals(double.class)) { - throw new ColumnFormatException(); - } - } catch (IndexOutOfBoundsException s) { - System.err.println(s); - } catch (ColumnFormatException s) { - System.err.println(s); + if (columnIndex >= this.typeKeeper.size()) { + throw new IndexOutOfBoundsException(); + } + if (!typeKeeper.get(columnIndex).equals(double.class)) { + throw new ColumnFormatException(); } return (Double) subValueList.get(columnIndex); } @Override public Boolean getBooleanAt(int columnIndex) throws ColumnFormatException, IndexOutOfBoundsException { - try { - if (columnIndex >= this.typeKeeper.size()) { - throw new IndexOutOfBoundsException(); - } - if (!typeKeeper.get(columnIndex).equals(boolean.class)) { - throw new ColumnFormatException(); - } - } catch (IndexOutOfBoundsException s) { - System.err.println(s); - } catch (ColumnFormatException s) { - System.err.println(s); + if (columnIndex >= this.typeKeeper.size()) { + throw new IndexOutOfBoundsException(); + } + if (!typeKeeper.get(columnIndex).equals(boolean.class)) { + throw new ColumnFormatException(); } return (Boolean) subValueList.get(columnIndex); } @Override public String getStringAt(int columnIndex) throws ColumnFormatException, IndexOutOfBoundsException { - try { - if (columnIndex >= this.typeKeeper.size()) { - throw new IndexOutOfBoundsException(); - } - if (!typeKeeper.get(columnIndex).equals(String.class)) { - throw new ColumnFormatException(); - } - } catch (IndexOutOfBoundsException s) { - System.err.println(s); - } catch (ColumnFormatException s) { - System.err.println(s); + if (columnIndex >= this.typeKeeper.size()) { + throw new IndexOutOfBoundsException(); + } + if (!typeKeeper.get(columnIndex).equals(String.class)) { + throw new ColumnFormatException(); } return subValueList.get(columnIndex).toString(); } diff --git a/src/ru/fizteh/fivt/students/MaximGotovchits/Parallel/objects/ObjectTable.java b/src/ru/fizteh/fivt/students/MaximGotovchits/Parallel/objects/ObjectTable.java index e20490476..dcce68322 100644 --- a/src/ru/fizteh/fivt/students/MaximGotovchits/Parallel/objects/ObjectTable.java +++ b/src/ru/fizteh/fivt/students/MaximGotovchits/Parallel/objects/ObjectTable.java @@ -103,7 +103,6 @@ public Storeable get(String key) throws IllegalArgumentException { // В док if (value == null) { return null; } - String serializedValue = value.serialisedValue; return value; } @@ -124,7 +123,6 @@ public Storeable put(String key, Storeable value) throws ColumnFormatException { lastChanges.get().push(key); lastChanges.get().push("put"); ++overwriteNum; - System.out.println(previousValue.serialisedValue); } return previousValue; } @@ -152,19 +150,9 @@ public int size() { @Override public List list() { LinkedList list = new LinkedList(); - int size = 0; Set k = storage.get().keySet(); for (Object iter : k) { list.add(iter.toString()); - if (size < storage.get().size() - 1) { - System.out.print(iter + ", "); - } else { - System.out.print(iter); - } - ++size; - } - if (size != 0) { - System.out.println(); } return list; } diff --git a/src/ru/fizteh/fivt/students/MaximGotovchits/Parallel/objects/ObjectTableProvider.java b/src/ru/fizteh/fivt/students/MaximGotovchits/Parallel/objects/ObjectTableProvider.java index 57c831d5f..fdd4faa0d 100644 --- a/src/ru/fizteh/fivt/students/MaximGotovchits/Parallel/objects/ObjectTableProvider.java +++ b/src/ru/fizteh/fivt/students/MaximGotovchits/Parallel/objects/ObjectTableProvider.java @@ -5,7 +5,6 @@ import ru.fizteh.fivt.storage.structured.Table; import ru.fizteh.fivt.storage.structured.TableProvider; import java.io.*; -import java.nio.charset.StandardCharsets; import java.text.ParseException; import java.util.LinkedList; import java.util.List; @@ -14,11 +13,8 @@ import java.util.concurrent.locks.ReentrantReadWriteLock; public class ObjectTableProvider implements TableProvider { + private static final String INCORRECT_SYMBOL = "^incorrect@"; private static final String BRACES_KILLER = "^\\s*\\[\\s*|\\s*\\]\\s*$"; - private static final String FILE_EXT = ".dat"; - private static final Integer FILE_NUM = 16; - private static final String DIR_EXT = ".dir"; - private static final Integer DIR_NUM = 16; private static final String JSON_REG_EX = "\\s*,\\s*(?=(?:(?:[^\"]*\"){2})*[^\"]*$)"; private static String usingTableName; private static ObjectTable currentTableObject; @@ -51,9 +47,10 @@ public boolean equals(Object obj) { public Table getTable(String name) throws IllegalArgumentException { checkException(name); ReadWriteLock readWriteLock = new ReentrantReadWriteLock(); - if (new File(rootDirectory + File.separator + name).exists()) { + String tempPath = rootDirectory + File.separator + name; + if (new File(tempPath).exists()) { readWriteLock.readLock().lock(); - ObjectTable tableToReturn = new ObjectTable(rootDirectory + File.separator + name); + ObjectTable tableToReturn = new ObjectTable(tempPath); readWriteLock.readLock().unlock(); return tableToReturn; } @@ -71,7 +68,7 @@ public Table createTable(String name, List> columnTypes) throws IOExcep File file = new File(rootDirectory + File.separator + name); File signatureFile = new File(rootDirectory + File.separator + name + File.separator + SIGNATURE_FILENAME); if (file.exists()) { - System.out.println(name + " exists"); + return null; } else { file.mkdir(); signatureFile.createNewFile(); @@ -87,7 +84,6 @@ public Table createTable(String name, List> columnTypes) throws IOExcep tempTypes = tempTypes.substring(0, tempTypes.length() - 1); writer.println(tempTypes); writer.close(); - System.out.println("created"); } readWriteLock.writeLock().unlock(); writeSectionIsInUse = false; @@ -111,7 +107,6 @@ public void removeTable(String name) throws IllegalArgumentException, IllegalSta } recRem(tableName); toBeRemoved.delete(); - System.out.println("dropped"); } else { throw new IllegalStateException(); } @@ -134,8 +129,8 @@ public Storeable deserialize(Table table, String value) throws ParseException { int index = 0; List> typeList = new LinkedList<>(); for (String str : tempValue) { - Object val = getValue(str, usingTable, usingTable.typeKeeper.get(index)); - if (val.equals("^incorrect$")) { + Object val = getValue(str/*, usingTable*/, usingTable.typeKeeper.get(index)); + if (val.equals(INCORRECT_SYMBOL)) { throw new ParseException(value, 0); } valueToReturn.subValueList.add(val); @@ -167,9 +162,8 @@ public Storeable createFor(Table table) { @Override public Storeable createFor(Table table, List values) throws ColumnFormatException, IndexOutOfBoundsException { - int ind = 0; ObjectTable tempTable = new ObjectTable(table); - List> valTypes = new LinkedList>(); + List> valTypes; valTypes = convertToPrimitive(values); if (values.size() != tempTable.getColumnsCount()) { throw new IndexOutOfBoundsException(); @@ -184,111 +178,82 @@ public Storeable createFor(Table table, List values) throws ColumnFormatExcep @Override public List getTableNames() { - List list = new LinkedList(); - String currentFile = new String(); - int recordsAmount = 0; + List list = new LinkedList<>(); File file = new File(rootDirectory); for (File sub : file.listFiles()) { if ((!sub.isHidden()) && sub.isDirectory()) { - recordsAmount = 0; - for (Integer i = 0; i < DIR_NUM; ++i) { - currentFile = rootDirectory + File.separator + sub.getName() + File.separator - + i + DIR_EXT; - File file1 = new File(currentFile); - if (file1.exists()) { - for (Integer j = 0; j < FILE_NUM; ++j) { - currentFile = rootDirectory + File.separator + sub.getName() + File.separator - + i + DIR_EXT + File.separator + j + FILE_EXT; - file1 = new File(currentFile); - try { - if (file1.exists()) { - DataInputStream stream = new DataInputStream(new FileInputStream(currentFile)); - byte[] data = new byte[(int) file1.length()]; - stream.read(data); - String temp = new String(data, StandardCharsets.UTF_8); - recordsAmount += (temp.length() - temp.replaceAll(" ", "").length()) / 4; - } - } catch (FileNotFoundException e) { - return null; - } catch (IOException e) { - return null; - } - } - } - } - currentFile = new File(new File(new File(currentFile).getParent()).getParent()).getName(); list.add(sub.getName()); - if (sub.getName().equals(usingTableName)) { - System.out.println(sub.getName() + " " - + (recordsAmount + currentTableObject.storage.get().size())); - } else { - System.out.println(sub.getName() + " " + recordsAmount); - } } } return list; } - private Object getValue(String str, ObjectTable usingTable, Class expectedType) throws NumberFormatException { - for (Class type : usingTable.typeKeeper) { - if (expectedType.equals(int.class)) { - if (str.equals("null")) { - return null; - } - Integer toReturn = Integer.parseInt(str); - return toReturn; + private Object getValue(String str, Class expectedType) + throws NumberFormatException { + if (expectedType.equals(int.class)) { + if (isNull(str)) { + return null; } - if (expectedType.equals(long.class)) { - if (str.equals("null")) { - return null; - } - Long toReturn = Long.parseLong(str); - return toReturn; + Integer toReturn = Integer.parseInt(str); + return toReturn; + } + if (expectedType.equals(long.class)) { + if (isNull(str)) { + return null; } - if (expectedType.equals(boolean.class)) { - if (str.equals("null")) { - return null; - } - Boolean toReturn = Boolean.parseBoolean(str); - return toReturn; + Long toReturn = Long.parseLong(str); + return toReturn; + } + if (expectedType.equals(boolean.class)) { + if (isNull(str)) { + return null; } - if (expectedType.equals(String.class)) { - if (str.equals("null")) { - return null; - } - String[] tmp = str.split(""); - if (tmp[0].equals("\"") && tmp[tmp.length - 1].equals("\"")) { - return str; - } else { - throw new NumberFormatException(); - } + Boolean toReturn = Boolean.parseBoolean(str); + return toReturn; + } + if (expectedType.equals(String.class)) { + if (isNull(str)) { + return null; } - if (expectedType.equals(byte.class)) { - if (str.equals("null")) { - return null; - } - Byte toReturn = Byte.parseByte(str); - return toReturn; + String[] tmp = str.split(""); + if (tmp[0].equals("\"") && tmp[tmp.length - 1].equals("\"")) { + return str; + } else { + throw new NumberFormatException(); } - if (expectedType.equals(double.class)) { - if (str.equals("null")) { - return null; - } - Double toReturn = Double.parseDouble(str); - return toReturn; + } + if (expectedType.equals(byte.class)) { + if (isNull(str)) { + return null; } - if (expectedType.equals(float.class)) { - if (str.equals("null")) { - return null; - } - Float toReturn = Float.parseFloat(str); - return toReturn; + Byte toReturn = Byte.parseByte(str); + return toReturn; + } + if (expectedType.equals(double.class)) { + if (isNull(str)) { + return null; } + Double toReturn = Double.parseDouble(str); + return toReturn; + } + if (expectedType.equals(float.class)) { + if (isNull(str)) { + return null; + } + Float toReturn = Float.parseFloat(str); + return toReturn; + } + return INCORRECT_SYMBOL; + } + + boolean isNull(String str) { + if (str.equals("null")) { + return true; } - return "^incorrect@"; + return false; } - void recRem(String myFile) { + private void recRem(String myFile) { File file = new File(myFile); if (!file.exists()) { return; diff --git a/src/ru/fizteh/fivt/students/MaximGotovchits/Parallel/objects/ObjectTableProviderFactory.java b/src/ru/fizteh/fivt/students/MaximGotovchits/Parallel/objects/ObjectTableProviderFactory.java index 9bcc77941..a73756cf9 100644 --- a/src/ru/fizteh/fivt/students/MaximGotovchits/Parallel/objects/ObjectTableProviderFactory.java +++ b/src/ru/fizteh/fivt/students/MaximGotovchits/Parallel/objects/ObjectTableProviderFactory.java @@ -10,13 +10,8 @@ public class ObjectTableProviderFactory implements TableProviderFactory { @Override public TableProvider create(String dir) throws IllegalArgumentException { dirName = dir; - try { - if (dir == null || dir.length() > LONGEST_NAME) { - throw new IllegalArgumentException(); - } - } catch (IllegalArgumentException s) { - System.err.println(s); - return null; + if (dir == null || dir.length() > LONGEST_NAME) { + throw new IllegalArgumentException(); } return new ObjectTableProvider(dir); } diff --git a/src/ru/fizteh/fivt/students/MaximGotovchits/Parallel/test/ObjectStoreableTest.java b/src/ru/fizteh/fivt/students/MaximGotovchits/Parallel/test/ObjectStoreableTest.java index 2423765f3..bac46e455 100644 --- a/src/ru/fizteh/fivt/students/MaximGotovchits/Parallel/test/ObjectStoreableTest.java +++ b/src/ru/fizteh/fivt/students/MaximGotovchits/Parallel/test/ObjectStoreableTest.java @@ -20,6 +20,7 @@ public class ObjectStoreableTest { public ObjectTable table; public String valueToDeserialize; public ObjectTable tempTable; + @Before public void initialization() throws IOException { name = "TestTable"; @@ -42,6 +43,7 @@ public void initialization() throws IOException { tempTable = (ObjectTable) new ObjectTableProvider().createTable(name, columnTypes); valueToDeserialize = "[100500, 10000000, 123.456, 12.45, 100, true, \"ValueToTest\"]"; } + @Test public void setColumnAtTest() { ObjectStoreable tempStoreable = new ObjectStoreable(); @@ -61,44 +63,47 @@ public void setColumnAtTest() { deserializedValue.setColumnAt(6, "\"AnotherValue\""); assertEquals(tempStoreable, deserializedValue); } + @Test public void getColumnAtTest() { - assertEquals(100500, deserializedValue.getColumnAt(0)); assertEquals((long) 10000000, deserializedValue.getColumnAt(1)); - assertEquals(123.456, deserializedValue.getColumnAt(2)); - assertEquals((float) 12.45, deserializedValue.getColumnAt(3)); - assertEquals((byte) 100, deserializedValue.getColumnAt(4)); - assertEquals(true, deserializedValue.getColumnAt(5)); - assertEquals("\"ValueToTest\"", deserializedValue.getColumnAt(6)); } + @Test public void getIntAtTest() { assertEquals((Integer) 100500, deserializedValue.getIntAt(0)); } + @Test public void getLongAtTest() { assertEquals((Long) Long.parseLong("10000000"), deserializedValue.getLongAt(1)); } + @Test public void getByteAtTest() { assertEquals((Byte) Byte.parseByte("100"), deserializedValue.getByteAt(4)); } + @Test public void getFloatAtTest() { assertEquals((Float) Float.parseFloat("12.45"), deserializedValue.getFloatAt(3)); } + @Test public void getDoubleAtTest() { assertEquals((Double) 123.456, deserializedValue.getDoubleAt(2)); } + @Test public void getBooleanAtTest() { assertEquals(true, deserializedValue.getBooleanAt(5)); } + @Test public void getStringAtTest() { assertEquals("\"ValueToTest\"", deserializedValue.getStringAt(6)); } + @After public void cleanUp() { new ObjectTableProvider().removeTable(name); diff --git a/src/ru/fizteh/fivt/students/MaximGotovchits/Parallel/test/ObjectTableProviderTest.java b/src/ru/fizteh/fivt/students/MaximGotovchits/Parallel/test/ObjectTableProviderTest.java index 3cf6ff761..ebcb83b40 100644 --- a/src/ru/fizteh/fivt/students/MaximGotovchits/Parallel/test/ObjectTableProviderTest.java +++ b/src/ru/fizteh/fivt/students/MaximGotovchits/Parallel/test/ObjectTableProviderTest.java @@ -1,11 +1,14 @@ package ru.fizteh.fivt.students.MaximGotovchits.Parallel.test; import static org.junit.Assert.assertEquals; +import static org.junit.Assert.assertTrue; + import org.junit.*; import ru.fizteh.fivt.students.MaximGotovchits.Parallel.objects.ObjectStoreable; import ru.fizteh.fivt.students.MaximGotovchits.Parallel.objects.ObjectTable; import ru.fizteh.fivt.students.MaximGotovchits.Parallel.objects.ObjectTableProvider; import java.io.IOException; +import java.text.ParseException; import java.util.LinkedList; import java.util.List; @@ -35,49 +38,50 @@ public void initialization() throws IOException { deserializedValue.typeKeeper = columnTypes; deserializedValue.serialisedValue = "[100500, 10000000, 123.456, 12.45, 100, true, \"ValueToTest\"]"; } + @Test public void createAndGetTableTest() throws IOException { name = "TestTable"; assertEquals(null, createTable(name, columnTypes)); assertEquals(testTable, getTable(name)); } - // @test - // public void deserializeTest() throws ParseException, IOException { - // assertEquals(deserializedValue, (ObjectStoreable) deserialize(table, valueToDeserialize)); - // } - /*@test(expected = IllegalArgumentException.class) // Это была попытка сделать тест на исключения. - //В следующей задаче я постараюсь это сделать. Просто нужно изменять кучу кода. - public void createNullTableTest() throws IOException { - createTable(null, columnTypes); - }*/ - /*@test + + @Test + public void deserializeTest() throws IOException { + try { + assertEquals(deserializedValue, (ObjectStoreable) deserialize(testTable, + deserializedValue.serialisedValue)); + } catch (ParseException e) { + assertTrue(false); + } + } + + @Test + public void deserializeExceptionTest() throws IOException { + try { + assertEquals(deserializedValue, deserialize(testTable, + "we are waiting for exception here >:[")); + } catch (ParseException e) { + assertTrue(true); + } + } + + @Test public void serializeTest() { - assertEquals(valueToDeserialize, serialize(table, deserializedValue)); + assertEquals(deserializedValue.serialisedValue, serialize(testTable, deserializedValue)); } - @test - public void createForTest() { - ObjectStoreable tempStoreable = new ObjectStoreable(); - tempStoreable.typeKeeper = table.typeKeeper; - assertEquals(tempStoreable, createFor(table)); - tempStoreable.subValueList = deserializedValue.subValueList; - tempStoreable.serialisedValue = deserializedValue.serialisedValue; - ObjectStoreable qq = (ObjectStoreable) createFor(table, deserializedValue.subValueList); - assertEquals(tempStoreable, (ObjectStoreable) createFor(table, deserializedValue.subValueList)); + + @Test + public void createForFirstTest() { + assertEquals(deserializedValue, createFor(testTable, deserializedValue.subValueList)); } - @test - public void getTableNamesTest() throws IOException { // Конечно же, стоит удостовериться, + + @Test + public void getTableNameTest() throws IOException { // Конечно же, стоит удостовериться, // что в рабочей директории на момент тестирования нет таблиц. - List toCompare = new LinkedList(); - toCompare.add(name); - for (Integer ind = 0; ind < 1000; ++ind) { // Generating tables. - toCompare.add(ind.toString()); - createTable(ind.toString(), columnTypes); - } - assertTrue(toCompare.containsAll(getTableNames())); - for (Integer ind = 0; ind < 1000; ++ind) { - removeTable(ind.toString()); - } - }*/ + assertEquals("TestTable", testTable.getName()); + } + @After public void cleanUp() { // Поясню. Теста на removeTable нет. Если бы метод не работал, то было бы // сообщение "table_name exists". Его нет. diff --git a/src/ru/fizteh/fivt/students/MaximGotovchits/Parallel/test/ObjectTableTest.java b/src/ru/fizteh/fivt/students/MaximGotovchits/Parallel/test/ObjectTableTest.java index 845deab1f..d15a856e9 100644 --- a/src/ru/fizteh/fivt/students/MaximGotovchits/Parallel/test/ObjectTableTest.java +++ b/src/ru/fizteh/fivt/students/MaximGotovchits/Parallel/test/ObjectTableTest.java @@ -3,6 +3,7 @@ import static junit.framework.Assert.assertNull; import static org.junit.Assert.assertEquals; import static org.junit.Assert.assertTrue; + import org.junit.*; import org.junit.Test; import ru.fizteh.fivt.students.MaximGotovchits.Parallel.base.commands.Use; @@ -19,6 +20,7 @@ public class ObjectTableTest { public List> columnTypes = new LinkedList>(); public ObjectStoreable deserializedValue = new ObjectStoreable(); public ObjectTable testTable; + @Before public void initialization() throws IOException { name = "TestTable"; @@ -30,8 +32,6 @@ public void initialization() throws IOException { columnTypes.add(boolean.class); columnTypes.add(String.class); testTable = (ObjectTable) new ObjectTableProvider().createTable(name, columnTypes); - //tableToCompare.typeKeeper = columnTypes; - //tableToCompare.tableName = name; deserializedValue.subValueList.add(100500); deserializedValue.subValueList.add((long) 10000000); deserializedValue.subValueList.add(123.456); @@ -41,77 +41,98 @@ public void initialization() throws IOException { deserializedValue.subValueList.add("\"ValueToTest\""); deserializedValue.typeKeeper = columnTypes; deserializedValue.serialisedValue = "[100500, 10000000, 123.456, 12.45, 100, true, \"ValueToTest\"]"; - /*testTable = (ObjectTable) new ObjectTableProvider().createTable(name, columnTypes); - valueToDeserialize = "[100500, 10000000, 123.456, 12.45, 100, true, \"ValueToTest\"]";*/ } + @Test public void getNameTest() throws Exception { assertEquals(name, testTable.getName()); } + @Test public void putTest() throws Exception { new Use().useFunction(name, null); assertNull(testTable.put("Key", deserializedValue)); assertEquals(deserializedValue, testTable.put("Key", deserializedValue)); } + @Test public void getTest() throws Exception { new Use().useFunction(name, null); testTable.put("Key", deserializedValue); assertEquals(deserializedValue, testTable.get("Key")); } + @Test public void sizeTest() throws Exception { new Use().useFunction(name, null); - for (Integer i = 0; i < 1000; ++i) { + for (Integer i = 0; i < 3; ++i) { testTable.put(i.toString(), deserializedValue); } - assertEquals(1000, testTable.size()); + assertEquals(3, testTable.size()); } + @Test public void listTest() throws Exception { new Use().useFunction(name, null); List toCompare = new LinkedList(); - for (Integer i = 0; i < 1000; ++i) { + for (Integer i = 0; i < 3; ++i) { toCompare.add(i.toString()); testTable.put(i.toString(), deserializedValue); } assertTrue(toCompare.containsAll(testTable.list())); } + @Test public void removeTest() throws Exception { new Use().useFunction(name, null); testTable.put("Key", deserializedValue); assertEquals(deserializedValue, testTable.remove("Key")); } + @Test public void commitTest() { - for (Integer i = 0; i < 1000; ++i) { + for (Integer i = 0; i < 3; ++i) { testTable.put(i.toString(), deserializedValue); } - assertEquals(1000, testTable.commit()); + assertEquals(deserializedValue, testTable.get("0")); + assertEquals(deserializedValue, testTable.get("1")); + assertEquals(deserializedValue, testTable.get("2")); + assertEquals(3, testTable.commit()); + assertEquals(deserializedValue, testTable.get("0")); + assertEquals(deserializedValue, testTable.get("1")); + assertEquals(deserializedValue, testTable.get("2")); } + @Test public void rollbackTest() { - for (Integer i = 0; i < 1000; ++i) { + for (Integer i = 0; i < 3; ++i) { testTable.put(i.toString(), deserializedValue); } - assertEquals(1001, testTable.rollback()); + assertEquals(deserializedValue, testTable.get("0")); + assertEquals(deserializedValue, testTable.get("1")); + assertEquals(deserializedValue, testTable.get("2")); + assertEquals(3, testTable.rollback()); + assertNull(testTable.get("0")); + assertNull(testTable.get("1")); + assertNull(testTable.get("2")); } + @Test public void getNumberOfUncommittedChangesTest() { - for (Integer i = 0; i < 1000; ++i) { + for (Integer i = 0; i < 2; ++i) { String key = i.toString(); testTable.put(key, deserializedValue); } - assertEquals(1000, testTable.getNumberOfUncommittedChanges()); + assertEquals(2, testTable.getNumberOfUncommittedChanges()); testTable.commit(); assertEquals(0, testTable.getNumberOfUncommittedChanges()); } + @Test public void getColumnsCountTest() { assertEquals(7, testTable.getColumnsCount()); } + @Test public void getColumnType() throws Exception { new Use().useFunction(name, null); @@ -123,6 +144,7 @@ public void getColumnType() throws Exception { assertEquals(boolean.class, testTable.getColumnType(5)); assertEquals(String.class, testTable.getColumnType(6)); } + @After public void cleanUp() { new ObjectTableProvider().removeTable(name); From 768c00ffeff0aa2c779f861c8c102f6480c2c582 Mon Sep 17 00:00:00 2001 From: MaximGotovchits Date: Fri, 20 Mar 2015 20:33:52 +0300 Subject: [PATCH 15/18] =?UTF-8?q?=D0=93=D0=BE=D1=82=D0=BE=D0=B2=D1=87?= =?UTF-8?q?=D0=B8=D1=86=20=D0=9C=D0=B0=D0=BA=D1=81=D0=B8=D0=BC,=20Parallel?= =?UTF-8?q?,=20396?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit fixed + tests --- .../Parallel/base/commands/CommandTools.java | 2 - .../Parallel/base/commands/Create.java | 8 +- .../Parallel/base/commands/Exit.java | 6 +- .../Parallel/base/commands/FillTable.java | 31 ++-- .../Parallel/base/commands/MakeDirs.java | 2 +- .../Parallel/base/commands/Put.java | 3 +- .../Parallel/base/commands/ShowTables.java | 1 - .../Parallel/base/commands/Use.java | 12 +- .../Parallel/interpreter/Command.java | 4 +- .../Parallel/interpreter/Interpreter.java | 15 +- .../Parallel/objects/ObjectTable.java | 7 +- .../Parallel/objects/ObjectTableProvider.java | 2 +- .../test/InterpreterTest/BatchModeTest.java | 59 +++++++ .../InterpreterTest/InteractiveModeTest.java | 161 ++++++++++++++++++ 14 files changed, 267 insertions(+), 46 deletions(-) create mode 100644 src/ru/fizteh/fivt/students/MaximGotovchits/Parallel/test/InterpreterTest/BatchModeTest.java create mode 100644 src/ru/fizteh/fivt/students/MaximGotovchits/Parallel/test/InterpreterTest/InteractiveModeTest.java diff --git a/src/ru/fizteh/fivt/students/MaximGotovchits/Parallel/base/commands/CommandTools.java b/src/ru/fizteh/fivt/students/MaximGotovchits/Parallel/base/commands/CommandTools.java index 3562eb55c..629c851d8 100644 --- a/src/ru/fizteh/fivt/students/MaximGotovchits/Parallel/base/commands/CommandTools.java +++ b/src/ru/fizteh/fivt/students/MaximGotovchits/Parallel/base/commands/CommandTools.java @@ -3,8 +3,6 @@ import ru.fizteh.fivt.students.MaximGotovchits.Parallel.objects.ObjectTable; public class CommandTools { - static final String INVITATIONAL_SYMBOL = "$ "; - private static final String SPLIT_BY_COMMA = "\\s*;\\s*"; protected static final String DATA_BASE_NAME = System.getProperty("fizteh.db.dir"); static boolean tableIsChosen = false; static final int DIR_NUM = 16; diff --git a/src/ru/fizteh/fivt/students/MaximGotovchits/Parallel/base/commands/Create.java b/src/ru/fizteh/fivt/students/MaximGotovchits/Parallel/base/commands/Create.java index 30a386b87..1460e109d 100644 --- a/src/ru/fizteh/fivt/students/MaximGotovchits/Parallel/base/commands/Create.java +++ b/src/ru/fizteh/fivt/students/MaximGotovchits/Parallel/base/commands/Create.java @@ -8,8 +8,6 @@ import java.util.LinkedList; import java.util.List; -//import static java.util.Arrays.copyOfRange; - public class Create extends Command { private static final String SPLIT_BY_RIGHT_BRACKET = "\\s*\\)\\s*"; private static final String SPLIT_BY_LEFT_BRACKET = "\\s*\\(\\s*"; @@ -21,7 +19,7 @@ public String getCmdName() { } @Override - public boolean execute(String[] cmd) throws Exception { + public boolean execute(String[] cmd) { if (cmd.length > 2) { String createParameter = new String(); // (...) - type list. String tableName = cmd[1]; @@ -43,13 +41,15 @@ public boolean execute(String[] cmd) throws Exception { } } catch (IOException e) { System.err.println(e); + } catch (Exception e) { + System.err.println(e); } return true; } return false; } - public List> getTypeList(String line) throws Exception { + public List> getTypeList(String line) { ObjectTable temp = new ObjectTable(); List> typeList = new LinkedList>(); line = line.replaceAll(SPLIT_BY_RIGHT_BRACKET, ""); diff --git a/src/ru/fizteh/fivt/students/MaximGotovchits/Parallel/base/commands/Exit.java b/src/ru/fizteh/fivt/students/MaximGotovchits/Parallel/base/commands/Exit.java index ea0b46d93..384a53ee6 100644 --- a/src/ru/fizteh/fivt/students/MaximGotovchits/Parallel/base/commands/Exit.java +++ b/src/ru/fizteh/fivt/students/MaximGotovchits/Parallel/base/commands/Exit.java @@ -4,9 +4,11 @@ public class Exit extends Command { @Override - public boolean execute(String[] cmd) throws Exception { - if (CommandTools.currentTable != null) { + public boolean execute(String[] cmd) { + if (CommandTools.currentTable != null && exitAndUseAvailable()) { new FillTable().execute(null); + } else { + return false; } System.exit(0); return true; diff --git a/src/ru/fizteh/fivt/students/MaximGotovchits/Parallel/base/commands/FillTable.java b/src/ru/fizteh/fivt/students/MaximGotovchits/Parallel/base/commands/FillTable.java index 4c65ded0c..cb106f4cf 100644 --- a/src/ru/fizteh/fivt/students/MaximGotovchits/Parallel/base/commands/FillTable.java +++ b/src/ru/fizteh/fivt/students/MaximGotovchits/Parallel/base/commands/FillTable.java @@ -5,6 +5,7 @@ import java.io.DataOutputStream; import java.io.File; import java.io.FileOutputStream; +import java.io.IOException; import java.nio.charset.Charset; import java.nio.charset.StandardCharsets; import java.nio.file.Path; @@ -15,7 +16,7 @@ public class FillTable extends Command { private final Charset coding = StandardCharsets.UTF_8; @Override - public boolean execute(String[] cmd) throws Exception { + public boolean execute(String[] cmd) { for (Map.Entry entry : CommandTools.currentTable.commitStorage.entrySet()) { int hashCode = entry.getKey().hashCode(); Integer nDirectory = hashCode % CommandTools.DIR_NUM; @@ -28,17 +29,21 @@ public boolean execute(String[] cmd) throws Exception { } fileName = Paths.get(fileName.toString(), nFile + CommandTools.FILE_EXT); file = new File(fileName.toString()); - if (!file.exists()) { - file.createNewFile(); + try { + if (!file.exists()) { + file.createNewFile(); + } + byte[] bytesKey = (" " + entry.getKey() + " ").getBytes(coding); + DataOutputStream stream = new DataOutputStream(new FileOutputStream(fileName.toString(), true)); + stream.write(bytesKey.length); + stream.write(bytesKey); + byte[] bytesVal = ((" " + entry.getValue().serialisedValue + " ").getBytes(coding)); + stream.write(bytesVal.length - 1); + stream.write(bytesVal); + stream.close(); + } catch (IOException e) { + System.err.println(e); } - byte[] bytesKey = (" " + entry.getKey() + " ").getBytes(coding); - DataOutputStream stream = new DataOutputStream(new FileOutputStream(fileName.toString(), true)); - stream.write((int) bytesKey.length); - stream.write(bytesKey); - byte[] bytesVal = ((" " + entry.getValue().serialisedValue + " ").getBytes(coding)); - stream.write((int) bytesVal.length - 1); - stream.write(bytesVal); - stream.close(); } return true; } @@ -47,8 +52,4 @@ public boolean execute(String[] cmd) throws Exception { public String getCmdName() { return "fill table"; } - - private void streamWrite() { - - } } diff --git a/src/ru/fizteh/fivt/students/MaximGotovchits/Parallel/base/commands/MakeDirs.java b/src/ru/fizteh/fivt/students/MaximGotovchits/Parallel/base/commands/MakeDirs.java index 43db05961..5ad7c71be 100644 --- a/src/ru/fizteh/fivt/students/MaximGotovchits/Parallel/base/commands/MakeDirs.java +++ b/src/ru/fizteh/fivt/students/MaximGotovchits/Parallel/base/commands/MakeDirs.java @@ -6,7 +6,7 @@ public class MakeDirs extends Command { @Override - public boolean execute(String[] cmd) throws Exception { + public boolean execute(String[] cmd) { File file = new File(CommandTools.DATA_BASE_NAME); if (!file.exists()) { file.mkdirs(); diff --git a/src/ru/fizteh/fivt/students/MaximGotovchits/Parallel/base/commands/Put.java b/src/ru/fizteh/fivt/students/MaximGotovchits/Parallel/base/commands/Put.java index c4d4e15a2..146984556 100644 --- a/src/ru/fizteh/fivt/students/MaximGotovchits/Parallel/base/commands/Put.java +++ b/src/ru/fizteh/fivt/students/MaximGotovchits/Parallel/base/commands/Put.java @@ -6,7 +6,7 @@ public class Put extends Command { public boolean execute(String[] cmd) { - if (cmd.length > 3) { + if (cmd.length > 2) { if (CommandTools.tableIsChosen) { String putParameter = new String(); String key = cmd[1]; @@ -18,7 +18,6 @@ public boolean execute(String[] cmd) { ObjectStoreable value = (ObjectStoreable) new ObjectTableProvider(). deserialize(CommandTools.currentTable, putParameter); ObjectStoreable temp = (ObjectStoreable) CommandTools.currentTable.put(key, value); - System.out.println(temp.serialisedValue); if (temp == null) { System.out.println("new"); } else { diff --git a/src/ru/fizteh/fivt/students/MaximGotovchits/Parallel/base/commands/ShowTables.java b/src/ru/fizteh/fivt/students/MaximGotovchits/Parallel/base/commands/ShowTables.java index fccfd937d..bb94a7f46 100644 --- a/src/ru/fizteh/fivt/students/MaximGotovchits/Parallel/base/commands/ShowTables.java +++ b/src/ru/fizteh/fivt/students/MaximGotovchits/Parallel/base/commands/ShowTables.java @@ -11,7 +11,6 @@ public class ShowTables extends Command { @Override public boolean execute(String[] cmd) { if (cmd.length == 2) { - List list = new ObjectTableProvider().getTableNames(); String currentFile; int recordsAmount; File file = new File(CommandTools.DATA_BASE_NAME); diff --git a/src/ru/fizteh/fivt/students/MaximGotovchits/Parallel/base/commands/Use.java b/src/ru/fizteh/fivt/students/MaximGotovchits/Parallel/base/commands/Use.java index c40d788d0..844627ccc 100644 --- a/src/ru/fizteh/fivt/students/MaximGotovchits/Parallel/base/commands/Use.java +++ b/src/ru/fizteh/fivt/students/MaximGotovchits/Parallel/base/commands/Use.java @@ -15,15 +15,21 @@ public String getCmdName() { } @Override - public boolean execute(String[] cmd) throws Exception { + public boolean execute(String[] cmd) { if (cmd.length == 2) { - useFunction(cmd[1], CommandTools.usingTableName); + try { + useFunction(cmd[1], CommandTools.usingTableName); + } catch (IOException e) { + System.err.println(e); + } catch (ParseException e) { + System.err.println(e); + } return true; } return false; } - public boolean useFunction(String tableName, String oldTableName) throws Exception { + public boolean useFunction(String tableName, String oldTableName) throws IOException, ParseException { if (!tableName.equals(oldTableName)) { String outputName = tableName; String tablePath = CommandTools.DATA_BASE_NAME + File.separator + tableName; diff --git a/src/ru/fizteh/fivt/students/MaximGotovchits/Parallel/interpreter/Command.java b/src/ru/fizteh/fivt/students/MaximGotovchits/Parallel/interpreter/Command.java index 990d18890..f9e2d9f0f 100644 --- a/src/ru/fizteh/fivt/students/MaximGotovchits/Parallel/interpreter/Command.java +++ b/src/ru/fizteh/fivt/students/MaximGotovchits/Parallel/interpreter/Command.java @@ -1,9 +1,7 @@ package ru.fizteh.fivt.students.MaximGotovchits.Parallel.interpreter; -import ru.fizteh.fivt.students.MaximGotovchits.Parallel.base.commands.*; - public abstract class Command { public abstract String getCmdName(); - public abstract boolean execute(String[] cmd) throws Exception; + public abstract boolean execute(String[] cmd); } diff --git a/src/ru/fizteh/fivt/students/MaximGotovchits/Parallel/interpreter/Interpreter.java b/src/ru/fizteh/fivt/students/MaximGotovchits/Parallel/interpreter/Interpreter.java index fc4910af9..4fc07a2ac 100644 --- a/src/ru/fizteh/fivt/students/MaximGotovchits/Parallel/interpreter/Interpreter.java +++ b/src/ru/fizteh/fivt/students/MaximGotovchits/Parallel/interpreter/Interpreter.java @@ -5,9 +5,11 @@ public class Interpreter { private static final String SPLIT_BY_SEMICOLON = "\\s*;\\s*"; + private static final String SECRET_TEST_WORD = "extremely_secret_word_for_test"; private static final String INVITATIONAL_SYMBOL = "$ "; private static final String SPLIT_BY_SPACE = "\\s+"; private Map commands = new HashMap<>(); + public Scanner scan = new Scanner(System.in); public Interpreter(Set commandSet) { for (Command cmd: commandSet) { @@ -15,8 +17,7 @@ public Interpreter(Set commandSet) { } } - public void startUp(String cmdLine, boolean isFromCmdLine) throws Exception { - boolean correctCmdName = false; + public void startUp(String cmdLine, boolean isFromCmdLine) { if (isFromCmdLine) { // Batch mode. String[] splittedLine = cmdLine.split(SPLIT_BY_SEMICOLON); for (String line : splittedLine) { @@ -25,16 +26,17 @@ public void startUp(String cmdLine, boolean isFromCmdLine) throws Exception { } } else { // Interactive mode. while (true) { - Scanner scan = new Scanner(System.in); System.out.print(INVITATIONAL_SYMBOL); String[] cmd = scan.nextLine().split(SPLIT_BY_SPACE); + if (cmd[0].equals(SECRET_TEST_WORD)) { + break; + } parseStep(commands, cmd, isFromCmdLine); } - } } - private void parseStep(Map commands, String[] cmd, boolean isFromCmdLine) throws Exception { + private void parseStep(Map commands, String[] cmd, boolean isFromCmdLine) { boolean correctCmdName = false; for (Map.Entry entry : commands.entrySet()) { String key = entry.getKey(); @@ -46,7 +48,7 @@ private void parseStep(Map commands, String[] cmd, boolean isFr } } if (!correctCmdName) { - if (isFromCmdLine) { + if (!isFromCmdLine) { System.err.println("no such command, try again..."); } else { String[] exit = new String[1]; @@ -54,6 +56,5 @@ private void parseStep(Map commands, String[] cmd, boolean isFr new Exit().execute(exit); } } - //correctCmdName = false; } } diff --git a/src/ru/fizteh/fivt/students/MaximGotovchits/Parallel/objects/ObjectTable.java b/src/ru/fizteh/fivt/students/MaximGotovchits/Parallel/objects/ObjectTable.java index dcce68322..4660329c9 100644 --- a/src/ru/fizteh/fivt/students/MaximGotovchits/Parallel/objects/ObjectTable.java +++ b/src/ru/fizteh/fivt/students/MaximGotovchits/Parallel/objects/ObjectTable.java @@ -13,9 +13,6 @@ public class ObjectTable implements Table { static int overwriteNum = 0; - private static final String JSON_REG_EX = "\\s*,\\s*(?=(?:(?:[^\"]*\"){2})*[^\"]*$)"; // Removes commas - // outside of "...". - public static String usingTableName = new String(); // OR public static String usingTableName; private static final String DATA_BASE_NAME = System.getProperty("fizteh.db.dir"); private static final String SIGNATURE_FILENAME = "signature.tsv"; @@ -29,7 +26,7 @@ protected Stack initialValue() { public ThreadLocal> storage = new ThreadLocal>() { @Override protected HashMap initialValue() { - return new HashMap(); + return new HashMap<>(); } }; @@ -50,7 +47,7 @@ public ObjectTable(String name) { name = DATA_BASE_NAME + File.separator + name; } this.tableName = new File(name).getName(); - String content = new String(); + String content; try { if (!new File(name + File.separator + SIGNATURE_FILENAME).isAbsolute()) { name = DATA_BASE_NAME + File.separator + name; diff --git a/src/ru/fizteh/fivt/students/MaximGotovchits/Parallel/objects/ObjectTableProvider.java b/src/ru/fizteh/fivt/students/MaximGotovchits/Parallel/objects/ObjectTableProvider.java index fdd4faa0d..5a7629add 100644 --- a/src/ru/fizteh/fivt/students/MaximGotovchits/Parallel/objects/ObjectTableProvider.java +++ b/src/ru/fizteh/fivt/students/MaximGotovchits/Parallel/objects/ObjectTableProvider.java @@ -129,7 +129,7 @@ public Storeable deserialize(Table table, String value) throws ParseException { int index = 0; List> typeList = new LinkedList<>(); for (String str : tempValue) { - Object val = getValue(str/*, usingTable*/, usingTable.typeKeeper.get(index)); + Object val = getValue(str, usingTable.typeKeeper.get(index)); if (val.equals(INCORRECT_SYMBOL)) { throw new ParseException(value, 0); } diff --git a/src/ru/fizteh/fivt/students/MaximGotovchits/Parallel/test/InterpreterTest/BatchModeTest.java b/src/ru/fizteh/fivt/students/MaximGotovchits/Parallel/test/InterpreterTest/BatchModeTest.java new file mode 100644 index 000000000..bf8c4d4ae --- /dev/null +++ b/src/ru/fizteh/fivt/students/MaximGotovchits/Parallel/test/InterpreterTest/BatchModeTest.java @@ -0,0 +1,59 @@ +package ru.fizteh.fivt.students.MaximGotovchits.Parallel.test.InterpreterTest; + +import org.junit.After; +import org.junit.Before; +import org.junit.Test; +import ru.fizteh.fivt.students.MaximGotovchits.Parallel.base.commands.*; +import ru.fizteh.fivt.students.MaximGotovchits.Parallel.base.commands.List; +import ru.fizteh.fivt.students.MaximGotovchits.Parallel.interpreter.*; +import ru.fizteh.fivt.students.MaximGotovchits.Parallel.objects.*; + +import java.io.ByteArrayOutputStream; +import java.io.IOException; +import java.io.PrintStream; +import java.util.*; + +public class BatchModeTest { + private final ByteArrayOutputStream outContent = new ByteArrayOutputStream(); + private final ByteArrayOutputStream errContent = new ByteArrayOutputStream(); + private Set commandSet; + private Interpreter interpreter; + private ObjectTableProvider testTableProvider = new ObjectTableProvider(); + private static final String TEST_TABLE_NAME = "test_table"; + + @Before + public void setUpStreams() throws IOException { + commandSet = new HashSet<>(); + commandSet.add(new Commit()); + commandSet.add(new Create()); + commandSet.add(new Drop()); + commandSet.add(new Exit()); + commandSet.add(new FillTable()); + commandSet.add(new Get()); + commandSet.add(new List()); + commandSet.add(new MakeDirs()); + commandSet.add(new Put()); + commandSet.add(new Remove()); + commandSet.add(new Rollback()); + commandSet.add(new ShowTables()); + commandSet.add(new Use()); + interpreter = new Interpreter(commandSet); + System.setOut(new PrintStream(outContent)); + System.setErr(new PrintStream(errContent)); + java.util.List> types = new LinkedList<>(); + types.add(int.class); + testTableProvider.createTable(TEST_TABLE_NAME, types); + } + + @Test + public void useTest() { + + } + + @After + public void cleanUpStreams() { + System.setOut(null); + System.setErr(null); + testTableProvider.removeTable(TEST_TABLE_NAME); + } +} diff --git a/src/ru/fizteh/fivt/students/MaximGotovchits/Parallel/test/InterpreterTest/InteractiveModeTest.java b/src/ru/fizteh/fivt/students/MaximGotovchits/Parallel/test/InterpreterTest/InteractiveModeTest.java new file mode 100644 index 000000000..7d48985a8 --- /dev/null +++ b/src/ru/fizteh/fivt/students/MaximGotovchits/Parallel/test/InterpreterTest/InteractiveModeTest.java @@ -0,0 +1,161 @@ +package ru.fizteh.fivt.students.MaximGotovchits.Parallel.test.InterpreterTest; + +import org.junit.After; +import org.junit.Before; +import org.junit.Test; +import ru.fizteh.fivt.students.MaximGotovchits.Parallel.base.commands.*; +import ru.fizteh.fivt.students.MaximGotovchits.Parallel.base.commands.List; +import ru.fizteh.fivt.students.MaximGotovchits.Parallel.interpreter.*; +import ru.fizteh.fivt.students.MaximGotovchits.Parallel.objects.*; + +import java.io.ByteArrayInputStream; +import java.io.ByteArrayOutputStream; +import java.io.IOException; +import java.io.PrintStream; +import java.util.*; + +import static org.junit.Assert.assertEquals; + +public class InteractiveModeTest { + private final ByteArrayOutputStream outContent = new ByteArrayOutputStream(); + private final ByteArrayOutputStream errContent = new ByteArrayOutputStream(); + private Set commandSet; + private Interpreter interpreter; + private ObjectTableProvider testTableProvider = new ObjectTableProvider(); + private static final String TEST_TABLE_NAME = "test_table"; + + @Before + public void setUpStreams() throws IOException { + commandSet = new HashSet<>(); + commandSet.add(new Commit()); + commandSet.add(new Create()); + commandSet.add(new Drop()); + commandSet.add(new Exit()); + commandSet.add(new FillTable()); + commandSet.add(new Get()); + commandSet.add(new List()); + commandSet.add(new MakeDirs()); + commandSet.add(new Put()); + commandSet.add(new Remove()); + commandSet.add(new Rollback()); + commandSet.add(new ShowTables()); + commandSet.add(new Use()); + interpreter = new Interpreter(commandSet); + System.setOut(new PrintStream(outContent)); + System.setErr(new PrintStream(errContent)); + java.util.List> types = new LinkedList<>(); + types.add(int.class); + testTableProvider.createTable(TEST_TABLE_NAME, types); + } + + @Test + public void dollarBillTest() { + ByteArrayInputStream in = new ByteArrayInputStream("extremely_secret_word_for_test".getBytes()); + interpreter.scan = new Scanner(in); + interpreter.startUp(null, false); + assertEquals("$ ", outContent.toString()); + } + + @Test + public void createAndDropTableTest() { + ByteArrayInputStream in = new ByteArrayInputStream(("create " + TEST_TABLE_NAME + " (int)\n" + + "extremely_secret_word_for_test").getBytes()); + interpreter.scan = new Scanner(in); + interpreter.startUp(null, false); + assertEquals("$ " + TEST_TABLE_NAME + " exists\n$ ", outContent.toString()); + in = new ByteArrayInputStream(("create to_be_dropped (long)\n" + + "extremely_secret_word_for_test").getBytes()); + interpreter.scan = new Scanner(in); + interpreter.startUp(null, false); + assertEquals("$ " + TEST_TABLE_NAME + " exists\n$ $ created\n$ ", outContent.toString()); + in = new ByteArrayInputStream(("drop to_be_dropped\nextremely_secret_word_for_test").getBytes()); + interpreter.scan = new Scanner(in); + interpreter.startUp(null, false); + assertEquals("$ " + TEST_TABLE_NAME + " exists\n$ $ created\n$ $ dropped\n$ ", outContent.toString()); + } + + @Test + public void putAndGetTest() { + ByteArrayInputStream in = new ByteArrayInputStream(("use " + TEST_TABLE_NAME + "\nput K [100500]\n" + + "extremely_secret_word_for_test").getBytes()); + interpreter.scan = new Scanner(in); + interpreter.startUp(null, false); + assertEquals("$ using " + TEST_TABLE_NAME + "\n$ new\n$ ", outContent.toString()); + in = new ByteArrayInputStream(("get K\nextremely_secret_word_for_test").getBytes()); + interpreter.scan = new Scanner(in); + interpreter.startUp(null, false); + assertEquals("$ using " + TEST_TABLE_NAME + "\n$ new\n$ $ found\n[100500]\n$ ", outContent.toString()); + } + + @Test + public void listTest() { + ByteArrayInputStream in = new ByteArrayInputStream(("use " + TEST_TABLE_NAME + "\nput K [100500]\nlist\n" + + "extremely_secret_word_for_test").getBytes()); + interpreter.scan = new Scanner(in); + interpreter.startUp(null, false); + assertEquals("$ using " + TEST_TABLE_NAME + "\n$ new\n$ K\n$ ", outContent.toString()); + } + + @Test + public void removeTest() { + ByteArrayInputStream in = new ByteArrayInputStream(("use " + TEST_TABLE_NAME + "\nput K [100500]\n" + + "remove K\nextremely_secret_word_for_test").getBytes()); + interpreter.scan = new Scanner(in); + interpreter.startUp(null, false); + assertEquals("$ using " + TEST_TABLE_NAME + "\n$ new\n$ removed\n$ ", outContent.toString()); + in = new ByteArrayInputStream(("remove K\nextremely_secret_word_for_test").getBytes()); + interpreter.scan = new Scanner(in); + interpreter.startUp(null, false); + assertEquals("$ using " + TEST_TABLE_NAME + "\n$ new\n$ removed\n$ $ not found\n$ ", outContent.toString()); + } + + @Test + public void rollbackTest() { + ByteArrayInputStream in = new ByteArrayInputStream(("use " + TEST_TABLE_NAME + "\nput K [10050]\n" + + "rollback\nextremely_secret_word_for_test").getBytes()); + interpreter.scan = new Scanner(in); + interpreter.startUp(null, false); + assertEquals("$ using " + TEST_TABLE_NAME + "\n$ new\n$ $ ", outContent.toString()); + } + + @Test + public void showTablesTest() { // Use empty dir. + ByteArrayInputStream in = new ByteArrayInputStream(("use " + TEST_TABLE_NAME + + "\nshow tables\nextremely_secret_word_for_test").getBytes()); + interpreter.scan = new Scanner(in); + interpreter.startUp(null, false); + assertEquals("$ using " + TEST_TABLE_NAME + "\n$ " + TEST_TABLE_NAME + " 0\n$ ", outContent.toString()); + } + + @Test + public void useTest() { + ByteArrayInputStream in = new ByteArrayInputStream(("use " + TEST_TABLE_NAME + + "\nextremely_secret_word_for_test").getBytes()); + interpreter.scan = new Scanner(in); + interpreter.startUp(null, false); + assertEquals("$ using " + TEST_TABLE_NAME + "\n$ ", outContent.toString()); + } + + @Test + public void incorrectCmdTest() { + ByteArrayInputStream in = new ByteArrayInputStream(("bugaga\nextremely_secret_word_for_test").getBytes()); + interpreter.scan = new Scanner(in); + interpreter.startUp(null, false); + assertEquals("no such command, try again...\n", errContent.toString()); + } + + @Test + public void incorrectPutTest() { + ByteArrayInputStream in = new ByteArrayInputStream(("bugaga\nextremely_secret_word_for_test").getBytes()); + interpreter.scan = new Scanner(in); + interpreter.startUp(null, false); + assertEquals("no such command, try again...\n", errContent.toString()); + } + + @After + public void cleanUpStreams() { + System.setOut(null); + System.setErr(null); + testTableProvider.removeTable(TEST_TABLE_NAME); + } +} From 0e7eae8d1bb27480839b8b050e351a4d4e66a7ae Mon Sep 17 00:00:00 2001 From: MaximGotovchits Date: Fri, 20 Mar 2015 20:39:25 +0300 Subject: [PATCH 16/18] =?UTF-8?q?=D0=93=D0=BE=D1=82=D0=BE=D0=B2=D1=87?= =?UTF-8?q?=D0=B8=D1=86=20=D0=9C=D0=B0=D0=BA=D1=81=D0=B8=D0=BC,=20Parallel?= =?UTF-8?q?,=20396?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit fixed check style and other things. --- .../Parallel/base/commands/ShowTables.java | 2 -- .../MaximGotovchits/Parallel/objects/ObjectTable.java | 6 +++--- .../Parallel/test/ObjectStoreableTest.java | 10 +++++----- .../Parallel/test/ObjectTableProviderTest.java | 8 ++++---- .../MaximGotovchits/Parallel/test/ObjectTableTest.java | 9 ++++----- 5 files changed, 16 insertions(+), 19 deletions(-) diff --git a/src/ru/fizteh/fivt/students/MaximGotovchits/Parallel/base/commands/ShowTables.java b/src/ru/fizteh/fivt/students/MaximGotovchits/Parallel/base/commands/ShowTables.java index bb94a7f46..9cb1a474e 100644 --- a/src/ru/fizteh/fivt/students/MaximGotovchits/Parallel/base/commands/ShowTables.java +++ b/src/ru/fizteh/fivt/students/MaximGotovchits/Parallel/base/commands/ShowTables.java @@ -1,11 +1,9 @@ package ru.fizteh.fivt.students.MaximGotovchits.Parallel.base.commands; import ru.fizteh.fivt.students.MaximGotovchits.Parallel.interpreter.Command; -import ru.fizteh.fivt.students.MaximGotovchits.Parallel.objects.ObjectTableProvider; import java.io.*; import java.nio.charset.StandardCharsets; -import java.util.List; public class ShowTables extends Command { @Override diff --git a/src/ru/fizteh/fivt/students/MaximGotovchits/Parallel/objects/ObjectTable.java b/src/ru/fizteh/fivt/students/MaximGotovchits/Parallel/objects/ObjectTable.java index 4660329c9..e68487529 100644 --- a/src/ru/fizteh/fivt/students/MaximGotovchits/Parallel/objects/ObjectTable.java +++ b/src/ru/fizteh/fivt/students/MaximGotovchits/Parallel/objects/ObjectTable.java @@ -12,7 +12,7 @@ import java.util.*; public class ObjectTable implements Table { - static int overwriteNum = 0; + private static int overwriteNum = 0; private static final String DATA_BASE_NAME = System.getProperty("fizteh.db.dir"); private static final String SIGNATURE_FILENAME = "signature.tsv"; @@ -31,7 +31,7 @@ protected HashMap initialValue() { }; public Map commitStorage = new HashMap<>(); - public String tableName = new String(); + private String tableName = new String(); public List> typeKeeper = new LinkedList>(); public ObjectTable() { } @@ -201,7 +201,7 @@ public Class getColumnType(int columnIndex) throws IndexOutOfBoundsException return objectToReturn; } - static String readFile(String path, Charset encoding) throws IOException { + private static String readFile(String path, Charset encoding) throws IOException { byte[] encoded = Files.readAllBytes(Paths.get(path)); String temp = new String(encoded, encoding); return temp.replaceAll("^\\s*|\\s*$", ""); diff --git a/src/ru/fizteh/fivt/students/MaximGotovchits/Parallel/test/ObjectStoreableTest.java b/src/ru/fizteh/fivt/students/MaximGotovchits/Parallel/test/ObjectStoreableTest.java index bac46e455..1b0871b33 100644 --- a/src/ru/fizteh/fivt/students/MaximGotovchits/Parallel/test/ObjectStoreableTest.java +++ b/src/ru/fizteh/fivt/students/MaximGotovchits/Parallel/test/ObjectStoreableTest.java @@ -14,12 +14,12 @@ import static org.junit.Assert.assertNotSame; public class ObjectStoreableTest { - public String name; - public List> columnTypes = new LinkedList>(); - public ObjectStoreable deserializedValue = new ObjectStoreable(); + private String name; + private List> columnTypes = new LinkedList>(); + private ObjectStoreable deserializedValue = new ObjectStoreable(); public ObjectTable table; - public String valueToDeserialize; - public ObjectTable tempTable; + private String valueToDeserialize; + private ObjectTable tempTable; @Before public void initialization() throws IOException { diff --git a/src/ru/fizteh/fivt/students/MaximGotovchits/Parallel/test/ObjectTableProviderTest.java b/src/ru/fizteh/fivt/students/MaximGotovchits/Parallel/test/ObjectTableProviderTest.java index ebcb83b40..3189ffe9c 100644 --- a/src/ru/fizteh/fivt/students/MaximGotovchits/Parallel/test/ObjectTableProviderTest.java +++ b/src/ru/fizteh/fivt/students/MaximGotovchits/Parallel/test/ObjectTableProviderTest.java @@ -13,10 +13,10 @@ import java.util.List; public class ObjectTableProviderTest extends ObjectTableProvider { - public String name; - public List> columnTypes = new LinkedList>(); - public ObjectStoreable deserializedValue = new ObjectStoreable(); - public ObjectTable testTable; + private String name; + private List> columnTypes = new LinkedList>(); + private ObjectStoreable deserializedValue = new ObjectStoreable(); + private ObjectTable testTable; @Before public void initialization() throws IOException { name = "TestTable"; diff --git a/src/ru/fizteh/fivt/students/MaximGotovchits/Parallel/test/ObjectTableTest.java b/src/ru/fizteh/fivt/students/MaximGotovchits/Parallel/test/ObjectTableTest.java index d15a856e9..3bf9f294d 100644 --- a/src/ru/fizteh/fivt/students/MaximGotovchits/Parallel/test/ObjectTableTest.java +++ b/src/ru/fizteh/fivt/students/MaximGotovchits/Parallel/test/ObjectTableTest.java @@ -5,7 +5,6 @@ import static org.junit.Assert.assertTrue; import org.junit.*; -import org.junit.Test; import ru.fizteh.fivt.students.MaximGotovchits.Parallel.base.commands.Use; import ru.fizteh.fivt.students.MaximGotovchits.Parallel.objects.ObjectStoreable; import ru.fizteh.fivt.students.MaximGotovchits.Parallel.objects.ObjectTable; @@ -16,10 +15,10 @@ import java.util.List; public class ObjectTableTest { - public String name; - public List> columnTypes = new LinkedList>(); - public ObjectStoreable deserializedValue = new ObjectStoreable(); - public ObjectTable testTable; + private String name; + private List> columnTypes = new LinkedList>(); + private ObjectStoreable deserializedValue = new ObjectStoreable(); + private ObjectTable testTable; @Before public void initialization() throws IOException { From 3138e1829e89f3e345404b102b9e40cba794dcc8 Mon Sep 17 00:00:00 2001 From: MaximGotovchits Date: Fri, 20 Mar 2015 22:12:48 +0300 Subject: [PATCH 17/18] =?UTF-8?q?=D0=93=D0=BE=D1=82=D0=BE=D0=B2=D1=87?= =?UTF-8?q?=D0=B8=D1=86=20=D0=9C=D0=B0=D0=BA=D1=81=D0=B8=D0=BC,=20396,=20P?= =?UTF-8?q?arallel?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit batch mode tests are added --- .../test/InterpreterTest/BatchModeTest.java | 106 ++++++++++++++++++ .../test/ObjectTableProviderTest.java | 2 +- 2 files changed, 107 insertions(+), 1 deletion(-) diff --git a/src/ru/fizteh/fivt/students/MaximGotovchits/Parallel/test/InterpreterTest/BatchModeTest.java b/src/ru/fizteh/fivt/students/MaximGotovchits/Parallel/test/InterpreterTest/BatchModeTest.java index bf8c4d4ae..74923d286 100644 --- a/src/ru/fizteh/fivt/students/MaximGotovchits/Parallel/test/InterpreterTest/BatchModeTest.java +++ b/src/ru/fizteh/fivt/students/MaximGotovchits/Parallel/test/InterpreterTest/BatchModeTest.java @@ -13,6 +13,9 @@ import java.io.PrintStream; import java.util.*; +import static org.junit.Assert.assertFalse; +import static org.junit.Assert.assertTrue; + public class BatchModeTest { private final ByteArrayOutputStream outContent = new ByteArrayOutputStream(); private final ByteArrayOutputStream errContent = new ByteArrayOutputStream(); @@ -47,7 +50,110 @@ public void setUpStreams() throws IOException { @Test public void useTest() { + String[] cmd = {"use", TEST_TABLE_NAME}; + assertTrue(new Use().execute(cmd)); + } + + @Test + public void useErrTest() { + String[] cmd = {"bugaga"}; + assertFalse(new Use().execute(cmd)); + } + + @Test + public void showTablesTest() { + String[] cmd = {"show", "tables"}; + assertTrue(new ShowTables().execute(cmd)); + } + + @Test + public void showTablesErrTest() { + String[] cmd = {"bugaga"}; + assertFalse(new ShowTables().execute(cmd)); + } + + @Test + public void rollbackTest() { + String[] cmd = {"rollback"}; + assertTrue(new Rollback().execute(cmd)); + } + + @Test + public void rollbackErrTest() { + String[] cmd = {"bugaga", "fail"}; + assertFalse(new Rollback().execute(cmd)); + } + + @Test + public void removeTest() { + String[] cmd = {"remove", "not_existing_table"}; + assertTrue(new Remove().execute(cmd)); + } + + @Test + public void removeErrTest() { + String[] cmd = {"bugaga"}; + assertFalse(new Remove().execute(cmd)); + } + + @Test + public void putTest() { + String[] cmd = {"put", "K", "[100]"}; + assertTrue(new Put().execute(cmd)); + } + @Test + public void putErrTest() { + String[] cmd = {"bugaga"}; + assertFalse(new Put().execute(cmd)); + } + + @Test + public void listTest() { + String[] cmd = {"list"}; + assertTrue(new List().execute(cmd)); + } + + @Test + public void listErrTest() { + String[] cmd = {"bugaga", "fail"}; + assertFalse(new List().execute(cmd)); + } + + @Test + public void dropTest() { + String[] cmd = {"drop", "something"}; + assertTrue(new Drop().execute(cmd)); + } + + @Test + public void dropErrTest() { + String[] cmd = {"bugaga"}; + assertFalse(new Drop().execute(cmd)); + } + + @Test + public void createTest() { + String[] cmd = {"create", "something", "(int)"}; + assertTrue(new Create().execute(cmd)); + } + + @Test + public void createErrTest() { + String[] cmd = {"bugaga"}; + assertFalse(new Create().execute(cmd)); + } + + @Test + public void commitTest() { + String[] cmd = {"commit"}; + assertTrue(new Commit().execute(cmd)); + } + + @Test + public void commitErrTest() { + String[] cmd = {"bugaga", "fail"}; + assertFalse(new Commit().execute(cmd)); } @After diff --git a/src/ru/fizteh/fivt/students/MaximGotovchits/Parallel/test/ObjectTableProviderTest.java b/src/ru/fizteh/fivt/students/MaximGotovchits/Parallel/test/ObjectTableProviderTest.java index 3189ffe9c..94e2f1a51 100644 --- a/src/ru/fizteh/fivt/students/MaximGotovchits/Parallel/test/ObjectTableProviderTest.java +++ b/src/ru/fizteh/fivt/students/MaximGotovchits/Parallel/test/ObjectTableProviderTest.java @@ -14,7 +14,7 @@ public class ObjectTableProviderTest extends ObjectTableProvider { private String name; - private List> columnTypes = new LinkedList>(); + private List> columnTypes = new LinkedList<>(); private ObjectStoreable deserializedValue = new ObjectStoreable(); private ObjectTable testTable; @Before From 10616cf6745cad5f9fec6fdf9f99a798ef5316eb Mon Sep 17 00:00:00 2001 From: MaximGotovchits Date: Sat, 21 Mar 2015 21:36:21 +0300 Subject: [PATCH 18/18] =?UTF-8?q?=D0=93=D0=BE=D1=82=D0=BE=D0=B2=D1=87?= =?UTF-8?q?=D0=B8=D1=86=20=D0=9C=D0=B0=D0=BA=D1=81=D0=B8=D0=BC,=20396,=20P?= =?UTF-8?q?arallel?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- .../MaximGotovchits/Parallel/base/Main.java | 5 +- .../Parallel/base/commands/CommandTools.java | 12 + .../Parallel/base/commands/Commit.java | 4 +- .../Parallel/base/commands/Create.java | 12 +- .../Parallel/base/commands/Drop.java | 2 +- .../Parallel/base/commands/Get.java | 2 +- .../Parallel/base/commands/List.java | 2 +- .../Parallel/base/commands/Put.java | 2 +- .../Parallel/base/commands/Remove.java | 2 +- .../Parallel/base/commands/Rollback.java | 2 +- .../Parallel/base/commands/ShowTables.java | 2 +- .../Parallel/base/commands/Use.java | 7 +- .../Parallel/objects/Change.java | 8 + .../Parallel/objects/ObjectStoreable.java | 158 +++++++- .../Parallel/objects/ObjectTable.java | 264 +++++++++++-- .../Parallel/objects/ObjectTableProvider.java | 357 +++++++++++++++++- .../objects/ObjectTableProviderFactory.java | 26 ++ .../Parallel/objects/PutChange.java | 16 + .../Parallel/objects/RemoveChange.java | 13 + .../InterpreterTest/InteractiveModeTest.java | 5 +- .../Parallel/test/ObjectTableTest.java | 21 +- 21 files changed, 842 insertions(+), 80 deletions(-) create mode 100644 src/ru/fizteh/fivt/students/MaximGotovchits/Parallel/objects/Change.java create mode 100644 src/ru/fizteh/fivt/students/MaximGotovchits/Parallel/objects/PutChange.java create mode 100644 src/ru/fizteh/fivt/students/MaximGotovchits/Parallel/objects/RemoveChange.java diff --git a/src/ru/fizteh/fivt/students/MaximGotovchits/Parallel/base/Main.java b/src/ru/fizteh/fivt/students/MaximGotovchits/Parallel/base/Main.java index 220ef7206..baecbdc57 100644 --- a/src/ru/fizteh/fivt/students/MaximGotovchits/Parallel/base/Main.java +++ b/src/ru/fizteh/fivt/students/MaximGotovchits/Parallel/base/Main.java @@ -22,10 +22,7 @@ public static void main(final String[] args) throws Exception { fromCmdLine = true; fillCommandSet(commandSet, currentTableObject, fromCmdLine); Interpreter interpreter = new Interpreter(commandSet); - String cmd = new String(); - for (String arg : args) { - cmd = cmd.join(" ", cmd, arg); - } + String cmd = String.join(" ", args); cmd = cmd.replaceAll("\\s+", " "); System.out.println(cmd); interpreter.startUp(cmd, fromCmdLine); diff --git a/src/ru/fizteh/fivt/students/MaximGotovchits/Parallel/base/commands/CommandTools.java b/src/ru/fizteh/fivt/students/MaximGotovchits/Parallel/base/commands/CommandTools.java index 629c851d8..cd8ebe6c2 100644 --- a/src/ru/fizteh/fivt/students/MaximGotovchits/Parallel/base/commands/CommandTools.java +++ b/src/ru/fizteh/fivt/students/MaximGotovchits/Parallel/base/commands/CommandTools.java @@ -2,6 +2,9 @@ import ru.fizteh.fivt.students.MaximGotovchits.Parallel.objects.ObjectTable; +import java.nio.charset.Charset; +import java.nio.charset.StandardCharsets; + public class CommandTools { protected static final String DATA_BASE_NAME = System.getProperty("fizteh.db.dir"); static boolean tableIsChosen = false; @@ -10,8 +13,17 @@ public class CommandTools { static final String DIR_EXT = ".dir"; static final String FILE_EXT = ".dat"; static String usingTableName; + public static final Charset UTF = StandardCharsets.UTF_8; static ObjectTable currentTable; public static void informToChooseTable() { System.err.println("table is not chosen"); } + + public static boolean amountOfArgumentsIs(int argsAmount, String[] cmd) { + return argsAmount == cmd.length; + } + + public static boolean amountOfArgumentsIsMoreThan(int argsAmount, String[] cmd) { + return argsAmount < cmd.length; + } } diff --git a/src/ru/fizteh/fivt/students/MaximGotovchits/Parallel/base/commands/Commit.java b/src/ru/fizteh/fivt/students/MaximGotovchits/Parallel/base/commands/Commit.java index b9488a1aa..2b91c7451 100644 --- a/src/ru/fizteh/fivt/students/MaximGotovchits/Parallel/base/commands/Commit.java +++ b/src/ru/fizteh/fivt/students/MaximGotovchits/Parallel/base/commands/Commit.java @@ -3,10 +3,10 @@ import ru.fizteh.fivt.students.MaximGotovchits.Parallel.interpreter.Command; public class Commit extends Command { - public Commit() {} + @Override public boolean execute(String[] cmd) { - if (cmd.length == 1) { + if (CommandTools.amountOfArgumentsIs(1, cmd)) { CommandTools.currentTable.commit(); return true; } diff --git a/src/ru/fizteh/fivt/students/MaximGotovchits/Parallel/base/commands/Create.java b/src/ru/fizteh/fivt/students/MaximGotovchits/Parallel/base/commands/Create.java index 1460e109d..9beaeeebb 100644 --- a/src/ru/fizteh/fivt/students/MaximGotovchits/Parallel/base/commands/Create.java +++ b/src/ru/fizteh/fivt/students/MaximGotovchits/Parallel/base/commands/Create.java @@ -5,6 +5,7 @@ import ru.fizteh.fivt.students.MaximGotovchits.Parallel.objects.ObjectTableProvider; import java.io.IOException; +import java.util.Arrays; import java.util.LinkedList; import java.util.List; @@ -20,13 +21,10 @@ public String getCmdName() { @Override public boolean execute(String[] cmd) { - if (cmd.length > 2) { - String createParameter = new String(); // (...) - type list. + if (CommandTools.amountOfArgumentsIsMoreThan(2, cmd)) { + String createParameter; // (...) - type list. String tableName = cmd[1]; - for (int ind = 2; ind < cmd.length; ++ind) { - createParameter += cmd[ind] + " "; - } - createParameter = createParameter.substring(0, createParameter.length() - 1); + createParameter = String.join(" ", Arrays.copyOfRange(cmd, 2, cmd.length)); List> typeList; try { typeList = getTypeList(createParameter); @@ -51,7 +49,7 @@ public boolean execute(String[] cmd) { public List> getTypeList(String line) { ObjectTable temp = new ObjectTable(); - List> typeList = new LinkedList>(); + List> typeList = new LinkedList<>(); line = line.replaceAll(SPLIT_BY_RIGHT_BRACKET, ""); line = line.replaceAll(SPLIT_BY_LEFT_BRACKET, ""); String[] tmp = line.split(SPLIT_BY_SPACE); diff --git a/src/ru/fizteh/fivt/students/MaximGotovchits/Parallel/base/commands/Drop.java b/src/ru/fizteh/fivt/students/MaximGotovchits/Parallel/base/commands/Drop.java index 41f73de0d..4c4e4810d 100644 --- a/src/ru/fizteh/fivt/students/MaximGotovchits/Parallel/base/commands/Drop.java +++ b/src/ru/fizteh/fivt/students/MaximGotovchits/Parallel/base/commands/Drop.java @@ -6,7 +6,7 @@ public class Drop extends Command { @Override public boolean execute(String[] cmd) { - if (cmd.length == 2) { + if (CommandTools.amountOfArgumentsIs(2, cmd)) { try { new ObjectTableProvider().removeTable(cmd[1]); System.out.println("dropped"); diff --git a/src/ru/fizteh/fivt/students/MaximGotovchits/Parallel/base/commands/Get.java b/src/ru/fizteh/fivt/students/MaximGotovchits/Parallel/base/commands/Get.java index be9875443..5beb3e1a4 100644 --- a/src/ru/fizteh/fivt/students/MaximGotovchits/Parallel/base/commands/Get.java +++ b/src/ru/fizteh/fivt/students/MaximGotovchits/Parallel/base/commands/Get.java @@ -6,7 +6,7 @@ public class Get extends Command { @Override public boolean execute(String[] cmd) { - if (cmd.length == 2) { + if (CommandTools.amountOfArgumentsIs(2, cmd)) { try { if (CommandTools.tableIsChosen) { ObjectStoreable temp = (ObjectStoreable) CommandTools.currentTable.get(cmd[1]); diff --git a/src/ru/fizteh/fivt/students/MaximGotovchits/Parallel/base/commands/List.java b/src/ru/fizteh/fivt/students/MaximGotovchits/Parallel/base/commands/List.java index 8ce19b62c..5616200ae 100644 --- a/src/ru/fizteh/fivt/students/MaximGotovchits/Parallel/base/commands/List.java +++ b/src/ru/fizteh/fivt/students/MaximGotovchits/Parallel/base/commands/List.java @@ -5,7 +5,7 @@ public class List extends Command { @Override public boolean execute(String[] cmd) { - if (cmd.length == 1) { + if (CommandTools.amountOfArgumentsIs(1, cmd)) { if (CommandTools.tableIsChosen) { java.util.List list = CommandTools.currentTable.list(); int size = 0; diff --git a/src/ru/fizteh/fivt/students/MaximGotovchits/Parallel/base/commands/Put.java b/src/ru/fizteh/fivt/students/MaximGotovchits/Parallel/base/commands/Put.java index 146984556..52a478ed1 100644 --- a/src/ru/fizteh/fivt/students/MaximGotovchits/Parallel/base/commands/Put.java +++ b/src/ru/fizteh/fivt/students/MaximGotovchits/Parallel/base/commands/Put.java @@ -6,7 +6,7 @@ public class Put extends Command { public boolean execute(String[] cmd) { - if (cmd.length > 2) { + if (CommandTools.amountOfArgumentsIsMoreThan(2, cmd)) { if (CommandTools.tableIsChosen) { String putParameter = new String(); String key = cmd[1]; diff --git a/src/ru/fizteh/fivt/students/MaximGotovchits/Parallel/base/commands/Remove.java b/src/ru/fizteh/fivt/students/MaximGotovchits/Parallel/base/commands/Remove.java index d1901bbb7..4722e7424 100644 --- a/src/ru/fizteh/fivt/students/MaximGotovchits/Parallel/base/commands/Remove.java +++ b/src/ru/fizteh/fivt/students/MaximGotovchits/Parallel/base/commands/Remove.java @@ -5,7 +5,7 @@ public class Remove extends Command { public boolean execute(String[] cmd) { - if (cmd.length == 2) { + if (CommandTools.amountOfArgumentsIs(2, cmd)) { if (CommandTools.tableIsChosen) { try { ObjectStoreable temp = (ObjectStoreable) CommandTools.currentTable.remove(cmd[1]); diff --git a/src/ru/fizteh/fivt/students/MaximGotovchits/Parallel/base/commands/Rollback.java b/src/ru/fizteh/fivt/students/MaximGotovchits/Parallel/base/commands/Rollback.java index bfd6b47ed..cad06fdb1 100644 --- a/src/ru/fizteh/fivt/students/MaximGotovchits/Parallel/base/commands/Rollback.java +++ b/src/ru/fizteh/fivt/students/MaximGotovchits/Parallel/base/commands/Rollback.java @@ -5,7 +5,7 @@ public class Rollback extends Command { @Override public boolean execute(String[] cmd) { - if (cmd.length == 1) { + if (CommandTools.amountOfArgumentsIs(1, cmd)) { CommandTools.currentTable.rollback(); return true; } diff --git a/src/ru/fizteh/fivt/students/MaximGotovchits/Parallel/base/commands/ShowTables.java b/src/ru/fizteh/fivt/students/MaximGotovchits/Parallel/base/commands/ShowTables.java index 9cb1a474e..d9c56dafc 100644 --- a/src/ru/fizteh/fivt/students/MaximGotovchits/Parallel/base/commands/ShowTables.java +++ b/src/ru/fizteh/fivt/students/MaximGotovchits/Parallel/base/commands/ShowTables.java @@ -8,7 +8,7 @@ public class ShowTables extends Command { @Override public boolean execute(String[] cmd) { - if (cmd.length == 2) { + if (CommandTools.amountOfArgumentsIs(2, cmd)) { String currentFile; int recordsAmount; File file = new File(CommandTools.DATA_BASE_NAME); diff --git a/src/ru/fizteh/fivt/students/MaximGotovchits/Parallel/base/commands/Use.java b/src/ru/fizteh/fivt/students/MaximGotovchits/Parallel/base/commands/Use.java index 844627ccc..2c3ff2df7 100644 --- a/src/ru/fizteh/fivt/students/MaximGotovchits/Parallel/base/commands/Use.java +++ b/src/ru/fizteh/fivt/students/MaximGotovchits/Parallel/base/commands/Use.java @@ -5,7 +5,6 @@ import ru.fizteh.fivt.students.MaximGotovchits.Parallel.objects.ObjectTable; import ru.fizteh.fivt.students.MaximGotovchits.Parallel.objects.ObjectTableProvider; import java.io.*; -import java.nio.charset.StandardCharsets; import java.text.ParseException; public class Use extends Command { @@ -16,7 +15,7 @@ public String getCmdName() { @Override public boolean execute(String[] cmd) { - if (cmd.length == 2) { + if (CommandTools.amountOfArgumentsIs(2, cmd)) { try { useFunction(cmd[1], CommandTools.usingTableName); } catch (IOException e) { @@ -80,10 +79,10 @@ void fillStorage(String datName, File file) throws IOException, ParseException { String aLL = new String(data); while (counter < file.length()) { offset = data[counter]; - keyForMap = new String(data, counter + 2, offset - 2, StandardCharsets.UTF_8); + keyForMap = new String(data, counter + 2, offset - 2, CommandTools.UTF); counter = counter + offset + 1; offset = data[counter]; - value = new String(data, counter + 2, data.length - counter - 3, StandardCharsets.UTF_8); + value = new String(data, counter + 2, data.length - counter - 3, CommandTools.UTF); value = value.replaceAll("^\\s*|\\s*$", ""); String tableName = new File(new File(datName).getParent()).getParent(); ObjectStoreable valForMap = (ObjectStoreable) diff --git a/src/ru/fizteh/fivt/students/MaximGotovchits/Parallel/objects/Change.java b/src/ru/fizteh/fivt/students/MaximGotovchits/Parallel/objects/Change.java new file mode 100644 index 000000000..90488ac63 --- /dev/null +++ b/src/ru/fizteh/fivt/students/MaximGotovchits/Parallel/objects/Change.java @@ -0,0 +1,8 @@ +package ru.fizteh.fivt.students.MaximGotovchits.Parallel.objects; + +public abstract class Change { + String key; + String value; + + public abstract void execute(ObjectTable table); +} diff --git a/src/ru/fizteh/fivt/students/MaximGotovchits/Parallel/objects/ObjectStoreable.java b/src/ru/fizteh/fivt/students/MaximGotovchits/Parallel/objects/ObjectStoreable.java index 83a5d7350..0b15b7896 100644 --- a/src/ru/fizteh/fivt/students/MaximGotovchits/Parallel/objects/ObjectStoreable.java +++ b/src/ru/fizteh/fivt/students/MaximGotovchits/Parallel/objects/ObjectStoreable.java @@ -50,12 +50,9 @@ public int hashCode() { @Override public boolean equals(Object obj) { ObjectStoreable storeableObj = (ObjectStoreable) obj; - if (this.serialisedValue.equals(storeableObj.serialisedValue) + return this.serialisedValue.equals(storeableObj.serialisedValue) && this.typeKeeper.equals(storeableObj.typeKeeper) - && this.subValueList.equals(storeableObj.subValueList)) { - return true; - } - return false; + && this.subValueList.equals(storeableObj.subValueList); } @Override @@ -199,3 +196,154 @@ private List> convertToPrimitive(List> list) { return toReturn; } } + + +/*package ru.fizteh.fivt.students.MaximGotovchits.Parallel.objects; + + import ru.fizteh.fivt.storage.structured.ColumnFormatException; + import ru.fizteh.fivt.storage.structured.Storeable; + import java.text.ParseException; + import java.util.*; + +public class ObjectStoreable implements Storeable { + private static final String LEFT_BRACE = "["; + private static final String RIGHT_BRACE = "]"; + private static final String VALUE_SEPARATOR = ", "; + public List subValueList = new LinkedList<>(); + private static ObjectTable currentTableObject; + public String serialisedValue; + public List> typeKeeper = new LinkedList<>(); + + public ObjectStoreable() {} + + public ObjectStoreable(List values) { + serialisedValue = LEFT_BRACE; + for (Object val : values) { + subValueList.add(val); + } + serialisedValue += String.join(VALUE_SEPARATOR, (List) values); + serialisedValue += RIGHT_BRACE; + } + + public ObjectStoreable(ObjectTable table) { + typeKeeper = table.typeKeeper; + } + + public ObjectStoreable(String value) throws ParseException { + ObjectStoreable obj = (ObjectStoreable) new ObjectTableProvider().deserialize(currentTableObject, value); + if (obj == null) { + return; + } + subValueList = obj.subValueList; + serialisedValue = obj.serialisedValue; + typeKeeper = obj.typeKeeper; + } + + @Override + public int hashCode() { + return Objects.hashCode(this.serialisedValue); + } + + @Override + public boolean equals(Object obj) { + ObjectStoreable storeableObj = (ObjectStoreable) obj; + return this.serialisedValue.equals(storeableObj.serialisedValue) + && this.typeKeeper.equals(storeableObj.typeKeeper) + && this.subValueList.equals(storeableObj.subValueList); + } + + @Override + public void setColumnAt(int columnIndex, Object value) throws ColumnFormatException, IndexOutOfBoundsException { + if (columnIndex >= this.subValueList.size()) { + throw new IndexOutOfBoundsException(); + } + List> toConvert = new LinkedList<>(); + toConvert.add(value.getClass()); + toConvert = convertToPrimitive(toConvert); + if (!typeKeeper.get(columnIndex).equals(toConvert.get(0))) { + throw new ColumnFormatException(); + } + this.subValueList.set(columnIndex, value); + this.serialisedValue = ""; + serialisedValue = LEFT_BRACE; + for (Object val : this.subValueList) { + serialisedValue += val + VALUE_SEPARATOR; + } + serialisedValue = serialisedValue.substring(0, serialisedValue.length() - 2); + serialisedValue += RIGHT_BRACE; + } + + @Override + public Object getColumnAt(int columnIndex) throws IndexOutOfBoundsException { + if (subValueList.size() < columnIndex - 1) { + throw new IndexOutOfBoundsException(); + } + return subValueList.get(columnIndex); + } + + @Override + public Integer getIntAt(int columnIndex) throws ColumnFormatException, IndexOutOfBoundsException { + checkGetSomethingAtException(columnIndex); + return (Integer) subValueList.get(columnIndex); + } + + @Override + public Long getLongAt(int columnIndex) throws ColumnFormatException, IndexOutOfBoundsException { + checkGetSomethingAtException(columnIndex); + return (Long) subValueList.get(columnIndex); + } + + @Override + public Byte getByteAt(int columnIndex) throws ColumnFormatException, IndexOutOfBoundsException { + checkGetSomethingAtException(columnIndex); + return (Byte) subValueList.get(columnIndex); + } + + @Override + public Float getFloatAt(int columnIndex) throws ColumnFormatException, IndexOutOfBoundsException { + checkGetSomethingAtException(columnIndex); + return (Float) subValueList.get(columnIndex); + } + + @Override + public Double getDoubleAt(int columnIndex) throws ColumnFormatException, IndexOutOfBoundsException { + checkGetSomethingAtException(columnIndex); + return (Double) subValueList.get(columnIndex); + } + + @Override + public Boolean getBooleanAt(int columnIndex) throws ColumnFormatException, IndexOutOfBoundsException { + checkGetSomethingAtException(columnIndex); + return (Boolean) subValueList.get(columnIndex); + } + + @Override + public String getStringAt(int columnIndex) throws ColumnFormatException, IndexOutOfBoundsException { + if (columnIndex >= this.typeKeeper.size()) { + throw new IndexOutOfBoundsException(); + } + if (!typeKeeper.get(columnIndex).equals(String.class)) { + throw new ColumnFormatException(); + } + return subValueList.get(columnIndex).toString(); + } + + private void checkGetSomethingAtException(int columnIndex) { + if (columnIndex >= this.typeKeeper.size()) { + throw new IndexOutOfBoundsException(); + } + if (!typeKeeper.get(columnIndex).equals(boolean.class)) { + throw new ColumnFormatException(); + } + } + + private List> convertToPrimitive(List> list) { + List> toReturn = new LinkedList<>(); + for (Class object : list) { + toReturn.add(ObjectTableProvider.TYPES_MAP.get(object)); + continue; + } + return toReturn; + } +} +*/ diff --git a/src/ru/fizteh/fivt/students/MaximGotovchits/Parallel/objects/ObjectTable.java b/src/ru/fizteh/fivt/students/MaximGotovchits/Parallel/objects/ObjectTable.java index e68487529..05c87927d 100644 --- a/src/ru/fizteh/fivt/students/MaximGotovchits/Parallel/objects/ObjectTable.java +++ b/src/ru/fizteh/fivt/students/MaximGotovchits/Parallel/objects/ObjectTable.java @@ -1,15 +1,15 @@ -package ru.fizteh.fivt.students.MaximGotovchits.Parallel.objects; +/*package ru.fizteh.fivt.students.MaximGotovchits.Parallel.objects; import ru.fizteh.fivt.storage.structured.ColumnFormatException; import ru.fizteh.fivt.storage.structured.Storeable; import ru.fizteh.fivt.storage.structured.Table; - import java.io.File; import java.io.IOException; import java.nio.charset.Charset; import java.nio.file.Files; import java.nio.file.Paths; import java.util.*; +import java.util.List; public class ObjectTable implements Table { private static int overwriteNum = 0; @@ -48,18 +48,15 @@ public ObjectTable(String name) { } this.tableName = new File(name).getName(); String content; - try { - if (!new File(name + File.separator + SIGNATURE_FILENAME).isAbsolute()) { - name = DATA_BASE_NAME + File.separator + name; - } - content = readFile(name + File.separator + SIGNATURE_FILENAME, Charset.defaultCharset()); - content.replaceAll("\\s+", " "); - String[] types = content.split(" "); - for (String type : types) { - typeKeeper.add(getType(type)); - } - } catch (IOException s) { - System.err.println(s); + + if (!new File(name + File.separator + SIGNATURE_FILENAME).isAbsolute()) { + name = DATA_BASE_NAME + File.separator + name; + } + content = readFile(name + File.separator + SIGNATURE_FILENAME, Charset.defaultCharset()); + content = content.replaceAll("\\s+", " "); + String[] types = content.split(" "); + for (String type : types) { + typeKeeper.add(getType(type)); } } @@ -78,10 +75,7 @@ public int hashCode() { @Override public boolean equals(Object obj) { ObjectTable tableObj = (ObjectTable) obj; - if (this.tableName.equals(tableObj.tableName) && this.typeKeeper.equals(tableObj.typeKeeper)) { - return true; - } - return false; + return this.tableName.equals(tableObj.tableName) && this.typeKeeper.equals(tableObj.typeKeeper); } @Override @@ -157,7 +151,7 @@ public List list() { @Override public int commit() { int savedKeys = Math.abs(storage.get().size() - commitStorage.size()); - commitStorage = new HashMap(storage.get()); + commitStorage = new HashMap<>(storage.get()); lastChanges.get().clear(); return savedKeys; } @@ -201,10 +195,233 @@ public Class getColumnType(int columnIndex) throws IndexOutOfBoundsException return objectToReturn; } - private static String readFile(String path, Charset encoding) throws IOException { - byte[] encoded = Files.readAllBytes(Paths.get(path)); - String temp = new String(encoded, encoding); - return temp.replaceAll("^\\s*|\\s*$", ""); + private static String readFile(String path, Charset encoding) { + byte[] encoded; + try { + encoded = Files.readAllBytes(Paths.get(path)); + String temp = new String(encoded, encoding); + return temp.replaceAll("^\\s*|\\s*$", ""); + } catch (IOException e) { + return null; + } + } + + public Class getType(String typeName) { + if (typeName.equals("int")) { + return int.class; + } + if (typeName.equals("long")) { + return long.class; + } + if (typeName.equals("byte")) { + return byte.class; + } + if (typeName.equals("float")) { + return float.class; + } + if (typeName.equals("double")) { + return double.class; + } + if (typeName.equals("boolean")) { + return boolean.class; + } + if (typeName.equals("String")) { + return String.class; + } + return null; + } +} + +*/ +package ru.fizteh.fivt.students.MaximGotovchits.Parallel.objects; + +import ru.fizteh.fivt.storage.structured.ColumnFormatException; +import ru.fizteh.fivt.storage.structured.Storeable; +import ru.fizteh.fivt.storage.structured.Table; +import java.io.File; +import java.io.IOException; +import java.nio.charset.Charset; +import java.nio.file.Files; +import java.nio.file.Paths; +import java.util.*; +import java.util.List; + +public class ObjectTable implements Table { + private int overwriteNum = 0; + + public ThreadLocal lastChanges = new ThreadLocal() { + @Override + protected Stack initialValue() { + return new Stack(); + } + }; + + public ThreadLocal> storage = new ThreadLocal>() { + @Override + protected HashMap initialValue() { + return new HashMap<>(); + } + }; + + public Map commitStorage = new HashMap<>(); + public String tableName = new String(); + public List> typeKeeper = new LinkedList<>(); + + public ObjectTable() { } + + public ObjectTable(Table table) { + ObjectTable temp = (ObjectTable) table; + this.tableName = temp.tableName; + this.typeKeeper = temp.typeKeeper; + } + + public ObjectTable(String name) { + if (!new File(name).isAbsolute()) { + name = ObjectTableProvider.dataBaseName + File.separator + name; + } + this.tableName = new File(name).getName(); + if (!new File(name + File.separator + ObjectTableProvider.SIGNATURE_FILENAME).isAbsolute()) { + name = ObjectTableProvider.dataBaseName + File.separator + name; + } + String content = readFile(name + File.separator + ObjectTableProvider.SIGNATURE_FILENAME, + Charset.defaultCharset()); + content = content.replaceAll("\\s+", " "); + String[] types = content.split(" "); + for (String type : types) { + typeKeeper.add(getType(type)); + } + } + + public ObjectTable(String name, List> typeList) { + for (Class type : typeList) { + typeKeeper.add(type); + } + tableName = name; + } + + @Override + public int hashCode() { + return Objects.hashCode(this.tableName); + } + + @Override + public boolean equals(Object obj) { + return (this.tableName.equals(((ObjectTable) obj).tableName) + && this.typeKeeper.equals(((ObjectTable) obj).typeKeeper)); + } + + @Override + public String getName() { + return tableName; + } + + @Override + public Storeable get(String key) throws IllegalArgumentException { // В документации в Index + // не сказано, когда кидать ParseException, однако согласно интерфейсу тут все-таки написано + // throws ParseException, но на самом деле это исключение тут не бросатется. + if (key == null) { + throw new IllegalArgumentException(); + } + ObjectStoreable value = storage.get().get(key); + if (value == null) { + return null; + } + return value; + } + + @Override + public Storeable put(String key, Storeable value) throws ColumnFormatException { + if (key == null || value == null) { + throw new IllegalArgumentException(); + } + if (!this.typeKeeper.equals(((ObjectStoreable) value).typeKeeper)) { + throw new ColumnFormatException(); + } + ObjectStoreable previousValue = storage.get().put(key, (ObjectStoreable) value); + if (previousValue == null) { + lastChanges.get().push(new RemoveChange(key)); + } else { + lastChanges.get().push(new PutChange(key, previousValue)); + ++overwriteNum; + } + return previousValue; + } + + @Override + public Storeable remove(String key) { + if (key == null) { + throw new IllegalArgumentException(); + } + ObjectStoreable value = storage.get().remove(key); + commitStorage.remove(key); + if (value != null) { + lastChanges.get().push(new PutChange(key, value)); + } + return value; + } + + @Override + public int size() { + return storage.get().size(); + } + + @Override + public List list() { + LinkedList list = new LinkedList(); + Set k = storage.get().keySet(); + for (Object iter : k) { + list.add(iter.toString()); + } + return list; + } + + @Override + public int commit() { + int savedKeys = Math.abs(storage.get().size() - commitStorage.size()); + commitStorage = new HashMap<>(storage.get()); + lastChanges.get().clear(); + return savedKeys; + } + + @Override + public int rollback() throws IllegalArgumentException { + int changes = Math.abs(storage.get().size() - commitStorage.size() + overwriteNum); + while (!lastChanges.get().isEmpty()) { + ((Change) lastChanges.get().pop()).execute(this); + } + overwriteNum = 0; + return changes; + } + + @Override + public int getNumberOfUncommittedChanges() { + int numberOfUncommitedChanges = Math.abs(storage.get().size() - commitStorage.size()); + return numberOfUncommitedChanges; + } + + @Override + public int getColumnsCount() { + return typeKeeper.size(); + } + + @Override + public Class getColumnType(int columnIndex) throws IndexOutOfBoundsException { + if (this.getColumnsCount() < columnIndex - 1) { + throw new IndexOutOfBoundsException(); + } + Class objectToReturn = typeKeeper.get(columnIndex); + return objectToReturn; + } + + static String readFile(String path, Charset encoding) { + try { + byte[] encoded = Files.readAllBytes(Paths.get(path)); + + String temp = new String(encoded, encoding); + return temp.replaceAll("^\\s*|\\s*$", ""); + } catch (IOException e) { + return null; + } } public Class getType(String typeName) { @@ -232,3 +449,4 @@ public Class getType(String typeName) { return null; } } + diff --git a/src/ru/fizteh/fivt/students/MaximGotovchits/Parallel/objects/ObjectTableProvider.java b/src/ru/fizteh/fivt/students/MaximGotovchits/Parallel/objects/ObjectTableProvider.java index 5a7629add..4c0c0f3a9 100644 --- a/src/ru/fizteh/fivt/students/MaximGotovchits/Parallel/objects/ObjectTableProvider.java +++ b/src/ru/fizteh/fivt/students/MaximGotovchits/Parallel/objects/ObjectTableProvider.java @@ -1,6 +1,7 @@ package ru.fizteh.fivt.students.MaximGotovchits.Parallel.objects; import ru.fizteh.fivt.storage.structured.ColumnFormatException; +import ru.fizteh.fivt.students.MaximGotovchits.Parallel.base.commands.*; import ru.fizteh.fivt.storage.structured.Storeable; import ru.fizteh.fivt.storage.structured.Table; import ru.fizteh.fivt.storage.structured.TableProvider; @@ -15,16 +16,15 @@ public class ObjectTableProvider implements TableProvider { private static final String INCORRECT_SYMBOL = "^incorrect@"; private static final String BRACES_KILLER = "^\\s*\\[\\s*|\\s*\\]\\s*$"; - private static final String JSON_REG_EX = "\\s*,\\s*(?=(?:(?:[^\"]*\"){2})*[^\"]*$)"; - private static String usingTableName; - private static ObjectTable currentTableObject; private static final int LONGEST_NAME = 260; - private static final String SIGNATURE_FILENAME = "signature.tsv"; + private static final String JSON_REG_EX = "\\s*,\\s*(?=(?:(?:[^\"]*\"){2})*[^\"]*$)"; + public static String usingTableName; + public static ObjectTable currentTableObject; + static final String SIGNATURE_FILENAME = "signature.tsv"; private static Boolean tableIsChosen = false; - private static String dataBaseName = System.getProperty("fizteh.db.dir"); + public static String dataBaseName = System.getProperty("fizteh.db.dir"); private volatile boolean writeSectionIsInUse = false; - private String rootDirectory = new String(); - + private String rootDirectory = ""; public ObjectTableProvider() { rootDirectory = dataBaseName; } @@ -72,7 +72,7 @@ public Table createTable(String name, List> columnTypes) throws IOExcep } else { file.mkdir(); signatureFile.createNewFile(); - PrintWriter writer = new PrintWriter(signatureFile, "UTF-8"); + PrintWriter writer = new PrintWriter(signatureFile, CommandTools.UTF.toString()); String tempTypes = new String(); for (Class type : columnTypes) { if (type.equals(String.class)) { @@ -307,3 +307,344 @@ private List> convertToPrimitive(List list) { return toReturn; } } + +/* +package ru.fizteh.fivt.students.MaximGotovchits.Parallel.objects; + + import ru.fizteh.fivt.storage.structured.ColumnFormatException; + import ru.fizteh.fivt.storage.structured.Storeable; + import ru.fizteh.fivt.storage.structured.Table; + import ru.fizteh.fivt.storage.structured.TableProvider; + import java.io.*; + import java.nio.charset.StandardCharsets; + import java.text.ParseException; + import java.util.*; + import java.util.concurrent.locks.ReadWriteLock; + import java.util.concurrent.locks.ReentrantReadWriteLock; + +public class ObjectTableProvider implements TableProvider { + static final Map, Class> TYPES_MAP = new HashMap, Class>() { + { + TYPES_MAP.put(int.class, int.class); + TYPES_MAP.put(long.class, long.class); + TYPES_MAP.put(byte.class, byte.class); + TYPES_MAP.put(float.class, float.class); + TYPES_MAP.put(double.class, double.class); + TYPES_MAP.put(boolean.class, boolean.class); + TYPES_MAP.put(String.class, String.class); + } + }; + private static final String BRACES_KILLER = "^\\s*\\[\\s*|\\s*\\]\\s*$"; + public static final String FILE_EXT = ".dat"; + public static final Integer FILE_NUM = 16; + public static final String DIR_EXT = ".dir"; + public static final Integer DIR_NUM = 16; + private static final String JSON_REG_EX = "\\s*,\\s*(?=(?:(?:[^\"]*\"){2})*[^\"]*$)"; + public static String usingTableName; + public static ObjectTable currentTableObject; + static final String SIGNATURE_FILENAME = "signature.tsv"; + private static Boolean tableIsChosen = false; + public static String dataBaseName = System.getProperty("fizteh.db.dir"); + private volatile boolean writeSectionIsInUse = false; + private String rootDirectory = ""; + + public ObjectTableProvider() { + rootDirectory = dataBaseName; + } + + public ObjectTableProvider(String dir) { + dataBaseName = dir; + rootDirectory = dir; + } + + public int hashCode() { + return Objects.hashCode(this.rootDirectory); + } + + @Override + public boolean equals(Object obj) { + ObjectTableProvider tempObj = (ObjectTableProvider) obj; + return tempObj.rootDirectory.equals(this.rootDirectory); + } + @Override + public Table getTable(String name) throws IllegalArgumentException { + checkException(name); + ReadWriteLock readWriteLock = new ReentrantReadWriteLock(); + if (new File(rootDirectory + File.separator + name).exists()) { + readWriteLock.readLock().lock(); + ObjectTable tableToReturn; + try { + tableToReturn = new ObjectTable(rootDirectory + File.separator + name); + } catch (IOException e) { + return null; + } + readWriteLock.readLock().unlock(); + return tableToReturn; + } + return null; + } + @Override + public Table createTable(String name, List> columnTypes) throws IOException, IllegalArgumentException { + ReadWriteLock readWriteLock = new ReentrantReadWriteLock(); + if (writeSectionIsInUse) { + return null; + } + writeSectionIsInUse = true; + readWriteLock.writeLock().lock(); + checkException(name); + File file = new File(rootDirectory + File.separator + name); + File signatureFile = new File(rootDirectory + File.separator + name + File.separator + SIGNATURE_FILENAME); + if (file.exists()) { + readWriteLock.writeLock().unlock(); + return new ObjectTable(name, columnTypes); + } else { + file.mkdir(); + signatureFile.createNewFile(); + PrintWriter writer = new PrintWriter(signatureFile, "UTF-8"); + String tempTypes = new String(); + for (Class type : columnTypes) { + if (type.equals(String.class)) { + tempTypes += "String "; + } else { + tempTypes += type.getName() + " "; + } + } + tempTypes = tempTypes.substring(0, tempTypes.length() - 1); + writer.println(tempTypes); + writer.close(); + System.out.println("created"); + } + writeSectionIsInUse = false; + return new ObjectTable(name, columnTypes); + } + @Override + public void removeTable(String name) throws IllegalArgumentException, IllegalStateException { + if (name == null || name.length() > ObjectTableProviderFactory.LONGEST_NAME) { + throw new IllegalArgumentException(); + } + String tableName = rootDirectory + File.separator + name; + File toBeRemoved = new File(tableName); + if (toBeRemoved.exists()) { + if (tableIsChosen) { + if (usingTableName.equals(name)) { + currentTableObject.storage.get().clear(); + currentTableObject.commitStorage.clear(); + tableIsChosen = false; + usingTableName = null; + } + } + recRem(tableName); + toBeRemoved.delete(); + System.out.println("dropped"); + } else { + throw new IllegalStateException(); + } + } + + @Override + public Storeable deserialize(Table table, String value) throws ParseException { + ObjectTable usingTable = (ObjectTable) table; + ObjectStoreable valueToReturn = new ObjectStoreable(); + String[] splittedValue = value.split(""); + if (!splittedValue[0].equals("[") || !splittedValue[splittedValue.length - 1].equals("]")) { + throw new ParseException(value, 0); + } + valueToReturn.serialisedValue = value; + value = value.replaceAll(BRACES_KILLER, ""); // Removing [ and ]. + String[] tempValue = value.split(JSON_REG_EX); // Split by comma. + if (usingTable.getColumnsCount() != tempValue.length) { + throw new ParseException(value, 0); + } + int index = 0; + List> typeList = new LinkedList<>(); + for (String str : tempValue) { + Object val = getValue(str, usingTable, usingTable.typeKeeper.get(index)); + if (val.equals("^incorrect$")) { + throw new ParseException(value, 0); + } + valueToReturn.subValueList.add(val); + typeList.add(val.getClass()); + ++index; + } + valueToReturn.typeKeeper = usingTable.typeKeeper; + return valueToReturn; + } + + @Override + public String serialize(Table table, Storeable value) throws ColumnFormatException { + ObjectStoreable valueToSerialize = (ObjectStoreable) value; + ObjectTable tableObj = (ObjectTable) table; + int index = 0; + for (Class type : tableObj.typeKeeper) { + if (!type.equals(valueToSerialize.typeKeeper.get(index))) { + throw new ColumnFormatException(); + } + ++index; + } + return valueToSerialize.serialisedValue; + } + + @Override + public Storeable createFor(Table table) { + return new ObjectStoreable((ObjectTable) table); + } + + @Override + public Storeable createFor(Table table, List values) throws ColumnFormatException, IndexOutOfBoundsException { + int ind = 0; + ObjectTable tempTable = new ObjectTable(table); + List> valTypes = new LinkedList>(); + valTypes = convertToPrimitive(values); + if (values.size() != tempTable.getColumnsCount()) { + throw new IndexOutOfBoundsException(); + } + if (!valTypes.equals(tempTable.typeKeeper)) { + throw new ColumnFormatException(); + } + ObjectStoreable toReturn = new ObjectStoreable(values); + toReturn.typeKeeper = tempTable.typeKeeper; + return toReturn; + } + + @Override + public List getTableNames() { + List list = new LinkedList(); + String currentFile = new String(); + int recordsAmount = 0; + File file = new File(rootDirectory); + for (File sub : file.listFiles()) { + if ((!sub.isHidden()) && sub.isDirectory()) { + recordsAmount = 0; + for (Integer i = 0; i < DIR_NUM; ++i) { + currentFile = rootDirectory + File.separator + sub.getName() + File.separator + + i + DIR_EXT; + File file1 = new File(currentFile); + if (file1.exists()) { + for (Integer j = 0; j < FILE_NUM; ++j) { + currentFile = rootDirectory + File.separator + sub.getName() + File.separator + + i + DIR_EXT + File.separator + j + FILE_EXT; + file1 = new File(currentFile); + try { + if (file1.exists()) { + DataInputStream stream = new DataInputStream(new FileInputStream(currentFile)); + byte[] data = new byte[(int) file1.length()]; + stream.read(data); + String temp = new String(data, StandardCharsets.UTF_8); + recordsAmount += (temp.length() - temp.replaceAll(" ", "").length()) / 4; + } + } catch (FileNotFoundException e) { + return null; + } catch (IOException e) { + return null; + } + } + } + } + currentFile = new File(new File(new File(currentFile).getParent()).getParent()).getName(); + list.add(sub.getName()); + if (sub.getName().equals(usingTableName)) { + System.out.println(sub.getName() + " " + + (recordsAmount + currentTableObject.storage.get().size())); + } else { + System.out.println(sub.getName() + " " + recordsAmount); + } + } + } + return list; + } + + private Object getValue(String str, ObjectTable usingTable, Class expectedType) throws NumberFormatException { + for (Class type : usingTable.typeKeeper) { + if (expectedType.equals(int.class)) { + if (str.equals("null")) { + return null; + } + Integer toReturn = Integer.parseInt(str); + return toReturn; + } + if (expectedType.equals(long.class)) { + if (str.equals("null")) { + return null; + } + Long toReturn = Long.parseLong(str); + return toReturn; + } + if (expectedType.equals(boolean.class)) { + if (str.equals("null")) { + return null; + } + Boolean toReturn = Boolean.parseBoolean(str); + return toReturn; + } + if (expectedType.equals(String.class)) { + if (str.equals("null")) { + return null; + } + String[] tmp = str.split(""); + if (tmp[0].equals("\"") && tmp[tmp.length - 1].equals("\"")) { + return str; + } else { + throw new NumberFormatException(); + } + } + if (expectedType.equals(byte.class)) { + if (str.equals("null")) { + return null; + } + Byte toReturn = Byte.parseByte(str); + return toReturn; + } + if (expectedType.equals(double.class)) { + if (str.equals("null")) { + return null; + } + Double toReturn = Double.parseDouble(str); + return toReturn; + } + if (expectedType.equals(float.class)) { + if (str.equals("null")) { + return null; + } + Float toReturn = Float.parseFloat(str); + return toReturn; + } + } + return "^incorrect@"; + } + + void recRem(String myFile) { + File file = new File(myFile); + if (!file.exists()) { + return; + } + if (file.isDirectory()) { + for (File f : file.listFiles()) { + recRem(f.getAbsolutePath()); + } + } + file.delete(); + } + + public void checkException(String name) throws IllegalArgumentException { + if (name == null || name.length() > ObjectTableProviderFactory.LONGEST_NAME) { + throw new IllegalArgumentException(); + } + } + + private List> convertToPrimitive(List list) { + List> toReturn = new LinkedList>(); + for (Object object : list) { + toReturn.add(TYPES_MAP.get(object)); + continue; + } + return toReturn; + } + + private void initialization() { + tableIsChosen = false; + dataBaseName = System.getProperty("fizteh.db.dir"); + writeSectionIsInUse = false; + rootDirectory = ""; + } +} +*/ diff --git a/src/ru/fizteh/fivt/students/MaximGotovchits/Parallel/objects/ObjectTableProviderFactory.java b/src/ru/fizteh/fivt/students/MaximGotovchits/Parallel/objects/ObjectTableProviderFactory.java index a73756cf9..c24b9919a 100644 --- a/src/ru/fizteh/fivt/students/MaximGotovchits/Parallel/objects/ObjectTableProviderFactory.java +++ b/src/ru/fizteh/fivt/students/MaximGotovchits/Parallel/objects/ObjectTableProviderFactory.java @@ -16,3 +16,29 @@ public TableProvider create(String dir) throws IllegalArgumentException { return new ObjectTableProvider(dir); } } + +/* +package ru.fizteh.fivt.students.MaximGotovchits.Parallel.objects; + +import ru.fizteh.fivt.storage.structured.TableProvider; +import ru.fizteh.fivt.storage.structured.TableProviderFactory; + +public class ObjectTableProviderFactory implements TableProviderFactory { + static final int LONGEST_NAME = 260; + String dirName; + + @Override + public TableProvider create(String dir) throws IllegalArgumentException { + dirName = dir; + try { + if (dir == null || dir.length() > LONGEST_NAME) { + throw new IllegalArgumentException(); + } + } catch (IllegalArgumentException s) { + System.err.println(s); + return null; + } + return new ObjectTableProvider(dir); + } +} +*/ diff --git a/src/ru/fizteh/fivt/students/MaximGotovchits/Parallel/objects/PutChange.java b/src/ru/fizteh/fivt/students/MaximGotovchits/Parallel/objects/PutChange.java new file mode 100644 index 000000000..6647de773 --- /dev/null +++ b/src/ru/fizteh/fivt/students/MaximGotovchits/Parallel/objects/PutChange.java @@ -0,0 +1,16 @@ +package ru.fizteh.fivt.students.MaximGotovchits.Parallel.objects; + +public class PutChange extends Change { + String key; + ObjectStoreable value; + + public PutChange(String keyParam, ObjectStoreable valueParam) { + key = keyParam; + value = valueParam; + } + + @Override + public void execute(ObjectTable table) { + table.storage.get().put(key, value); + } +} diff --git a/src/ru/fizteh/fivt/students/MaximGotovchits/Parallel/objects/RemoveChange.java b/src/ru/fizteh/fivt/students/MaximGotovchits/Parallel/objects/RemoveChange.java new file mode 100644 index 000000000..2fd5d387f --- /dev/null +++ b/src/ru/fizteh/fivt/students/MaximGotovchits/Parallel/objects/RemoveChange.java @@ -0,0 +1,13 @@ +package ru.fizteh.fivt.students.MaximGotovchits.Parallel.objects; + +public class RemoveChange extends Change { + String key; + public RemoveChange(String keyParam) { + key = keyParam; + } + + @Override + public void execute(ObjectTable table) { + table.storage.get().remove(key); + } +} diff --git a/src/ru/fizteh/fivt/students/MaximGotovchits/Parallel/test/InterpreterTest/InteractiveModeTest.java b/src/ru/fizteh/fivt/students/MaximGotovchits/Parallel/test/InterpreterTest/InteractiveModeTest.java index 7d48985a8..959b4a4fb 100644 --- a/src/ru/fizteh/fivt/students/MaximGotovchits/Parallel/test/InterpreterTest/InteractiveModeTest.java +++ b/src/ru/fizteh/fivt/students/MaximGotovchits/Parallel/test/InterpreterTest/InteractiveModeTest.java @@ -115,7 +115,7 @@ public void rollbackTest() { + "rollback\nextremely_secret_word_for_test").getBytes()); interpreter.scan = new Scanner(in); interpreter.startUp(null, false); - assertEquals("$ using " + TEST_TABLE_NAME + "\n$ new\n$ $ ", outContent.toString()); + assertEquals("$ using " + TEST_TABLE_NAME + "\n$ overwrite\n$ $ ", outContent.toString()); } @Test @@ -124,7 +124,8 @@ public void showTablesTest() { // Use empty dir. + "\nshow tables\nextremely_secret_word_for_test").getBytes()); interpreter.scan = new Scanner(in); interpreter.startUp(null, false); - assertEquals("$ using " + TEST_TABLE_NAME + "\n$ " + TEST_TABLE_NAME + " 0\n$ ", outContent.toString()); + assertEquals("$ using " + TEST_TABLE_NAME + "\n$ something 0\n" + TEST_TABLE_NAME + + " 0\n$ ", outContent.toString()); } @Test diff --git a/src/ru/fizteh/fivt/students/MaximGotovchits/Parallel/test/ObjectTableTest.java b/src/ru/fizteh/fivt/students/MaximGotovchits/Parallel/test/ObjectTableTest.java index 3bf9f294d..864ff76d8 100644 --- a/src/ru/fizteh/fivt/students/MaximGotovchits/Parallel/test/ObjectTableTest.java +++ b/src/ru/fizteh/fivt/students/MaximGotovchits/Parallel/test/ObjectTableTest.java @@ -25,21 +25,11 @@ public void initialization() throws IOException { name = "TestTable"; columnTypes.add(int.class); columnTypes.add(long.class); - columnTypes.add(double.class); - columnTypes.add(float.class); - columnTypes.add(byte.class); - columnTypes.add(boolean.class); - columnTypes.add(String.class); testTable = (ObjectTable) new ObjectTableProvider().createTable(name, columnTypes); deserializedValue.subValueList.add(100500); deserializedValue.subValueList.add((long) 10000000); - deserializedValue.subValueList.add(123.456); - deserializedValue.subValueList.add((float) 12.45); - deserializedValue.subValueList.add((byte) 100); - deserializedValue.subValueList.add(true); - deserializedValue.subValueList.add("\"ValueToTest\""); deserializedValue.typeKeeper = columnTypes; - deserializedValue.serialisedValue = "[100500, 10000000, 123.456, 12.45, 100, true, \"ValueToTest\"]"; + deserializedValue.serialisedValue = "[100500, 10000000]"; } @Test @@ -129,7 +119,7 @@ public void getNumberOfUncommittedChangesTest() { @Test public void getColumnsCountTest() { - assertEquals(7, testTable.getColumnsCount()); + assertEquals(2, testTable.getColumnsCount()); } @Test @@ -137,12 +127,7 @@ public void getColumnType() throws Exception { new Use().useFunction(name, null); assertEquals(int.class, testTable.getColumnType(0)); assertEquals(long.class, testTable.getColumnType(1)); - assertEquals(double.class, testTable.getColumnType(2)); - assertEquals(float.class, testTable.getColumnType(3)); - assertEquals(byte.class, testTable.getColumnType(4)); - assertEquals(boolean.class, testTable.getColumnType(5)); - assertEquals(String.class, testTable.getColumnType(6)); - } + } @After public void cleanUp() {