Homework g595 zueva

homework-base/src/main/java/ru/mipt/java2016/homework/base/task2/KeyValueStorage.java

@@ -14,6 +14,7 @@
  * @since 04.10.16
  */
 public interface KeyValueStorage<K, V> extends Closeable {
+
     /**
      * Возвращает значение для данного ключа, если оно есть в хранилище.
      * Иначе возвращает null.

homework-g595-zueva/pom.xml

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

homework-g595-zueva/src/main/java/ru/mipt/java2016/homework/g595/zueva/task2/task2/SerializerStorage.java

@@ -0,0 +1,14 @@
+package ru.mipt.java2016.homework.g595.zueva.task2.task2;
+
+import java.io.DataInputStream;
+import java.io.DataOutputStream;
+import java.io.IOException;
+
+/**
+ * Created by nestyme on 31.10.2016.
+ */
+interface SerializerStorage<T> {
+    void writeToStream(DataOutputStream out, T value)throws IOException;
+
+    T readFromStream(DataInputStream in) throws IOException;
+}

homework-g595-zueva/src/main/java/ru/mipt/java2016/homework/g595/zueva/task2/task2/Serializers.java

@@ -0,0 +1,52 @@
+package ru.mipt.java2016.homework.g595.zueva.task2.task2;
+
+/**
+ * Created by nestyme on 30.10.2016.
+ */
+
+import java.io.DataInputStream;
+import java.io.DataOutputStream;
+import java.io.IOException;
+
+
+public class Serializers {
+
+    public static class SerialiserInt implements SerializerStorage<Integer> {
+
+
+        public void writeToStream(DataOutputStream out, Integer value) throws IOException {
+
+            out.writeInt(value);
+
+        }
+
+        public Integer readFromStream(DataInputStream in) throws IOException {
+
+            return in.readInt();
+        }
+    }
+
+
+    public static class SerializerStorageString implements SerializerStorage<String> {
+
+        public void writeToStream(DataOutputStream out, String value) throws IOException {
+            out.writeUTF(value);
+        }
+
+        public String readFromStream(DataInputStream in) throws IOException {
+            return in.readUTF();
+        }
+    }
+
+    public static class SerializerStorageDouble implements SerializerStorage<Double> {
+
+        public void writeToStream(DataOutputStream out, Double value) throws IOException {
+            out.writeDouble(value);
+        }
+
+        @Override
+        public Double readFromStream(DataInputStream in) throws IOException {
+            return in.readDouble();
+        }
+    }
+}

homework-g595-zueva/src/main/java/ru/mipt/java2016/homework/g595/zueva/task2/task3/FRFile.java

@@ -0,0 +1,81 @@
+package ru.mipt.java2016.homework.g595.zueva.task2.task3;
+import java.io.*;
+import java.nio.*;
+/**
+ * Created by someb on 17.12.2016.
+ */
+public class FRFile {
+    private ByteBuffer mybuffer = ByteBuffer.allocate(Long.SIZE / 8);
+    private File myfile;
+    private BufferedInputStream in;
+    private BufferedOutputStream out;
+
+     private boolean ifEmpty = false;
+
+             public FRFile(String fileDirectory, String fileName) throws IOException {
+                File directory = new File(fileDirectory);
+                if (directory.exists()) {
+                        myfile = new File(fileDirectory, fileName);
+                    myfile.createNewFile();
+                        in = new BufferedInputStream(new FileInputStream(myfile));
+                    } else {
+                        throw new IOException("Cannot found directory");
+                    }
+            }
+
+             public long ReadFileOffst() throws IOException {
+                if (in.read(mybuffer.array(), 0, Long.SIZE / 8) != Long.SIZE / 8) {
+                        throw new IOException("Can`t continue reading");
+                    }
+                return mybuffer.getLong(0);
+            }
+    public int readKey() throws IOException {
+        if (in.read(mybuffer.array(), 0, Integer.SIZE / 8) != Integer.SIZE / 8) {
+            throw new IOException("Can`t continue reading");
+        }
+        return mybuffer.getInt(0);
+    }
+
+    public void writeBytes(ByteBuffer bytesToWrite) throws IOException {
+        out.write(bytesToWrite.array());
+    }
+
+             public void writeFileOffst(long value) throws IOException {
+                mybuffer.putLong(0, value);
+                out.write(mybuffer.array());
+            }
+
+             public ByteBuffer byteReading(int size) throws IOException {
+                ByteBuffer bytesRead = ByteBuffer.allocate(size);
+                in.read(bytesRead.array(), 0, size);
+                return bytesRead;
+            }
+
+
+             public void SizeWr(int size) throws IOException {
+                mybuffer.putInt(0, size);
+                out.write(mybuffer.array(), 0, Integer.SIZE / 8);
+            }
+
+             public void Clean() throws IOException {
+                ifEmpty = true;
+                in.close();
+                myfile.delete();
+                myfile.createNewFile();
+                out = new BufferedOutputStream(new FileOutputStream(myfile));
+            }
+
+             public void close() throws IOException {
+                if (ifEmpty) {
+                        mybuffer.putInt(0, Integer.MIN_VALUE);
+                        out.write(mybuffer.array(), 0, Integer.SIZE / 8);
+                        out.close();
+                    } else {
+                        in.close();
+                    }
+            }
+
+             public boolean checkIsEmpty() throws IOException {
+                return in.available() == 0;
+            }
+}

homework-g595-zueva/src/main/java/ru/mipt/java2016/homework/g595/zueva/task2/task3/MyOptKVStorage.java

@@ -0,0 +1,96 @@
+package ru.mipt.java2016.homework.g595.zueva.task2.task3;
+
+/**
+ * Created by someb on 17.12.2016.
+ */
+import java.io.*;
+ import java.nio.ByteBuffer;
+
+public class MyOptKVStorage {
+     private BufferedInputStream input;
+     private BufferedOutputStream output;
+     private File storageInstance;
+     private File bufferStorageInstance;
+     private RandomAccessFile randomAccessFile;
+     private ByteBuffer byteBuffer = ByteBuffer.allocate(Integer.SIZE / 8);
+
+             public MyOptKVStorage(String fileDirectory, String fileName) throws IOException {
+                File directory = new File(fileDirectory);
+                if (directory.exists()) {
+                        storageInstance = new File(fileDirectory, fileName);
+                        bufferStorageInstance = new File(fileDirectory, "buffer.db");
+                        storageInstance.createNewFile();
+                        randomAccessFile = new RandomAccessFile(storageInstance, "rw");
+                        /* ! 'true' because we rather write to the end of the file */
+                                output = new BufferedOutputStream(new FileOutputStream(storageInstance, true));
+                    } else {
+                        throw new IllegalStateException("There is no such directory");
+                    }
+            }
+
+             public void writeSizeToStream(int size) throws IOException {
+                byteBuffer.putInt(0, size);
+                output.write(byteBuffer.array());
+            }
+
+             public void writeBytesToStream(ByteBuffer bytesToWrite) throws IOException {
+                output.write(bytesToWrite.array());
+            }
+
+             public void flushStream() throws IOException {
+                output.flush();
+            }
+
+             public int readKey(long offset) throws IOException {
+                randomAccessFile.seek(offset);
+                return randomAccessFile.readInt();
+            }
+
+             public ByteBuffer readBytes(int size) throws IOException {
+                ByteBuffer value = ByteBuffer.allocate(size);
+                randomAccessFile.readFully(value.array());
+                return value;
+            }
+
+             public int readKeyFromStream() throws IOException {
+                if (input.read(byteBuffer.array(), 0, Integer.SIZE / 8) != Integer.SIZE / 8) {
+                        throw new IOException("Error during reading");
+                    }
+                return byteBuffer.getInt(0);
+            }
+
+             public ByteBuffer readValueFromStream(int size) throws IOException {
+                ByteBuffer value = ByteBuffer.allocate(size);
+                if (input.read(value.array(), 0, size) != size) {
+                        throw new IOException("Error during reading");
+                    }
+                return value;
+            }
+
+             public long getLength() throws IOException {
+                return randomAccessFile.length();
+            }
+
+             public void close() throws IOException {
+                byteBuffer.putInt(0, Integer.MIN_VALUE);
+                output.write(byteBuffer.array());
+                output.close();
+                randomAccessFile.close();
+            }
+
+             public void beginUpdate() throws IOException {
+                output.close();
+                randomAccessFile.close();
+                bufferStorageInstance.createNewFile();
+                input = new BufferedInputStream(new FileInputStream(storageInstance));
+                output = new BufferedOutputStream(new FileOutputStream(bufferStorageInstance));
+            }
+
+             public void endUpdate() throws IOException {
+               output.close();
+                input.close();
+                bufferStorageInstance.renameTo(storageInstance);
+                randomAccessFile = new RandomAccessFile(storageInstance, "rw");
+                output = new BufferedOutputStream(new FileOutputStream(storageInstance, true));
+            }
+ }

homework-g595-zueva/src/main/java/ru/mipt/java2016/homework/g595/zueva/task2/task3/OptDoubleSerializer.java

@@ -0,0 +1,24 @@
+package ru.mipt.java2016.homework.g595.zueva.task2.task3;
+
+
+import java.nio.ByteBuffer;
+
+         public class OptDoubleSerializer implements OptKVStorageSerializer<Double> {
+
+            @Override
+    public ByteBuffer srlzToStr(Double value) {
+                ByteBuffer serialized = ByteBuffer.allocate(SrlzSize(value));
+                serialized.putDouble(value);
+                return serialized;
+            }
+
+             @Override
+     public Double desrlzFrStr(ByteBuffer input) {
+                return input.getDouble();
+            }
+
+             @Override
+     public int SrlzSize(Double value) {
+                return Double.SIZE / 8;
+            }
+ }

homework-g595-zueva/src/main/java/ru/mipt/java2016/homework/g595/zueva/task2/task3/OptIntegerSerializer.java

@@ -0,0 +1,20 @@
+package ru.mipt.java2016.homework.g595.zueva.task2.task3;
+import java.nio.ByteBuffer;
+public class OptIntegerSerializer implements OptKVStorageSerializer<Integer> {
+       @Override
+     public ByteBuffer srlzToStr(Integer value) {
+                ByteBuffer serialized = ByteBuffer.allocate(SrlzSize(value));
+                serialized.putInt(value);
+                return serialized;
+            }
+
+             @Override
+     public Integer desrlzFrStr(ByteBuffer input) {
+                return input.getInt();
+            }
+
+             @Override
+     public int SrlzSize(Integer value) {
+               return Integer.SIZE / 8;
+            }
+}