diff --git a/homework-base/src/main/java/ru/mipt/java2016/homework/base/task2/KeyValueStorage.java b/homework-base/src/main/java/ru/mipt/java2016/homework/base/task2/KeyValueStorage.java index bab3d8d97..15a524c40 100644 --- a/homework-base/src/main/java/ru/mipt/java2016/homework/base/task2/KeyValueStorage.java +++ b/homework-base/src/main/java/ru/mipt/java2016/homework/base/task2/KeyValueStorage.java @@ -14,6 +14,7 @@ * @since 04.10.16 */ public interface KeyValueStorage extends Closeable { + /** * Возвращает значение для данного ключа, если оно есть в хранилище. * Иначе возвращает null. diff --git a/homework-g595-zueva/pom.xml b/homework-g595-zueva/pom.xml new file mode 100644 index 000000000..ebbfe1909 --- /dev/null +++ b/homework-g595-zueva/pom.xml @@ -0,0 +1,29 @@ + + + + mipt-java-2016 + ru.mipt.java2016 + 1.0.0 + + 4.0.0 + + homework-g595-zueva + + + + ru.mipt.java2016 + homework-base + 1.0.0 + + + + ru.mipt.java2016 + homework-tests + 1.0.0 + test + + + + \ No newline at end of file diff --git a/homework-g595-zueva/src/main/java/ru/mipt/java2016/homework/g595/zueva/task2/task2/SerializerStorage.java b/homework-g595-zueva/src/main/java/ru/mipt/java2016/homework/g595/zueva/task2/task2/SerializerStorage.java new file mode 100644 index 000000000..6aac27f72 --- /dev/null +++ b/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 { + void writeToStream(DataOutputStream out, T value)throws IOException; + + T readFromStream(DataInputStream in) throws IOException; +} diff --git a/homework-g595-zueva/src/main/java/ru/mipt/java2016/homework/g595/zueva/task2/task2/Serializers.java b/homework-g595-zueva/src/main/java/ru/mipt/java2016/homework/g595/zueva/task2/task2/Serializers.java new file mode 100644 index 000000000..7508d7281 --- /dev/null +++ b/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 { + + + 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 { + + 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 { + + public void writeToStream(DataOutputStream out, Double value) throws IOException { + out.writeDouble(value); + } + + @Override + public Double readFromStream(DataInputStream in) throws IOException { + return in.readDouble(); + } + } +} \ No newline at end of file diff --git a/homework-g595-zueva/src/main/java/ru/mipt/java2016/homework/g595/zueva/task2/task3/FRFile.java b/homework-g595-zueva/src/main/java/ru/mipt/java2016/homework/g595/zueva/task2/task3/FRFile.java new file mode 100644 index 000000000..77d82ee81 --- /dev/null +++ b/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; + } +} diff --git a/homework-g595-zueva/src/main/java/ru/mipt/java2016/homework/g595/zueva/task2/task3/MyOptKVStorage.java b/homework-g595-zueva/src/main/java/ru/mipt/java2016/homework/g595/zueva/task2/task3/MyOptKVStorage.java new file mode 100644 index 000000000..ae1ff7ea3 --- /dev/null +++ b/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)); + } + } \ No newline at end of file diff --git a/homework-g595-zueva/src/main/java/ru/mipt/java2016/homework/g595/zueva/task2/task3/OptDoubleSerializer.java b/homework-g595-zueva/src/main/java/ru/mipt/java2016/homework/g595/zueva/task2/task3/OptDoubleSerializer.java new file mode 100644 index 000000000..7481cb5a7 --- /dev/null +++ b/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 { + + @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; + } + } diff --git a/homework-g595-zueva/src/main/java/ru/mipt/java2016/homework/g595/zueva/task2/task3/OptIntegerSerializer.java b/homework-g595-zueva/src/main/java/ru/mipt/java2016/homework/g595/zueva/task2/task3/OptIntegerSerializer.java new file mode 100644 index 000000000..d2a324584 --- /dev/null +++ b/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 { + @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; + } +} diff --git a/homework-g595-zueva/src/main/java/ru/mipt/java2016/homework/g595/zueva/task2/task3/OptKVStorage.java b/homework-g595-zueva/src/main/java/ru/mipt/java2016/homework/g595/zueva/task2/task3/OptKVStorage.java new file mode 100644 index 000000000..e1d5441df --- /dev/null +++ b/homework-g595-zueva/src/main/java/ru/mipt/java2016/homework/g595/zueva/task2/task3/OptKVStorage.java @@ -0,0 +1,297 @@ +package ru.mipt.java2016.homework.g595.zueva.task2.task3; + +import ru.mipt.java2016.homework.base.task2.KeyValueStorage; +import java.io.File; +import java.io.IOException; +import java.nio.ByteBuffer; +import java.util.HashMap; +import java.util.Iterator; +import java.util.LinkedHashMap; +import java.util.Map; +import java.util.concurrent.locks.Lock; +import java.util.concurrent.locks.ReadWriteLock; +import java.util.concurrent.locks.ReentrantReadWriteLock; + +/** + * find in the cache firstly. + */ +public class OptKVStorage implements KeyValueStorage { + private static final String STORAGE_NAME = "somestorage.db"; + private String FileIn; + private final HashMap offsetTable = new HashMap(); + private ReadWriteLock readWriteLock = new ReentrantReadWriteLock(); + private Lock writeLock = readWriteLock.writeLock(); + private Lock readLock = readWriteLock.readLock(); + private static final String REFERENCE_FILE_NAME = "ref.db"; + private static final String LOCK_FILE_NAME = "locking.db"; + private File LockingMyFile; + private MyOptKVStorage storage; + private FRFile RefFile; + private OptKVStorageSerializer KeySerializer; + private OptKVStorageSerializer ValueSerializer; + private boolean ifOpen = false; + private long StorSize; + private long recordLength; + private long deletedField = 0; + private boolean updated = false; + private LinkedHashMap cache; + private static final int CACHE_SIZE = 1000; + + public OptKVStorage(String fileDirectoryInit, OptKVStorageSerializer keySerializerInit, + OptKVStorageSerializer valueSerializerInit) throws IOException { + ifOpen = true; + KeySerializer = keySerializerInit; + ValueSerializer = valueSerializerInit; + FileIn = fileDirectoryInit; + RefFile = new FRFile(FileIn, REFERENCE_FILE_NAME); + storage = new MyOptKVStorage(FileIn, STORAGE_NAME); + StorSize = storage.getLength(); + recordLength = StorSize - 1; + cache = new LinkedHashMap(); + String lockFilePath = FileIn + File.separator + LOCK_FILE_NAME; + LockingMyFile = new File(lockFilePath); + if (!LockingMyFile.exists()) { + try { + LockingMyFile.createNewFile(); + } catch (Exception e) { + throw new IOException("Failed to create lock file"); + } + } else { + throw new IOException("Somebody is working w/ db right now."); + } + startWorkWithOffsetTable(); + } + @Override + public V read(K key) { + V value; + writeLock.lock(); + try { + checkIfClosed(); + if (cache.containsKey(key)) { + return cache.get(key); + } + if (!exists(key)) { + value = null; + } else { + value = readValue(key); + } + } catch (IOException e) { + value = null; + } finally { + writeLock.unlock(); + } + return value; + } + + /* ! First we look for key in cache, than we try to find it in the storage */ + @Override + public boolean exists(K key) { + readLock.lock(); + try { + checkIfClosed(); + if (cache.containsKey(key)) { + return true; + } + return offsetTable.keySet().contains(key); + } finally { + readLock.unlock(); + } + } + + /* ! First we look for key in cache, if we succeed we upgrade the value ++ * otherwise we put key - value to cache; we put key - value to storage */ + @Override + public void write(K key, V value) { + writeLock.lock(); + try { + checkIfClosed(); + if (cache.containsKey(key)) { + cache.put(key, value); + balanceCache(); + } else { + writeField(key, value); + cache.put(key, value); + balanceCache(); + updated = true; + } + } catch (IOException e) { + throw new IllegalStateException("Error during writing"); + } finally { + writeLock.unlock(); + } + } + + /* ! delete key - value from storage and from cache if needed */ + @Override + public void delete(K key) { + writeLock.lock(); + try { + checkIfClosed(); + if (cache.containsKey(key)) { + cache.remove(key); + } + offsetTable.remove(key); + ++deletedField; + updated = true; + } finally { + writeLock.unlock(); + } + } + + @Override + public Iterator readKeys() { + readLock.lock(); + try { + checkIfClosed(); + return offsetTable.keySet().iterator(); + } finally { + readLock.unlock(); + } + } + + @Override + public int size() { + readLock.lock(); + try { + checkIfClosed(); + return offsetTable.size(); + } finally { + readLock.unlock(); + } + } + + /* ! close files and write changes to the disk */ + @Override + public void close() throws IOException { + writeLock.lock(); + try { + checkIfClosed(); + updateStorageFile(); + storage.close(); + if (updated) { + endWorkWithOffsetTable(); + updated = false; + } + if (LockingMyFile.exists()) { + try { + LockingMyFile.delete(); + } catch (Exception e) { + throw new IOException("Failed to delete lock file"); + } + } + RefFile.close(); + ifOpen = false; + } finally { + writeLock.unlock(); + } + } + + private void startWorkWithOffsetTable() throws IOException { + if (!RefFile.checkIsEmpty()) { + int counter = RefFile.readKey(); + while (counter > 0) { + K key = KeySerializer.desrlzFrStr(RefFile.byteReading(counter)); + long offset = RefFile.ReadFileOffst(); + offsetTable.put(key, offset); + counter = RefFile.readKey(); + } + } + } + + private void endWorkWithOffsetTable() throws IOException { + RefFile.Clean(); + for (HashMap.Entry iterator : offsetTable.entrySet()) { + RefFile.SizeWr(KeySerializer.SrlzSize(iterator.getKey())); + RefFile.writeBytes(KeySerializer.srlzToStr(iterator.getKey())); + RefFile.writeFileOffst(iterator.getValue()); + } + offsetTable.clear(); + if (LockingMyFile.exists()) { + try { + LockingMyFile.delete(); + } catch (Exception e) { + throw new IOException("Failed to delete lock file"); + } + } + } + + private void checkFreeSpace(long offset) throws IOException { + if (offset > recordLength) { + storage.flushStream(); + recordLength = StorSize - 1; + } + } + + private V readValue(K key) throws IOException { + long offset = offsetTable.get(key); + checkFreeSpace(offset); + int serializedKey = storage.readKey(offset); + return ValueSerializer.desrlzFrStr(storage.readBytes(serializedKey)); + } + + private void writeOffsetField(K key) throws IOException { + offsetTable.put(key, KeySerializer.SrlzSize(key) + Integer.SIZE / 8 + StorSize); + } + + private void writeKey(K key) throws IOException { + storage.writeSizeToStream(KeySerializer.SrlzSize(key)); + storage.writeBytesToStream(KeySerializer.srlzToStr(key)); + } + + private void writeValue(V value) throws IOException { + storage.writeSizeToStream(ValueSerializer.SrlzSize(value)); + storage.writeBytesToStream(ValueSerializer.srlzToStr(value)); + } + + private void updateStorageLength(K key, V value) throws IOException { + StorSize = StorSize + Integer.SIZE / 8 + KeySerializer.SrlzSize(key) + + Integer.SIZE / 8 + ValueSerializer.SrlzSize(value); + } + + private void writeField(K key, V value) throws IOException { + writeOffsetField(key); + writeKey(key); + writeValue(value); + updateStorageLength(key, value); + } + + private void updateStorageFile() throws IOException { + if (deletedField > 4 * offsetTable.size()) { + storage.beginUpdate(); + StorSize = 0; + long oldFileOffset = 0; + int keySize = storage.readKeyFromStream(); + while (keySize > 0) { + ByteBuffer serializedKey = storage.readValueFromStream(keySize); + K key = KeySerializer.desrlzFrStr(serializedKey); + int valueSize = storage.readKeyFromStream(); + ByteBuffer value = storage.readValueFromStream(valueSize); + if (offsetTable.containsKey(key) && offsetTable.get(key).equals(oldFileOffset)) { + writeField(key, ValueSerializer.desrlzFrStr(value)); + } + oldFileOffset = oldFileOffset + Integer.SIZE / 8 + Integer.SIZE / 8 + keySize + valueSize; + keySize = storage.readKeyFromStream(); + } + storage.endUpdate(); + } + } + + private void checkIfClosed() { + if (!ifOpen) { + throw new IllegalStateException("Impossible to work with closed storage"); + } + } + + /* ! method for controlling cache size */ + private void balanceCache() { + if (cache.size() > CACHE_SIZE) { + Iterator> iterator = cache.entrySet().iterator(); + iterator.next(); + iterator.remove(); + } + } +} + + + + diff --git a/homework-g595-zueva/src/main/java/ru/mipt/java2016/homework/g595/zueva/task2/task3/OptKVStorageSerializer.java b/homework-g595-zueva/src/main/java/ru/mipt/java2016/homework/g595/zueva/task2/task3/OptKVStorageSerializer.java new file mode 100644 index 000000000..4b715d75d --- /dev/null +++ b/homework-g595-zueva/src/main/java/ru/mipt/java2016/homework/g595/zueva/task2/task3/OptKVStorageSerializer.java @@ -0,0 +1,10 @@ +package ru.mipt.java2016.homework.g595.zueva.task2.task3; + +import java.nio.ByteBuffer; +public interface OptKVStorageSerializer { + int SrlzSize(K value); + + ByteBuffer srlzToStr(K value); + + K desrlzFrStr(ByteBuffer input); +} diff --git a/homework-g595-zueva/src/main/java/ru/mipt/java2016/homework/g595/zueva/task2/task3/OptStrSerializer.java b/homework-g595-zueva/src/main/java/ru/mipt/java2016/homework/g595/zueva/task2/task3/OptStrSerializer.java new file mode 100644 index 000000000..5b360171c --- /dev/null +++ b/homework-g595-zueva/src/main/java/ru/mipt/java2016/homework/g595/zueva/task2/task3/OptStrSerializer.java @@ -0,0 +1,18 @@ +package ru.mipt.java2016.homework.g595.zueva.task2.task3; +import java.nio.ByteBuffer; +public class OptStrSerializer implements OptKVStorageSerializer { + @Override + public ByteBuffer srlzToStr(String value) { + return ByteBuffer.wrap(value.getBytes()); + } + + @Override + public String desrlzFrStr(ByteBuffer input) { + return new String(input.array()); + } + + @Override + public int SrlzSize(String value) { + return value.length(); + } +} diff --git a/homework-g595-zueva/src/main/java/ru/mipt/java2016/homework/g595/zueva/task2/task3/OptStrSerializerStudentStudentKey.java b/homework-g595-zueva/src/main/java/ru/mipt/java2016/homework/g595/zueva/task2/task3/OptStrSerializerStudentStudentKey.java new file mode 100644 index 000000000..a11300328 --- /dev/null +++ b/homework-g595-zueva/src/main/java/ru/mipt/java2016/homework/g595/zueva/task2/task3/OptStrSerializerStudentStudentKey.java @@ -0,0 +1,30 @@ +package ru.mipt.java2016.homework.g595.zueva.task2.task3; + +import java.nio.ByteBuffer; +public class OptStrSerializerStudentStudentKey implements OptKVStorageSerializer { + @Override + public int SrlzSize(String value) { + return 2 * (value.length() + 1); + } + + @Override + public ByteBuffer srlzToStr(String value) { + ByteBuffer serialized = ByteBuffer.allocate(SrlzSize(value)); + for (char c : value.toCharArray()) { + serialized.putChar(c); + } + serialized.putChar('\0'); + return serialized; + } + + @Override + public String desrlzFrStr(ByteBuffer input) { + StringBuilder deserialized = new StringBuilder(); + char c = input.getChar(); + while (c != '\0') { + deserialized.append(c); + c = input.getChar(); + } + return deserialized.toString(); + } +} diff --git a/homework-g595-zueva/src/main/java/ru/mipt/java2016/homework/g595/zueva/task2/task3/testing.java b/homework-g595-zueva/src/main/java/ru/mipt/java2016/homework/g595/zueva/task2/task3/testing.java new file mode 100644 index 000000000..8f56b4452 --- /dev/null +++ b/homework-g595-zueva/src/main/java/ru/mipt/java2016/homework/g595/zueva/task2/task3/testing.java @@ -0,0 +1,26 @@ +package ru.mipt.java2016.homework.g595.zueva.task2.task3; +import java.io.IOException; +public class testing { + + public static void main(String[] args) { + OptKVStorage fst = + null; + try { + fst = new OptKVStorage("/home/king", new OptIntegerSerializer(), new OptIntegerSerializer()); + } catch (IOException e) { + e.printStackTrace(); + } + fst.write(5, 5); + OptKVStorage snd = + null; + try { + snd = new OptKVStorage("/something", new OptIntegerSerializer(), new OptIntegerSerializer()); + } catch (IOException e) { + e.printStackTrace(); + } + snd.write(6, 6); + snd.write(5, 6); + System.out.println(fst.read(5)); + System.out.println(snd.read(6)); + } +} diff --git a/homework-g595-zueva/src/test/java/ru/mipt/java/homework/g595/zueva/task3/FastKeyValueStorageTest.java b/homework-g595-zueva/src/test/java/ru/mipt/java/homework/g595/zueva/task3/FastKeyValueStorageTest.java new file mode 100644 index 000000000..5ee1a3fe0 --- /dev/null +++ b/homework-g595-zueva/src/test/java/ru/mipt/java/homework/g595/zueva/task3/FastKeyValueStorageTest.java @@ -0,0 +1,39 @@ +package ru.mipt.java.homework.g595.zueva.task3; + +import ru.mipt.java2016.homework.base.task2.KeyValueStorage; +import ru.mipt.java2016.homework.tests.task2.Student; +import ru.mipt.java2016.homework.tests.task2.StudentKey; +import ru.mipt.java2016.homework.base.task2.MalformedDataException; +import ru.mipt.java2016.homework.tests.task3.KeyValueStoragePerformanceTest; +/** + * Created by someb on 17.12.2016. + */ +public class FastKeyValueStorageTest extends KeyValueStoragePerformanceTest{ + @Override + protected KeyValueStorage buildStringsStorage(String path) throws MalformedDataException { + try { + return new FastKeyValueStorageImpl(path, new FastStringSerializer(), new FastStringSerializer()); + } catch (IOException e) { + return null; + } + } + + @Override + protected KeyValueStorage buildNumbersStorage(String path) throws MalformedDataException { + try { + return new FastKeyValueStorageImpl(path, new FastIntegerSerializer(), new FastDoubleSerializer()); + } catch (IOException e) { + return null; + } + } + + @Override + protected KeyValueStorage buildPojoStorage(String path) throws MalformedDataException { + try { + return new FastKeyValueStorageImpl(path, new FastStudentKeySerializer(), new FastStudentSerializer()); + } catch (IOException e) { + return null; + } + } +} +} diff --git a/homework-g595-zueva/src/test/java/ru/mipt/java/homework/g595/zueva/task3/FastKeyValueStudentKeySerializer.java b/homework-g595-zueva/src/test/java/ru/mipt/java/homework/g595/zueva/task3/FastKeyValueStudentKeySerializer.java new file mode 100644 index 000000000..4f9921a11 --- /dev/null +++ b/homework-g595-zueva/src/test/java/ru/mipt/java/homework/g595/zueva/task3/FastKeyValueStudentKeySerializer.java @@ -0,0 +1,44 @@ +package ru.mipt.java.homework.g595.zueva.task3; + +import ru.mipt.java2016.homework.g595.zueva.task2.task3.OptKVStorageSerializer; +import ru.mipt.java2016.homework.tests.task2.Student; +import ru.mipt.java2016.homework.tests.task2.StudentKey; + +import java.nio.ByteBuffer; +import java.util.Date; +public class FastKeyValueStudentKeySerializer implements OptKVStorageSerializer { + @Override + public ByteBuffer srlzToStr(Student value) { + ByteBuffer serialized = ByteBuffer.allocate(SrlzSize(value)); + FastStudentKeySerializer studentKeySerializer = new FastStudentKeySerializer(); + serialized.put(studentKeySerializer.serializeToStream(new StudentKey(value.getGroupId(), + value.getName())).array()); + FastStringSerializerForStudentKeyAndStudent fastStringSerializerForStudentKeyAndStudent = + new FastStringSerializerForStudentKeyAndStudent(); + serialized.put(fastStringSerializerForStudentKeyAndStudent.serializeToStream(value.getHometown()).array()); + serialized.putLong(value.getBirthDate().getTime()); + if (value.isHasDormitory()) { + serialized.put((byte) 1); + } else { + serialized.put((byte) 0); + } + serialized.putDouble(value.getAverageScore()); + return serialized; + } + + @Override + public Student desrlzFrStr(ByteBuffer input) { + FastStringSerializerForStudentKeyAndStudent fastStringSerializerForStudentKeyAndStudent = + new FastStringSerializerForStudentKeyAndStudent(); + return new Student(input.getInt(), + fastStringSerializerForStudentKeyAndStudent.deserializeFromStream(input), + fastStringSerializerForStudentKeyAndStudent.deserializeFromStream(input), + new Date(input.getLong()), (input.get() == 1), input.getDouble()); + } + + @Override + public int SrlzSize(Student value) { + return Integer.SIZE / 8 + 2 * (value.getName().length() + 1) + + 2 * (value.getHometown().length() + 1) + Long.SIZE / 8 + 1 + Double.SIZE / 8; + } +} diff --git a/homework-g595-zueva/src/test/java/ru/mipt/java/homework/g595/zueva/task3/FastKeyValueStudentSerializer.java b/homework-g595-zueva/src/test/java/ru/mipt/java/homework/g595/zueva/task3/FastKeyValueStudentSerializer.java new file mode 100644 index 000000000..33ba83c29 --- /dev/null +++ b/homework-g595-zueva/src/test/java/ru/mipt/java/homework/g595/zueva/task3/FastKeyValueStudentSerializer.java @@ -0,0 +1,35 @@ +package ru.mipt.java.homework.g595.zueva.task3; + +import ru.mipt.java2016.homework.g595.zueva.task2.task3.OptKVStorageSerializer; +import ru.mipt.java2016.homework.g595.zueva.task2.task3.OptStrSerializerStudentStudentKey; +import ru.mipt.java2016.homework.tests.task2.Student; +import ru.mipt.java2016.homework.tests.task2.StudentKey; + +import java.nio.ByteBuffer; + +public class FastKeyValueStudentSerializer implements OptKVStorageSerializer { + @Override + public StudentKey desrlzFrStr(ByteBuffer input) { + OptStrSerializerStudentStudentKey fastStringSerializerForStudentKeyAndStudent = + new OptStrSerializerStudentStudentKey(); + return new StudentKey(input.getInt(), fastStringSerializerForStudentKeyAndStudent.desrlzFrStr(input)); + } + @Override + public int SrlzSize(Student value) { + return Integer.SIZE / 8 + 2 * (value.getName().length() + 1); + } + + @Override + public ByteBuffer srlzToStr(Student value) { + ByteBuffer serialized = ByteBuffer.allocate(SrlzSize(value)); + serialized.putInt(value.getGroupId()); + OptStrSerializerStudentStudentKey fastStringSerializerForStudentKeyAndStudent = + new OptStrSerializerStudentStudentKey(); + serialized.put(fastStringSerializerForStudentKeyAndStudent.srlzToStr(value.getName()).array()); + return serialized; + } + + + + +} diff --git a/homework-tests/src/main/java/ru/mipt/java2016/homework/tests/task1/AbstractCalculatorTest.java b/homework-tests/src/main/java/ru/mipt/java2016/homework/tests/task1/AbstractCalculatorTest.java index 6d06e3186..b27d7c5c0 100644 --- a/homework-tests/src/main/java/ru/mipt/java2016/homework/tests/task1/AbstractCalculatorTest.java +++ b/homework-tests/src/main/java/ru/mipt/java2016/homework/tests/task1/AbstractCalculatorTest.java @@ -155,8 +155,4 @@ public void testUnaryMultiply() throws ParsingException { public void testBadNumber() throws ParsingException { tryFail("1.2.3"); } -/*<<<<<<< HEAD -======= - ->>>>>>> upstream/master*/ } \ No newline at end of file diff --git a/pom.xml b/pom.xml index 0b1bce4c9..6d417c92d 100644 --- a/pom.xml +++ b/pom.xml @@ -17,6 +17,7 @@ homework-g597-povarnitsyn homework-g596-kupriyanov homework-g595-kryloff + homework-g595-zueva homework-g596-kravets homework-g596-litvinov homework-g594-kozlov @@ -83,9 +84,11 @@ homework-g597-grishutin homework-g595-tkachenko homework-g597-miller + homework-g596-pockonechny homework-g597-smirnova homework-g596-grebenshchikova homework-g597-kochukov + homework-g597-sigareva workshop-materials @@ -267,4 +270,4 @@ - + \ No newline at end of file