From 5fc30d91c040f30607dc0b19f0739d8336cb0c3a Mon Sep 17 00:00:00 2001 From: Vadim Tsesko Date: Sun, 1 Oct 2023 13:44:57 +0300 Subject: [PATCH 01/45] Restore test timeout due to slow runners --- src/test/java/ru/vk/itmo/DaoTest.java | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/test/java/ru/vk/itmo/DaoTest.java b/src/test/java/ru/vk/itmo/DaoTest.java index 4e5249d3f..bd855d09e 100644 --- a/src/test/java/ru/vk/itmo/DaoTest.java +++ b/src/test/java/ru/vk/itmo/DaoTest.java @@ -36,7 +36,7 @@ @ParameterizedTest @ArgumentsSource(DaoTest.DaoList.class) @ExtendWith(DaoTest.DaoList.class) -@Timeout(5) +@Timeout(10) public @interface DaoTest { int stage(); From 657ea75679588c2d4d2cf633bae97e24671c74a6 Mon Sep 17 00:00:00 2001 From: Vadim Tsesko Date: Sun, 1 Oct 2023 14:14:20 +0300 Subject: [PATCH 02/45] Disable codeclimate duplication plugin to be able to use reference --- .codeclimate.yml | 5 +++++ 1 file changed, 5 insertions(+) diff --git a/.codeclimate.yml b/.codeclimate.yml index 1a722351a..54a4a3c82 100644 --- a/.codeclimate.yml +++ b/.codeclimate.yml @@ -1,5 +1,10 @@ version: "2" plugins: + duplication: + enabled: false + config: + languages: + java: checkstyle: enabled: true config: From 6971fd8f7ab899768dfb094ff1efc35dcf89799f Mon Sep 17 00:00:00 2001 From: Sevastian Trutnev <30924194+sevabeat@users.noreply.github.com> Date: Sun, 1 Oct 2023 22:00:46 +0300 Subject: [PATCH 03/45] =?UTF-8?q?=D0=A2=D1=80=D1=83=D1=82=D0=BD=D0=B5?= =?UTF-8?q?=D0=B2=20=D0=A1=D0=B5=D0=B2=D0=B0=D1=81=D1=82=D1=8C=D1=8F=D0=BD?= =?UTF-8?q?=20=D0=9E=D0=BB=D0=B5=D0=B3=D0=BE=D0=B2=D0=B8=D1=87.=20=D0=98?= =?UTF-8?q?=D0=A2=D0=9C=D0=9E=20DWS.=20=D0=97=D0=B0=D0=B4=D0=B0=D0=BD?= =?UTF-8?q?=D0=B8=D0=B5=20#1=20(#55)?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- .../test/trutnevsevastian/DaoFactoryImpl.java | 40 ++++++++++++ .../vk/itmo/trutnevsevastian/InMemoryDao.java | 62 +++++++++++++++++++ 2 files changed, 102 insertions(+) create mode 100644 src/main/java/ru/vk/itmo/test/trutnevsevastian/DaoFactoryImpl.java create mode 100644 src/main/java/ru/vk/itmo/trutnevsevastian/InMemoryDao.java diff --git a/src/main/java/ru/vk/itmo/test/trutnevsevastian/DaoFactoryImpl.java b/src/main/java/ru/vk/itmo/test/trutnevsevastian/DaoFactoryImpl.java new file mode 100644 index 000000000..f819c99d0 --- /dev/null +++ b/src/main/java/ru/vk/itmo/test/trutnevsevastian/DaoFactoryImpl.java @@ -0,0 +1,40 @@ +package ru.vk.itmo.test.trutnevsevastian; + +import ru.vk.itmo.Dao; +import ru.vk.itmo.Entry; +import ru.vk.itmo.test.DaoFactory; +import ru.vk.itmo.trutnevsevastian.InMemoryDao; + +import java.lang.foreign.MemorySegment; +import java.lang.foreign.ValueLayout; +import java.nio.charset.StandardCharsets; + +@DaoFactory +public class DaoFactoryImpl implements DaoFactory.Factory> { + + @Override + public Dao> createDao() { + return new InMemoryDao(); + } + + @Override + public String toString(MemorySegment data) { + if (data == null) { + return null; + } + return new String(data.toArray(ValueLayout.JAVA_BYTE), StandardCharsets.UTF_8); + } + + @Override + public MemorySegment fromString(String data) { + if (data == null) { + return null; + } + return MemorySegment.ofArray(data.getBytes(StandardCharsets.UTF_8)); + } + + @Override + public Entry fromBaseEntry(Entry baseEntry) { + return baseEntry; + } +} diff --git a/src/main/java/ru/vk/itmo/trutnevsevastian/InMemoryDao.java b/src/main/java/ru/vk/itmo/trutnevsevastian/InMemoryDao.java new file mode 100644 index 000000000..7897e36f1 --- /dev/null +++ b/src/main/java/ru/vk/itmo/trutnevsevastian/InMemoryDao.java @@ -0,0 +1,62 @@ +package ru.vk.itmo.trutnevsevastian; + +import ru.vk.itmo.Dao; +import ru.vk.itmo.Entry; + +import java.lang.foreign.MemorySegment; +import java.lang.foreign.ValueLayout; +import java.util.Comparator; +import java.util.Iterator; +import java.util.Map; +import java.util.NavigableMap; +import java.util.concurrent.ConcurrentSkipListMap; + +public class InMemoryDao implements Dao> { + + private final NavigableMap> storage = + new ConcurrentSkipListMap<>(new MemorySegmentComparator()); + + @Override + public Iterator> get(MemorySegment from, MemorySegment to) { + return subMap(from, to).values().iterator(); + } + + private Map> subMap(MemorySegment from, MemorySegment to) { + if (from == null && to == null) { + return storage; + } + if (from == null) { + return storage.headMap(to); + } + if (to == null) { + return storage.tailMap(from, true); + } + + return storage.subMap(from, true, to, false); + } + + @Override + public void upsert(Entry entry) { + storage.put(entry.key(), entry); + } + + @Override + public Entry get(MemorySegment key) { + return storage.get(key); + } + + private static class MemorySegmentComparator implements Comparator { + @Override + public int compare(MemorySegment o1, MemorySegment o2) { + long lim = Math.min(o1.byteSize(), o2.byteSize()); + long k = MemorySegment.mismatch(o1, 0, lim, o2, 0, lim); + if (k >= 0) { + return o1.get(ValueLayout.JAVA_BYTE, k) - o2.get(ValueLayout.JAVA_BYTE, k); + } + if (o1.byteSize() == o2.byteSize()) { + return 0; + } + return o1.byteSize() < o2.byteSize() ? -1 : 1; + } + } +} From 52b3fd044c8813738b3694412919a2edcd822c12 Mon Sep 17 00:00:00 2001 From: Gamzat Gadzhimagomedov Date: Sun, 1 Oct 2023 22:01:10 +0300 Subject: [PATCH 04/45] Gamzat Gadzhimagomedov ITMO DWS. HW #1 (#56) --- .../gamzatgadzhimagomedov/InMemoryDao.java | 47 +++++++++++++++++++ .../MemorySegmentComparator.java | 28 +++++++++++ .../InMemoryDaoFactory.java | 36 ++++++++++++++ 3 files changed, 111 insertions(+) create mode 100644 src/main/java/ru/vk/itmo/gamzatgadzhimagomedov/InMemoryDao.java create mode 100644 src/main/java/ru/vk/itmo/gamzatgadzhimagomedov/MemorySegmentComparator.java create mode 100644 src/main/java/ru/vk/itmo/test/gamzatgadzhimagomedov/InMemoryDaoFactory.java diff --git a/src/main/java/ru/vk/itmo/gamzatgadzhimagomedov/InMemoryDao.java b/src/main/java/ru/vk/itmo/gamzatgadzhimagomedov/InMemoryDao.java new file mode 100644 index 000000000..f86dfe3ef --- /dev/null +++ b/src/main/java/ru/vk/itmo/gamzatgadzhimagomedov/InMemoryDao.java @@ -0,0 +1,47 @@ +package ru.vk.itmo.gamzatgadzhimagomedov; + +import ru.vk.itmo.Dao; +import ru.vk.itmo.Entry; + +import java.lang.foreign.MemorySegment; +import java.util.Iterator; +import java.util.NavigableMap; +import java.util.concurrent.ConcurrentNavigableMap; +import java.util.concurrent.ConcurrentSkipListMap; + +public class InMemoryDao implements Dao> { + + private final ConcurrentNavigableMap> mem; + + public InMemoryDao() { + this.mem = new ConcurrentSkipListMap<>(new MemorySegmentComparator()); + } + + private NavigableMap> subMap(MemorySegment from, MemorySegment to) { + if (from != null && to != null) { + return mem.subMap(from, to); + } + if (from != null) { + return mem.tailMap(from, true); + } + if (to != null) { + return mem.headMap(to, false); + } + return mem; + } + + @Override + public Iterator> get(MemorySegment from, MemorySegment to) { + return subMap(from, to).values().iterator(); + } + + @Override + public Entry get(MemorySegment key) { + return mem.get(key); + } + + @Override + public void upsert(Entry entry) { + mem.put(entry.key(), entry); + } +} diff --git a/src/main/java/ru/vk/itmo/gamzatgadzhimagomedov/MemorySegmentComparator.java b/src/main/java/ru/vk/itmo/gamzatgadzhimagomedov/MemorySegmentComparator.java new file mode 100644 index 000000000..ceafa2f67 --- /dev/null +++ b/src/main/java/ru/vk/itmo/gamzatgadzhimagomedov/MemorySegmentComparator.java @@ -0,0 +1,28 @@ +package ru.vk.itmo.gamzatgadzhimagomedov; + +import java.lang.foreign.MemorySegment; +import java.lang.foreign.ValueLayout; +import java.util.Comparator; + +public class MemorySegmentComparator implements Comparator { + + @Override + public int compare(MemorySegment o1, MemorySegment o2) { + + long index = o1.mismatch(o2); + if (index == o1.byteSize()) { + return -1; + } + if (index == o2.byteSize()) { + return 1; + } + if (index == -1) { + return 0; + } + + return Byte.compare( + o1.get(ValueLayout.JAVA_BYTE, index), + o2.get(ValueLayout.JAVA_BYTE, index) + ); + } +} diff --git a/src/main/java/ru/vk/itmo/test/gamzatgadzhimagomedov/InMemoryDaoFactory.java b/src/main/java/ru/vk/itmo/test/gamzatgadzhimagomedov/InMemoryDaoFactory.java new file mode 100644 index 000000000..add7e3c52 --- /dev/null +++ b/src/main/java/ru/vk/itmo/test/gamzatgadzhimagomedov/InMemoryDaoFactory.java @@ -0,0 +1,36 @@ +package ru.vk.itmo.test.gamzatgadzhimagomedov; + +import ru.vk.itmo.Dao; +import ru.vk.itmo.Entry; +import ru.vk.itmo.gamzatgadzhimagomedov.InMemoryDao; +import ru.vk.itmo.test.DaoFactory; + +import java.lang.foreign.MemorySegment; +import java.lang.foreign.ValueLayout; +import java.nio.charset.StandardCharsets; + +@DaoFactory +public class InMemoryDaoFactory implements DaoFactory.Factory> { + + @Override + public Dao> createDao() { + return new InMemoryDao(); + } + + @Override + public String toString(MemorySegment data) { + return data == null ? null : + new String(data.toArray(ValueLayout.JAVA_BYTE), StandardCharsets.UTF_8); + } + + @Override + public MemorySegment fromString(String data) { + return data == null ? null : + MemorySegment.ofArray(data.getBytes(StandardCharsets.UTF_8)); + } + + @Override + public Entry fromBaseEntry(Entry baseEntry) { + return baseEntry; + } +} From 0416434965e496ef3f061043d4a463bcddfc23a9 Mon Sep 17 00:00:00 2001 From: Handiesto <67788642+Handiesto@users.noreply.github.com> Date: Sun, 1 Oct 2023 22:04:26 +0300 Subject: [PATCH 05/45] =?UTF-8?q?=D0=9F=D0=BB=D1=8F=D1=81=D0=BE=D0=B2=20?= =?UTF-8?q?=D0=9A=D0=BB=D0=B8=D0=BC=D0=B5=D0=BD=D1=82=D0=B8=D0=B9,=20?= =?UTF-8?q?=D0=9C=D0=B0=D0=B3=D0=B8=D1=81=D1=82=D1=80=D0=B0=D1=82=D1=83?= =?UTF-8?q?=D1=80=D0=B0=20=D0=98=D0=A2=D0=9C=D0=9E=20"=D0=A0=D0=B0=D1=81?= =?UTF-8?q?=D0=BF=D1=80=D0=B5=D0=B4=D0=B5=D0=BB=D0=B5=D0=BD=D0=BD=D1=8B?= =?UTF-8?q?=D0=B5=20=D0=B2=D0=B5=D0=B1-=D1=81=D0=B5=D1=80=D0=B2=D0=B8?= =?UTF-8?q?=D1=81=D1=8B",=20=D0=9B=D0=B0=D0=B1=201=20(#53)?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- .../vk/itmo/plyasovklimentii/InMemoryDao.java | 40 ++++++++++++++++++ .../plyasovklimentii/MemoryComparator.java | 29 +++++++++++++ .../itmo/test/plyasovklimentii/MyFactory.java | 41 +++++++++++++++++++ 3 files changed, 110 insertions(+) create mode 100644 src/main/java/ru/vk/itmo/plyasovklimentii/InMemoryDao.java create mode 100644 src/main/java/ru/vk/itmo/plyasovklimentii/MemoryComparator.java create mode 100644 src/main/java/ru/vk/itmo/test/plyasovklimentii/MyFactory.java diff --git a/src/main/java/ru/vk/itmo/plyasovklimentii/InMemoryDao.java b/src/main/java/ru/vk/itmo/plyasovklimentii/InMemoryDao.java new file mode 100644 index 000000000..739c8366e --- /dev/null +++ b/src/main/java/ru/vk/itmo/plyasovklimentii/InMemoryDao.java @@ -0,0 +1,40 @@ +package ru.vk.itmo.plyasovklimentii; + +import ru.vk.itmo.Dao; +import ru.vk.itmo.Entry; + +import java.lang.foreign.MemorySegment; +import java.util.Iterator; +import java.util.concurrent.ConcurrentSkipListMap; + +public class InMemoryDao implements Dao> { + + private final ConcurrentSkipListMap> storage; + + public InMemoryDao() { + this.storage = new ConcurrentSkipListMap<>(new MemoryComparator()); + } + + @Override + public Entry get(MemorySegment key) { + return storage.get(key); + } + + @Override + public Iterator> get(MemorySegment from, MemorySegment to) { + if (from == null && to == null) { + return storage.sequencedValues().iterator(); + } else if (from == null) { + return storage.headMap(to, false).sequencedValues().iterator(); + } else if (to == null) { + return storage.tailMap(from, true).sequencedValues().iterator(); + } else { + return storage.subMap(from,true, to, false).sequencedValues().iterator(); + } + } + + @Override + public void upsert(Entry entry) { + storage.put(entry.key(), entry); + } +} diff --git a/src/main/java/ru/vk/itmo/plyasovklimentii/MemoryComparator.java b/src/main/java/ru/vk/itmo/plyasovklimentii/MemoryComparator.java new file mode 100644 index 000000000..a8478afb3 --- /dev/null +++ b/src/main/java/ru/vk/itmo/plyasovklimentii/MemoryComparator.java @@ -0,0 +1,29 @@ +package ru.vk.itmo.plyasovklimentii; + +import java.lang.foreign.MemorySegment; +import java.util.Comparator; +import java.util.Objects; + +import static java.lang.foreign.ValueLayout.JAVA_BYTE; + +public class MemoryComparator implements Comparator { + @Override + public int compare(MemorySegment s1, MemorySegment s2) { + Objects.requireNonNull(s1); + Objects.requireNonNull(s2); + + long mismatchCount = s1.mismatch(s2); + + if (mismatchCount < 0) { + return 0; + } + if (mismatchCount == s1.byteSize()) { + return -1; + } + if (mismatchCount == s2.byteSize()) { + return 1; + } + + return Byte.compare(s1.get(JAVA_BYTE, mismatchCount), s2.get(JAVA_BYTE, mismatchCount)); + } +} diff --git a/src/main/java/ru/vk/itmo/test/plyasovklimentii/MyFactory.java b/src/main/java/ru/vk/itmo/test/plyasovklimentii/MyFactory.java new file mode 100644 index 000000000..4a0467262 --- /dev/null +++ b/src/main/java/ru/vk/itmo/test/plyasovklimentii/MyFactory.java @@ -0,0 +1,41 @@ +package ru.vk.itmo.test.plyasovklimentii; + +import ru.vk.itmo.Dao; +import ru.vk.itmo.Entry; +import ru.vk.itmo.plyasovklimentii.InMemoryDao; +import ru.vk.itmo.test.DaoFactory; + +import java.lang.foreign.MemorySegment; +import java.lang.foreign.ValueLayout; +import java.nio.charset.StandardCharsets; + +@DaoFactory +public class MyFactory implements DaoFactory.Factory> { + @Override + public Dao> createDao() { + return new InMemoryDao(); + } + + @Override + public String toString(MemorySegment memorySegment) { + if (memorySegment == null) { + return null; + } + return new String(memorySegment.toArray(ValueLayout.JAVA_BYTE), StandardCharsets.UTF_8); + } + + @Override + public MemorySegment fromString(String data) { + if (data == null) { + return null; + } else { + return MemorySegment.ofArray(data.getBytes(StandardCharsets.UTF_8)); + } + + } + + @Override + public Entry fromBaseEntry(Entry baseEntry) { + return baseEntry; + } +} From a4eaed35c8580c644fd920ad8af4900e823735d1 Mon Sep 17 00:00:00 2001 From: Kamron <64926443+Boturkhonov@users.noreply.github.com> Date: Sun, 1 Oct 2023 22:10:12 +0300 Subject: [PATCH 06/45] Boturkhonov Kamron DWS-23, ITMO, stage 1 (#52) --- .../itmo/boturkhonovkamron/InMemoryDao.java | 49 +++++++++++++++++++ .../MemorySegmentComparator.java | 32 ++++++++++++ .../boturkhonovkamron/InMemoryDaoFactory.java | 41 ++++++++++++++++ 3 files changed, 122 insertions(+) create mode 100644 src/main/java/ru/vk/itmo/boturkhonovkamron/InMemoryDao.java create mode 100644 src/main/java/ru/vk/itmo/boturkhonovkamron/MemorySegmentComparator.java create mode 100644 src/main/java/ru/vk/itmo/test/boturkhonovkamron/InMemoryDaoFactory.java diff --git a/src/main/java/ru/vk/itmo/boturkhonovkamron/InMemoryDao.java b/src/main/java/ru/vk/itmo/boturkhonovkamron/InMemoryDao.java new file mode 100644 index 000000000..537780c31 --- /dev/null +++ b/src/main/java/ru/vk/itmo/boturkhonovkamron/InMemoryDao.java @@ -0,0 +1,49 @@ +package ru.vk.itmo.boturkhonovkamron; + +import ru.vk.itmo.Dao; +import ru.vk.itmo.Entry; + +import java.lang.foreign.MemorySegment; +import java.util.Iterator; +import java.util.concurrent.ConcurrentNavigableMap; +import java.util.concurrent.ConcurrentSkipListMap; + +/** + * Реализация интерфейса Dao для работы с объектами типа MemorySegment в памяти. + * + * @author Kamron Boturkhonov + * @since 2023.09.26 + */ +public class InMemoryDao implements Dao> { + + final ConcurrentNavigableMap> data; + + public InMemoryDao() { + data = new ConcurrentSkipListMap<>(new MemorySegmentComparator()); + } + + @Override + public Entry get(final MemorySegment key) { + return data.get(key); + } + + @Override + public Iterator> get(final MemorySegment from, final MemorySegment to) { + final ConcurrentNavigableMap> subMap; + if (from == null && to == null) { + subMap = data; + } else if (from == null) { + subMap = data.headMap(to, false); + } else if (to == null) { + subMap = data.tailMap(from, true); + } else { + subMap = data.subMap(from, to); + } + return subMap.values().iterator(); + } + + @Override + public void upsert(final Entry entry) { + data.merge(entry.key(), entry, (oldValue, newValue) -> newValue); + } +} diff --git a/src/main/java/ru/vk/itmo/boturkhonovkamron/MemorySegmentComparator.java b/src/main/java/ru/vk/itmo/boturkhonovkamron/MemorySegmentComparator.java new file mode 100644 index 000000000..2cac2f930 --- /dev/null +++ b/src/main/java/ru/vk/itmo/boturkhonovkamron/MemorySegmentComparator.java @@ -0,0 +1,32 @@ +package ru.vk.itmo.boturkhonovkamron; + +import java.lang.foreign.MemorySegment; +import java.lang.foreign.ValueLayout; +import java.util.Comparator; + +/** + * Реализация компаратора для сравнения объектов типа MemorySegment. + * + * @author Kamron Boturkhonov + * @since 2023.09.27 + */ +public class MemorySegmentComparator implements Comparator { + + @Override + public int compare(final MemorySegment left, final MemorySegment right) { + if (left == null || right == null) { + return left == null ? -1 : 1; + } + if (left.equals(right)) { + return 0; + } + final long leftSize = left.byteSize(); + final long rightSize = right.byteSize(); + final long mismatch = left.mismatch(right); + if (mismatch >= 0 && leftSize != mismatch && rightSize != mismatch) { + return Byte.compare(left.get(ValueLayout.JAVA_BYTE, mismatch), + right.get(ValueLayout.JAVA_BYTE, mismatch)); + } + return (int) (leftSize - rightSize); + } +} diff --git a/src/main/java/ru/vk/itmo/test/boturkhonovkamron/InMemoryDaoFactory.java b/src/main/java/ru/vk/itmo/test/boturkhonovkamron/InMemoryDaoFactory.java new file mode 100644 index 000000000..f838ba1a6 --- /dev/null +++ b/src/main/java/ru/vk/itmo/test/boturkhonovkamron/InMemoryDaoFactory.java @@ -0,0 +1,41 @@ +package ru.vk.itmo.test.boturkhonovkamron; + +import ru.vk.itmo.Dao; +import ru.vk.itmo.Entry; +import ru.vk.itmo.boturkhonovkamron.InMemoryDao; +import ru.vk.itmo.test.DaoFactory; + +import java.lang.foreign.MemorySegment; +import java.lang.foreign.ValueLayout; +import java.nio.charset.StandardCharsets; + +/** + * Класс представляет фабрику DAO для создания и предоставления объектов типа InMemoryDao. + * + * @author Kamron Boturkhonov + * @since 2023.09.26 + */ +@DaoFactory +public class InMemoryDaoFactory implements DaoFactory.Factory> { + + @Override + public Dao> createDao() { + return new InMemoryDao(); + } + + @Override + public String toString(final MemorySegment memorySegment) { + return memorySegment == null ? null + : new String(memorySegment.toArray(ValueLayout.JAVA_BYTE), StandardCharsets.UTF_8); + } + + @Override + public MemorySegment fromString(final String data) { + return data == null ? null : MemorySegment.ofArray(data.getBytes(StandardCharsets.UTF_8)); + } + + @Override + public Entry fromBaseEntry(final Entry baseEntry) { + return baseEntry; + } +} From 0cd3682e8a3959f297decb1b74f0c97632d88d8f Mon Sep 17 00:00:00 2001 From: Stepan Date: Sun, 1 Oct 2023 22:13:19 +0300 Subject: [PATCH 07/45] =?UTF-8?q?=D0=A8=D0=B8=D1=88=D0=B8=D0=B3=D0=B8?= =?UTF-8?q?=D0=BD=20=D0=A1=D1=82=D0=B5=D0=BF=D0=B0=D0=BD=20=D0=98=D0=A2?= =?UTF-8?q?=D0=9C=D0=9E=20=D0=A2=D0=98=D0=9D=D0=A2=20=D0=A0=D0=B0=D1=81?= =?UTF-8?q?=D0=BF=D1=80=D0=B5=D0=B4=D0=B5=D0=BB=D0=B5=D0=BD=D0=BD=D1=8B?= =?UTF-8?q?=D0=B5=20=D0=B2=D0=B5=D0=B1=20=D1=81=D0=B5=D1=80=D0=B2=D0=B8?= =?UTF-8?q?=D1=81=D1=8B.=20=D0=94=D0=BE=D0=BC=D0=B0=D1=88=D0=BA=D0=B0=201.?= =?UTF-8?q?=20(#51)?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- .../vk/itmo/shishiginstepan/InMemDaoImpl.java | 40 +++++++++++++++++++ .../shishiginstepan/InMemDaoFactoryImpl.java | 33 +++++++++++++++ 2 files changed, 73 insertions(+) create mode 100644 src/main/java/ru/vk/itmo/shishiginstepan/InMemDaoImpl.java create mode 100644 src/main/java/ru/vk/itmo/test/shishiginstepan/InMemDaoFactoryImpl.java diff --git a/src/main/java/ru/vk/itmo/shishiginstepan/InMemDaoImpl.java b/src/main/java/ru/vk/itmo/shishiginstepan/InMemDaoImpl.java new file mode 100644 index 000000000..d430604bf --- /dev/null +++ b/src/main/java/ru/vk/itmo/shishiginstepan/InMemDaoImpl.java @@ -0,0 +1,40 @@ +package ru.vk.itmo.shishiginstepan; + +import ru.vk.itmo.Dao; +import ru.vk.itmo.Entry; + +import java.lang.foreign.MemorySegment; +import java.lang.foreign.ValueLayout; +import java.util.Arrays; +import java.util.Iterator; +import java.util.concurrent.ConcurrentSkipListMap; + +public class InMemDaoImpl implements Dao> { + ConcurrentSkipListMap> storage = new ConcurrentSkipListMap<>( + (o1, o2) -> Arrays.compare(o1.toArray(ValueLayout.JAVA_BYTE), o2.toArray(ValueLayout.JAVA_BYTE)) + ); + + @Override + public Iterator> get(MemorySegment from, MemorySegment to) { + if (to == null && from == null) { + return this.storage.values().iterator(); + } else if (to == null) { + return this.storage.tailMap(from).sequencedValues().iterator(); + } else if (from == null) { + return this.storage.headMap(to).sequencedValues().iterator(); + } else { + return this.storage.subMap(from, to).sequencedValues().iterator(); + } + } + + @Override + public Entry get(MemorySegment key) { + return this.storage.get(key); + } + + @Override + public void upsert(Entry entry) { + this.storage.put(entry.key(), entry); + } +} + diff --git a/src/main/java/ru/vk/itmo/test/shishiginstepan/InMemDaoFactoryImpl.java b/src/main/java/ru/vk/itmo/test/shishiginstepan/InMemDaoFactoryImpl.java new file mode 100644 index 000000000..dba48749c --- /dev/null +++ b/src/main/java/ru/vk/itmo/test/shishiginstepan/InMemDaoFactoryImpl.java @@ -0,0 +1,33 @@ +package ru.vk.itmo.test.shishiginstepan; + +import ru.vk.itmo.Dao; +import ru.vk.itmo.Entry; +import ru.vk.itmo.shishiginstepan.InMemDaoImpl; +import ru.vk.itmo.test.DaoFactory; + +import java.lang.foreign.MemorySegment; +import java.lang.foreign.ValueLayout; +import java.nio.charset.StandardCharsets; + +@DaoFactory +public class InMemDaoFactoryImpl implements DaoFactory.Factory> { + @Override + public Dao> createDao() { + return new InMemDaoImpl(); + } + + @Override + public String toString(MemorySegment memorySegment) { + return new String(memorySegment.toArray(ValueLayout.JAVA_BYTE), StandardCharsets.UTF_8); + } + + @Override + public MemorySegment fromString(String data) { + return data == null ? null : MemorySegment.ofArray(data.getBytes(StandardCharsets.UTF_8)); + } + + @Override + public Entry fromBaseEntry(Entry baseEntry) { + return baseEntry; + } +} From 2eda76a1c311dfc510b8c8c5991f73c77284ded5 Mon Sep 17 00:00:00 2001 From: Alexey <71148093+lehatheslayer@users.noreply.github.com> Date: Mon, 2 Oct 2023 14:57:51 +0300 Subject: [PATCH 08/45] =?UTF-8?q?=D0=A0=D0=B5=D1=88=D0=B5=D1=82=D0=BD?= =?UTF-8?q?=D0=B8=D0=BA=D0=BE=D0=B2=20=D0=90=D0=BB=D0=B5=D0=BA=D1=81=D0=B5?= =?UTF-8?q?=D0=B9,=20=D0=9C=D0=B0=D0=B3=D0=B8=D1=81=D1=82=D1=80=D0=B0?= =?UTF-8?q?=D1=82=D1=83=D1=80=D0=B0=20=D0=98=D0=A2=D0=9C=D0=9E=20"=D0=A0?= =?UTF-8?q?=D0=B0=D1=81=D0=BF=D1=80=D0=B5=D0=B4=D0=B5=D0=BB=D0=B5=D0=BD?= =?UTF-8?q?=D0=BD=D1=8B=D0=B5=20=D0=B2=D0=B5=D0=B1-=D1=81=D0=B5=D1=80?= =?UTF-8?q?=D0=B2=D0=B8=D1=81=D1=8B",=20=D0=9B=D0=B0=D0=B11=20(#58)?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Co-authored-by: Vadim Tsesko --- .../itmo/reshetnikovaleksei/InMemoryDao.java | 58 +++++++++++++++++++ .../reshetnikovaleksei/DaoFactoryImpl.java | 37 ++++++++++++ 2 files changed, 95 insertions(+) create mode 100644 src/main/java/ru/vk/itmo/reshetnikovaleksei/InMemoryDao.java create mode 100644 src/main/java/ru/vk/itmo/test/reshetnikovaleksei/DaoFactoryImpl.java diff --git a/src/main/java/ru/vk/itmo/reshetnikovaleksei/InMemoryDao.java b/src/main/java/ru/vk/itmo/reshetnikovaleksei/InMemoryDao.java new file mode 100644 index 000000000..d393b0ea8 --- /dev/null +++ b/src/main/java/ru/vk/itmo/reshetnikovaleksei/InMemoryDao.java @@ -0,0 +1,58 @@ +package ru.vk.itmo.reshetnikovaleksei; + +import ru.vk.itmo.Dao; +import ru.vk.itmo.Entry; + +import java.lang.foreign.MemorySegment; +import java.lang.foreign.ValueLayout; +import java.util.Iterator; +import java.util.concurrent.ConcurrentSkipListMap; + +public class InMemoryDao implements Dao> { + private final ConcurrentSkipListMap> map; + + public InMemoryDao() { + this.map = new ConcurrentSkipListMap<>((a, b) -> { + var offset = a.mismatch(b); + + if (offset == -1) { + return 0; + } else if (offset == a.byteSize()) { + return -1; + } else if (offset == b.byteSize()) { + return 1; + } else { + return Byte.compare( + a.get(ValueLayout.JAVA_BYTE, offset), + b.get(ValueLayout.JAVA_BYTE, offset) + ); + } + }); + } + + @Override + public Iterator> get(MemorySegment from, MemorySegment to) { + if (from == null && to == null) { + return map.values().iterator(); + } + + if (from == null) { + return map.headMap(to).values().iterator(); + } + if (to == null) { + return map.tailMap(from).values().iterator(); + } + + return map.subMap(from, to).values().iterator(); + } + + @Override + public Entry get(MemorySegment key) { + return map.get(key); + } + + @Override + public void upsert(Entry entry) { + map.put(entry.key(), entry); + } +} diff --git a/src/main/java/ru/vk/itmo/test/reshetnikovaleksei/DaoFactoryImpl.java b/src/main/java/ru/vk/itmo/test/reshetnikovaleksei/DaoFactoryImpl.java new file mode 100644 index 000000000..c9ecc4f07 --- /dev/null +++ b/src/main/java/ru/vk/itmo/test/reshetnikovaleksei/DaoFactoryImpl.java @@ -0,0 +1,37 @@ +package ru.vk.itmo.test.reshetnikovaleksei; + +import ru.vk.itmo.Dao; +import ru.vk.itmo.Entry; +import ru.vk.itmo.reshetnikovaleksei.InMemoryDao; +import ru.vk.itmo.test.DaoFactory; + +import java.lang.foreign.MemorySegment; +import java.lang.foreign.ValueLayout; +import java.nio.charset.StandardCharsets; + +@DaoFactory +public class DaoFactoryImpl implements DaoFactory.Factory> { + @Override + public String toString(MemorySegment memorySegment) { + return memorySegment == null + ? null + : new String(memorySegment.toArray(ValueLayout.JAVA_BYTE), StandardCharsets.UTF_8); + } + + @Override + public MemorySegment fromString(String data) { + return data == null + ? null + : MemorySegment.ofArray(data.getBytes(StandardCharsets.UTF_8)); + } + + @Override + public Entry fromBaseEntry(Entry baseEntry) { + return baseEntry; + } + + @Override + public Dao> createDao() { + return new InMemoryDao(); + } +} From d40725278c2bb60b75ba234af17d9419f2ab4e8c Mon Sep 17 00:00:00 2001 From: td2r <56451941+td2r@users.noreply.github.com> Date: Mon, 2 Oct 2023 15:03:11 +0300 Subject: [PATCH 09/45] =?UTF-8?q?=D0=9D=D0=B0=D1=83=D0=BC=D0=BE=D0=B2=20?= =?UTF-8?q?=D0=98=D0=B2=D0=B0=D0=BD,=20ITMO=20DWS,=20HW1=20(#66)?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Co-authored-by: Ivan Naumov Co-authored-by: Vadim Tsesko --- .../ru/vk/itmo/naumovivan/InMemoryDao.java | 50 +++++++++++++++++++ .../test/naumovivan/InMemoryDaoFactory.java | 33 ++++++++++++ 2 files changed, 83 insertions(+) create mode 100644 src/main/java/ru/vk/itmo/naumovivan/InMemoryDao.java create mode 100644 src/main/java/ru/vk/itmo/test/naumovivan/InMemoryDaoFactory.java diff --git a/src/main/java/ru/vk/itmo/naumovivan/InMemoryDao.java b/src/main/java/ru/vk/itmo/naumovivan/InMemoryDao.java new file mode 100644 index 000000000..81f95fc38 --- /dev/null +++ b/src/main/java/ru/vk/itmo/naumovivan/InMemoryDao.java @@ -0,0 +1,50 @@ +package ru.vk.itmo.naumovivan; + +import ru.vk.itmo.Dao; +import ru.vk.itmo.Entry; + +import java.lang.foreign.MemorySegment; +import java.lang.foreign.ValueLayout; +import java.util.Iterator; +import java.util.concurrent.ConcurrentSkipListMap; + +public class InMemoryDao implements Dao> { + private final ConcurrentSkipListMap> map = + new ConcurrentSkipListMap<>(InMemoryDao::compareMemorySegments); + + private static int compareMemorySegments(final MemorySegment ms1, final MemorySegment ms2) { + final long n1 = ms1.byteSize(); + final long n2 = ms2.byteSize(); + for (long i = 0; i < n1 && i < n2; ++i) { + final byte b1 = ms1.get(ValueLayout.JAVA_BYTE, i); + final byte b2 = ms2.get(ValueLayout.JAVA_BYTE, i); + if (b1 != b2) { + return Byte.compare(b1, b2); + } + } + return Long.compare(n1, n2); + } + + @Override + public Iterator> get(final MemorySegment from, final MemorySegment to) { + if (from == null && to == null) { + return map.values().iterator(); + } else if (from == null) { + return map.headMap(to).values().iterator(); + } else if (to == null) { + return map.tailMap(from).values().iterator(); + } else { + return map.subMap(from, to).values().iterator(); + } + } + + @Override + public Entry get(final MemorySegment key) { + return map.get(key); + } + + @Override + public void upsert(final Entry entry) { + map.put(entry.key(), entry); + } +} diff --git a/src/main/java/ru/vk/itmo/test/naumovivan/InMemoryDaoFactory.java b/src/main/java/ru/vk/itmo/test/naumovivan/InMemoryDaoFactory.java new file mode 100644 index 000000000..658007536 --- /dev/null +++ b/src/main/java/ru/vk/itmo/test/naumovivan/InMemoryDaoFactory.java @@ -0,0 +1,33 @@ +package ru.vk.itmo.test.naumovivan; + +import ru.vk.itmo.Dao; +import ru.vk.itmo.Entry; +import ru.vk.itmo.naumovivan.InMemoryDao; +import ru.vk.itmo.test.DaoFactory; + +import java.lang.foreign.MemorySegment; +import java.lang.foreign.ValueLayout; +import java.nio.charset.StandardCharsets; + +@DaoFactory +public class InMemoryDaoFactory implements DaoFactory.Factory> { + @Override + public Dao> createDao() { + return new InMemoryDao(); + } + + @Override + public String toString(final MemorySegment memorySegment) { + return new String(memorySegment.toArray(ValueLayout.JAVA_BYTE), StandardCharsets.UTF_8); + } + + @Override + public MemorySegment fromString(final String data) { + return data == null ? null : MemorySegment.ofArray(data.getBytes(StandardCharsets.UTF_8)).asReadOnly(); + } + + @Override + public Entry fromBaseEntry(final Entry baseEntry) { + return baseEntry; + } +} From 35e9c739cc1a05b41337e12b6a3989b544357ef6 Mon Sep 17 00:00:00 2001 From: Georgii Dalbeev <55684784+goshadalbeev@users.noreply.github.com> Date: Mon, 2 Oct 2023 15:09:13 +0300 Subject: [PATCH 10/45] =?UTF-8?q?=D0=94=D0=B0=D0=BB=D0=B1=D0=B5=D0=B5?= =?UTF-8?q?=D0=B2=20=D0=93=D0=B5=D0=BE=D1=80=D0=B3=D0=B8=D0=B9=20=D0=93?= =?UTF-8?q?=D0=B5=D0=BE=D1=80=D0=B3=D0=B8=D0=B5=D0=B2=D0=B8=D1=87.=20?= =?UTF-8?q?=D0=98=D0=A2=D0=9C=D0=9E=20DWS.=20=D0=97=D0=B0=D0=B4=D0=B0?= =?UTF-8?q?=D0=BD=D0=B8=D0=B5=20#1=20(#61)?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Co-authored-by: Vadim Tsesko --- .../ru/vk/itmo/dalbeevgeorgii/DaoImpl.java | 52 +++++++++++++++++++ .../itmo/test/dalbeevgeorgii/FactoryImpl.java | 41 +++++++++++++++ 2 files changed, 93 insertions(+) create mode 100644 src/main/java/ru/vk/itmo/dalbeevgeorgii/DaoImpl.java create mode 100644 src/main/java/ru/vk/itmo/test/dalbeevgeorgii/FactoryImpl.java diff --git a/src/main/java/ru/vk/itmo/dalbeevgeorgii/DaoImpl.java b/src/main/java/ru/vk/itmo/dalbeevgeorgii/DaoImpl.java new file mode 100644 index 000000000..237a5b2de --- /dev/null +++ b/src/main/java/ru/vk/itmo/dalbeevgeorgii/DaoImpl.java @@ -0,0 +1,52 @@ +package ru.vk.itmo.dalbeevgeorgii; + +import ru.vk.itmo.Dao; +import ru.vk.itmo.Entry; + +import java.lang.foreign.MemorySegment; +import java.lang.foreign.ValueLayout; +import java.util.Iterator; +import java.util.concurrent.ConcurrentSkipListMap; + +public class DaoImpl implements Dao> { + private final ConcurrentSkipListMap> map = new ConcurrentSkipListMap<>( + (segment1, segment2) -> { + long offset = segment1.mismatch(segment2); + if (offset == -1) { + return 0; + } else if (offset == segment1.byteSize()) { + return -1; + } else if (offset == segment2.byteSize()) { + return 1; + } + return Byte.compare( + segment1.get(ValueLayout.JAVA_BYTE, offset), + segment2.get(ValueLayout.JAVA_BYTE, offset) + ); + }); + + @Override + public Iterator> get(MemorySegment from, MemorySegment to) { + if (from == null && to == null) { + return map.values().iterator(); + } else if (to == null) { + return map.tailMap(from).values().iterator(); + } else if (from == null) { + return map.headMap(to).values().iterator(); + } + return map.subMap(from, to).values().iterator(); + } + + @Override + public Entry get(MemorySegment key) { + return map.get(key); + } + + @Override + public void upsert(Entry entry) { + if (entry == null) { + throw new IllegalArgumentException("Entry cannot be null"); + } + map.put(entry.key(), entry); + } +} diff --git a/src/main/java/ru/vk/itmo/test/dalbeevgeorgii/FactoryImpl.java b/src/main/java/ru/vk/itmo/test/dalbeevgeorgii/FactoryImpl.java new file mode 100644 index 000000000..366177862 --- /dev/null +++ b/src/main/java/ru/vk/itmo/test/dalbeevgeorgii/FactoryImpl.java @@ -0,0 +1,41 @@ +package ru.vk.itmo.test.dalbeevgeorgii; + +import ru.vk.itmo.Dao; +import ru.vk.itmo.Entry; +import ru.vk.itmo.dalbeevgeorgii.DaoImpl; +import ru.vk.itmo.test.DaoFactory; + +import java.lang.foreign.MemorySegment; +import java.nio.charset.StandardCharsets; + +import static java.lang.foreign.ValueLayout.JAVA_BYTE; + +@DaoFactory +public class FactoryImpl implements DaoFactory.Factory> { + + @Override + public Dao> createDao() { + return new DaoImpl(); + } + + @Override + public String toString(MemorySegment memorySegment) { + if (memorySegment == null) { + return null; + } + return new String(memorySegment.toArray(JAVA_BYTE), StandardCharsets.UTF_8); + } + + @Override + public MemorySegment fromString(String data) { + if (data == null) { + return null; + } + return MemorySegment.ofArray(data.getBytes(StandardCharsets.UTF_8)); + } + + @Override + public Entry fromBaseEntry(Entry baseEntry) { + return baseEntry; + } +} From 1628e11b0d12d8f680b2a59cdc3eb424f2dc4c80 Mon Sep 17 00:00:00 2001 From: Vladislav Kovalchuk <72710736+Dalvikk@users.noreply.github.com> Date: Mon, 2 Oct 2023 18:19:10 +0300 Subject: [PATCH 11/45] =?UTF-8?q?=D0=98=D0=A2=D0=9C=D0=9E=20=D0=A4=D0=98?= =?UTF-8?q?=D0=A2=D0=98=D0=9F,=20=D0=9A=D0=BE=D0=B2=D0=B0=D0=BB=D1=8C?= =?UTF-8?q?=D1=87=D1=83=D0=BA=20=D0=92=D0=BB=D0=B0=D0=B4=D0=B8=D1=81=D0=BB?= =?UTF-8?q?=D0=B0=D0=B2,=20M33371,=20HW=201=20(#67)?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Co-authored-by: Vladislav Kovalchuk Co-authored-by: Vadim Tsesko Co-authored-by: Alexey Shik <58121508+AlexeyShik@users.noreply.github.com> --- .../AbstractInMemoryDao.java | 72 +++++++++++++++++++ .../kovalchukvladislav/MemorySegmentDao.java | 34 +++++++++ .../MemorySegmentDaoFactory.java | 43 +++++++++++ 3 files changed, 149 insertions(+) create mode 100644 src/main/java/ru/vk/itmo/kovalchukvladislav/AbstractInMemoryDao.java create mode 100644 src/main/java/ru/vk/itmo/kovalchukvladislav/MemorySegmentDao.java create mode 100644 src/main/java/ru/vk/itmo/test/kovalchukvladislav/MemorySegmentDaoFactory.java diff --git a/src/main/java/ru/vk/itmo/kovalchukvladislav/AbstractInMemoryDao.java b/src/main/java/ru/vk/itmo/kovalchukvladislav/AbstractInMemoryDao.java new file mode 100644 index 000000000..d3ae8c9f5 --- /dev/null +++ b/src/main/java/ru/vk/itmo/kovalchukvladislav/AbstractInMemoryDao.java @@ -0,0 +1,72 @@ +package ru.vk.itmo.kovalchukvladislav; + +import ru.vk.itmo.Dao; +import ru.vk.itmo.Entry; + +import java.util.Comparator; +import java.util.Iterator; +import java.util.concurrent.ConcurrentNavigableMap; +import java.util.concurrent.ConcurrentSkipListMap; + +public abstract class AbstractInMemoryDao> implements Dao { + private final ConcurrentNavigableMap dao; + + protected AbstractInMemoryDao(Comparator comparator) { + dao = new ConcurrentSkipListMap<>(comparator); + } + + @Override + public Iterator get(D from, D to) { + if (from == null && to == null) { + return all(); + } else if (from == null) { + return allToUnsafe(to); + } else if (to == null) { + return allFromUnsafe(from); + } + return dao.subMap(from, to).values().iterator(); + } + + @Override + public E get(D key) { + return dao.get(key); + } + + @Override + public void upsert(E entry) { + dao.put(entry.key(), entry); + } + + @Override + public Iterator allFrom(D from) { + return from == null ? all() : allFromUnsafe(from); + } + + /** + * Doesn't check the argument for null. Should be called only if there was a check before + * @param from NotNull lower bound of range (inclusive) + * @return entries with key >= from + */ + private Iterator allFromUnsafe(D from) { + return dao.tailMap(from).values().iterator(); + } + + @Override + public Iterator allTo(D to) { + return to == null ? all() : allToUnsafe(to); + } + + /** + * Doesn't check the argument for null. Should be called only if there was a check before + * @param to NotNull upper bound of range (exclusive) + * @return entries with key < to + */ + private Iterator allToUnsafe(D to) { + return dao.headMap(to).values().iterator(); + } + + @Override + public Iterator all() { + return dao.values().iterator(); + } +} diff --git a/src/main/java/ru/vk/itmo/kovalchukvladislav/MemorySegmentDao.java b/src/main/java/ru/vk/itmo/kovalchukvladislav/MemorySegmentDao.java new file mode 100644 index 000000000..e573bb058 --- /dev/null +++ b/src/main/java/ru/vk/itmo/kovalchukvladislav/MemorySegmentDao.java @@ -0,0 +1,34 @@ +package ru.vk.itmo.kovalchukvladislav; + +import ru.vk.itmo.Entry; + +import java.lang.foreign.MemorySegment; +import java.lang.foreign.ValueLayout; +import java.util.Comparator; + +public class MemorySegmentDao extends AbstractInMemoryDao> { + private static final Comparator COMPARATOR = getComparator(); + private static final ValueLayout.OfByte VALUE_LAYOUT = ValueLayout.JAVA_BYTE; + + public MemorySegmentDao() { + super(COMPARATOR); + } + + private static Comparator getComparator() { + return (Comparator) (a, b) -> { + long diffIndex = a.mismatch(b); + if (diffIndex == -1) { + return 0; + } else if (diffIndex == a.byteSize()) { + return -1; + } else if (diffIndex == b.byteSize()) { + return 1; + } + + byte byteA = a.getAtIndex(VALUE_LAYOUT, diffIndex); + byte byteB = b.getAtIndex(VALUE_LAYOUT, diffIndex); + return Byte.compare(byteA, byteB); + }; + } +} + diff --git a/src/main/java/ru/vk/itmo/test/kovalchukvladislav/MemorySegmentDaoFactory.java b/src/main/java/ru/vk/itmo/test/kovalchukvladislav/MemorySegmentDaoFactory.java new file mode 100644 index 000000000..dd8963f94 --- /dev/null +++ b/src/main/java/ru/vk/itmo/test/kovalchukvladislav/MemorySegmentDaoFactory.java @@ -0,0 +1,43 @@ +package ru.vk.itmo.test.kovalchukvladislav; + +import ru.vk.itmo.Dao; +import ru.vk.itmo.Entry; +import ru.vk.itmo.kovalchukvladislav.MemorySegmentDao; +import ru.vk.itmo.test.DaoFactory; + +import java.lang.foreign.MemorySegment; +import java.lang.foreign.ValueLayout; +import java.nio.charset.Charset; +import java.nio.charset.StandardCharsets; + +@DaoFactory +public class MemorySegmentDaoFactory implements DaoFactory.Factory> { + private static final Charset CHARSET = StandardCharsets.UTF_8; + private static final ValueLayout.OfByte VALUE_LAYOUT = ValueLayout.JAVA_BYTE; + + @Override + public Dao> createDao() { + return new MemorySegmentDao(); + } + + @Override + public String toString(MemorySegment memorySegment) { + if (memorySegment == null) { + return null; + } + return new String(memorySegment.toArray(VALUE_LAYOUT), CHARSET); + } + + @Override + public MemorySegment fromString(String data) { + if (data == null) { + return null; + } + return MemorySegment.ofArray(data.getBytes(CHARSET)); + } + + @Override + public Entry fromBaseEntry(Entry baseEntry) { + return baseEntry; + } +} From 9c65fa1afe8622dbf5b7577630b905ddac3c74bb Mon Sep 17 00:00:00 2001 From: Danil Kislov <48238626+HKTRp@users.noreply.github.com> Date: Mon, 2 Oct 2023 18:23:20 +0300 Subject: [PATCH 12/45] =?UTF-8?q?Kislov=20Danil=20=D0=98=D0=A2=D0=9C=D0=9E?= =?UTF-8?q?=20=D0=A4=D0=98=D0=A2=D0=B8=D0=9F=20HW1=20(#17)?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Co-authored-by: Vadim Tsesko Co-authored-by: Alexey Shik <58121508+AlexeyShik@users.noreply.github.com> --- .../ru/vk/itmo/kislovdanil/InMemoryDao.java | 47 +++++++++++++++++++ .../test/kislovdanil/InMemoryDaoFactory.java | 34 ++++++++++++++ 2 files changed, 81 insertions(+) create mode 100644 src/main/java/ru/vk/itmo/kislovdanil/InMemoryDao.java create mode 100644 src/main/java/ru/vk/itmo/test/kislovdanil/InMemoryDaoFactory.java diff --git a/src/main/java/ru/vk/itmo/kislovdanil/InMemoryDao.java b/src/main/java/ru/vk/itmo/kislovdanil/InMemoryDao.java new file mode 100644 index 000000000..6d1c3d3c9 --- /dev/null +++ b/src/main/java/ru/vk/itmo/kislovdanil/InMemoryDao.java @@ -0,0 +1,47 @@ +package ru.vk.itmo.kislovdanil; + +import ru.vk.itmo.Dao; +import ru.vk.itmo.Entry; + +import java.lang.foreign.MemorySegment; +import java.lang.foreign.ValueLayout; +import java.util.Comparator; +import java.util.Iterator; +import java.util.concurrent.ConcurrentSkipListMap; + +public class InMemoryDao implements Dao> { + ConcurrentSkipListMap> storage = + new ConcurrentSkipListMap<>(new MemSegComparator()); + + private static class MemSegComparator implements Comparator { + @Override + public int compare(MemorySegment o1, MemorySegment o2) { + long mismatch = o1.mismatch(o2); + if (mismatch == -1) { + return 0; + } + if (mismatch == Math.min(o1.byteSize(), o2.byteSize())) { + return Long.compare(o1.byteSize(), o2.byteSize()); + } + return Byte.compare(o1.get(ValueLayout.JAVA_BYTE, mismatch), o2.get(ValueLayout.JAVA_BYTE, mismatch)); + } + } + + @Override + public Iterator> get(MemorySegment from, MemorySegment to) { + if (from == null && to == null) return storage.values().iterator(); + if (from != null && to == null) return storage.tailMap(from).values().iterator(); + if (from == null) return storage.headMap(to).values().iterator(); + return storage.subMap(from, to).values().iterator(); + } + + @Override + public Entry get(MemorySegment key) { + return storage.get(key); + } + + @Override + public void upsert(Entry entry) { + storage.put(entry.key(), entry); + } +} diff --git a/src/main/java/ru/vk/itmo/test/kislovdanil/InMemoryDaoFactory.java b/src/main/java/ru/vk/itmo/test/kislovdanil/InMemoryDaoFactory.java new file mode 100644 index 000000000..96ce7c10f --- /dev/null +++ b/src/main/java/ru/vk/itmo/test/kislovdanil/InMemoryDaoFactory.java @@ -0,0 +1,34 @@ +package ru.vk.itmo.test.kislovdanil; + +import ru.vk.itmo.Dao; +import ru.vk.itmo.Entry; +import ru.vk.itmo.kislovdanil.InMemoryDao; +import ru.vk.itmo.test.DaoFactory; + +import java.lang.foreign.MemorySegment; +import java.lang.foreign.ValueLayout; +import java.nio.charset.StandardCharsets; + +@DaoFactory +public class InMemoryDaoFactory implements DaoFactory.Factory> { + + @Override + public String toString(MemorySegment memorySegment) { + return new String(memorySegment.toArray(ValueLayout.JAVA_BYTE), StandardCharsets.UTF_8); + } + + @Override + public MemorySegment fromString(String data) { + return (data == null) ? null : MemorySegment.ofArray(data.getBytes(StandardCharsets.UTF_8)); + } + + @Override + public Entry fromBaseEntry(Entry baseEntry) { + return baseEntry; + } + + @Override + public Dao> createDao() { + return new InMemoryDao(); + } +} From 5f40ab7e516f8f0973091786fd16af13ab544f62 Mon Sep 17 00:00:00 2001 From: Ilya Abramov <45769461+IlyaAbramovv@users.noreply.github.com> Date: Mon, 2 Oct 2023 18:27:12 +0300 Subject: [PATCH 13/45] Abramov Ilya, ITMO FITIP M33341, HW1 (#8) Co-authored-by: Vadim Tsesko Co-authored-by: Alexey Shik <58121508+AlexeyShik@users.noreply.github.com> --- .../ru/vk/itmo/abramovilya/InMemoryDao.java | 55 +++++++++++++++++++ .../itmo/test/abramovilya/DaoFactoryImpl.java | 35 ++++++++++++ 2 files changed, 90 insertions(+) create mode 100644 src/main/java/ru/vk/itmo/abramovilya/InMemoryDao.java create mode 100644 src/main/java/ru/vk/itmo/test/abramovilya/DaoFactoryImpl.java diff --git a/src/main/java/ru/vk/itmo/abramovilya/InMemoryDao.java b/src/main/java/ru/vk/itmo/abramovilya/InMemoryDao.java new file mode 100644 index 000000000..d359aa6b3 --- /dev/null +++ b/src/main/java/ru/vk/itmo/abramovilya/InMemoryDao.java @@ -0,0 +1,55 @@ +package ru.vk.itmo.abramovilya; + +import ru.vk.itmo.Dao; +import ru.vk.itmo.Entry; + +import java.lang.foreign.MemorySegment; +import java.lang.foreign.ValueLayout; +import java.util.Iterator; +import java.util.concurrent.ConcurrentNavigableMap; +import java.util.concurrent.ConcurrentSkipListMap; + +public class InMemoryDao implements Dao> { + private final ConcurrentNavigableMap> map = + new ConcurrentSkipListMap<>(InMemoryDao::compareMemorySegments); + + @Override + public Iterator> get(MemorySegment from, MemorySegment to) { + ConcurrentNavigableMap> subMap; + if (from == null && to == null) { + subMap = map; + } else if (from == null) { + subMap = map.headMap(to); + } else if (to == null) { + subMap = map.tailMap(from); + } else { + subMap = map.subMap(from, to); + } + return subMap.values().iterator(); + } + + @Override + public void upsert(Entry entry) { + map.put(entry.key(), entry); + } + + @Override + public Entry get(MemorySegment key) { + return map.get(key); + } + + private static int compareMemorySegments(MemorySegment segment1, MemorySegment segment2) { + long offset = segment1.mismatch(segment2); + if (offset == -1) { + return 0; + } else if (offset == segment1.byteSize()) { + return -1; + } else if (offset == segment2.byteSize()) { + return 1; + } + return Byte.compare( + segment1.get(ValueLayout.JAVA_BYTE, offset), + segment2.get(ValueLayout.JAVA_BYTE, offset) + ); + } +} diff --git a/src/main/java/ru/vk/itmo/test/abramovilya/DaoFactoryImpl.java b/src/main/java/ru/vk/itmo/test/abramovilya/DaoFactoryImpl.java new file mode 100644 index 000000000..20a9c7a31 --- /dev/null +++ b/src/main/java/ru/vk/itmo/test/abramovilya/DaoFactoryImpl.java @@ -0,0 +1,35 @@ +package ru.vk.itmo.test.abramovilya; + +import ru.vk.itmo.Dao; +import ru.vk.itmo.Entry; +import ru.vk.itmo.abramovilya.InMemoryDao; +import ru.vk.itmo.test.DaoFactory; + +import java.lang.foreign.MemorySegment; +import java.lang.foreign.ValueLayout; +import java.nio.charset.StandardCharsets; + +@DaoFactory +public class DaoFactoryImpl implements DaoFactory.Factory> { + @Override + public Dao> createDao() { + return new InMemoryDao(); + } + + @Override + public String toString(MemorySegment memorySegment) { + if (memorySegment == null) return null; + return new String(memorySegment.toArray(ValueLayout.JAVA_BYTE), StandardCharsets.UTF_8); + } + + @Override + public MemorySegment fromString(String data) { + if (data == null) return null; + return MemorySegment.ofArray(data.getBytes(StandardCharsets.UTF_8)); + } + + @Override + public Entry fromBaseEntry(Entry baseEntry) { + return baseEntry; + } +} From 4c4953ae83b37aae6f5fe95347668e0a0602d008 Mon Sep 17 00:00:00 2001 From: AndrewDanilin <76146421+AndrewDanilin@users.noreply.github.com> Date: Mon, 2 Oct 2023 18:29:22 +0300 Subject: [PATCH 14/45] =?UTF-8?q?=D0=98=D0=A2=D0=9C=D0=9E=20=D0=A4=D0=98?= =?UTF-8?q?=D0=A2=D0=B8=D0=9F,=20=D0=94=D0=B0=D0=BD=D0=B8=D0=BB=D0=B8?= =?UTF-8?q?=D0=BD=20=D0=90=D0=BD=D0=B4=D1=80=D0=B5=D0=B9=20M34341,=20hw1?= =?UTF-8?q?=20(#63)?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Co-authored-by: Alexey Shik <58121508+AlexeyShik@users.noreply.github.com> --- src/main/java/ru/vk/itmo/Dao.java | 1 + .../ru/vk/itmo/danilinandrew/InMemoryDao.java | 45 +++++++++++++++++++ .../MemorySegmentComparator.java | 30 +++++++++++++ .../vk/itmo/test/danilinandrew/MyFactory.java | 34 ++++++++++++++ 4 files changed, 110 insertions(+) create mode 100644 src/main/java/ru/vk/itmo/danilinandrew/InMemoryDao.java create mode 100644 src/main/java/ru/vk/itmo/danilinandrew/MemorySegmentComparator.java create mode 100644 src/main/java/ru/vk/itmo/test/danilinandrew/MyFactory.java diff --git a/src/main/java/ru/vk/itmo/Dao.java b/src/main/java/ru/vk/itmo/Dao.java index 820d2b10d..3f2c3b11d 100644 --- a/src/main/java/ru/vk/itmo/Dao.java +++ b/src/main/java/ru/vk/itmo/Dao.java @@ -24,6 +24,7 @@ default E get(D key) { if (!iterator.hasNext()) { return null; } + E next = iterator.next(); if (next.key().equals(key)) { return next; diff --git a/src/main/java/ru/vk/itmo/danilinandrew/InMemoryDao.java b/src/main/java/ru/vk/itmo/danilinandrew/InMemoryDao.java new file mode 100644 index 000000000..2a36372bc --- /dev/null +++ b/src/main/java/ru/vk/itmo/danilinandrew/InMemoryDao.java @@ -0,0 +1,45 @@ +package ru.vk.itmo.danilinandrew; + +import ru.vk.itmo.Dao; +import ru.vk.itmo.Entry; + +import java.lang.foreign.MemorySegment; +import java.util.Iterator; +import java.util.concurrent.ConcurrentNavigableMap; +import java.util.concurrent.ConcurrentSkipListMap; + +public class InMemoryDao implements Dao> { + private final ConcurrentNavigableMap> data = + new ConcurrentSkipListMap<>(new MemorySegmentComparator()); + + @Override + public Entry get(MemorySegment key) { + return data.get(key); + } + + @Override + public Iterator> get(MemorySegment from, MemorySegment to) { + if (from == null && to == null) { + return data.values().iterator(); + } + + if (from == null) { + return data.headMap(to).values().iterator(); + } + + if (to == null) { + return data.tailMap(from).values().iterator(); + } + + return data.subMap(from, to).values().iterator(); + } + + @Override + public void upsert(Entry entry) { + if (entry == null) { + return; + } + + data.put(entry.key(), entry); + } +} diff --git a/src/main/java/ru/vk/itmo/danilinandrew/MemorySegmentComparator.java b/src/main/java/ru/vk/itmo/danilinandrew/MemorySegmentComparator.java new file mode 100644 index 000000000..ed9a37ecf --- /dev/null +++ b/src/main/java/ru/vk/itmo/danilinandrew/MemorySegmentComparator.java @@ -0,0 +1,30 @@ +package ru.vk.itmo.danilinandrew; + +import java.lang.foreign.MemorySegment; +import java.lang.foreign.ValueLayout; +import java.util.Comparator; + +public class MemorySegmentComparator implements Comparator { + + @Override + public int compare(MemorySegment o1, MemorySegment o2) { + long mismatch = o1.mismatch(o2); + + if (mismatch == -1) { + return 0; + } + + if (mismatch == o1.byteSize()) { + return -1; + } + + if (mismatch == o2.byteSize()) { + return 1; + } + + return Byte.compare( + o1.get(ValueLayout.JAVA_BYTE, mismatch), + o2.get(ValueLayout.JAVA_BYTE, mismatch) + ); + } +} diff --git a/src/main/java/ru/vk/itmo/test/danilinandrew/MyFactory.java b/src/main/java/ru/vk/itmo/test/danilinandrew/MyFactory.java new file mode 100644 index 000000000..4be1a0d2e --- /dev/null +++ b/src/main/java/ru/vk/itmo/test/danilinandrew/MyFactory.java @@ -0,0 +1,34 @@ +package ru.vk.itmo.test.danilinandrew; + +import ru.vk.itmo.Config; +import ru.vk.itmo.Dao; +import ru.vk.itmo.Entry; +import ru.vk.itmo.danilinandrew.InMemoryDao; +import ru.vk.itmo.test.DaoFactory; + +import java.lang.foreign.MemorySegment; +import java.lang.foreign.ValueLayout; +import java.nio.charset.StandardCharsets; + +@DaoFactory +public class MyFactory implements DaoFactory.Factory> { + @Override + public String toString(MemorySegment memorySegment) { + return new String(memorySegment.toArray(ValueLayout.JAVA_BYTE), StandardCharsets.UTF_8); + } + + @Override + public MemorySegment fromString(String data) { + return data == null ? null : MemorySegment.ofArray(data.getBytes(StandardCharsets.UTF_8)); + } + + @Override + public Dao> createDao(Config config) { + return new InMemoryDao(); + } + + @Override + public Entry fromBaseEntry(Entry baseEntry) { + return baseEntry; + } +} From fe878a17cc47aedd7eb368c7b34ba9426689faee Mon Sep 17 00:00:00 2001 From: Vadim Ryabov <70646736+holeyko@users.noreply.github.com> Date: Mon, 2 Oct 2023 18:38:43 +0300 Subject: [PATCH 15/45] =?UTF-8?q?=D0=A0=D1=8F=D0=B1=D0=BE=D0=B2=20=D0=92?= =?UTF-8?q?=D0=B0=D0=B4=D0=B8=D0=BC=20=D0=A1=D0=B5=D1=80=D0=B3=D0=B5=D0=B5?= =?UTF-8?q?=D0=B2=D0=B8=D1=87,=20=D0=98=D0=A2=D0=9C=D0=9E=20=D0=A4=D0=98?= =?UTF-8?q?=D0=A2=D0=B8=D0=9F,=20=D0=9C33351=20(#42)?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Co-authored-by: Vadim Ryabov Co-authored-by: Vadim Tsesko Co-authored-by: Alexey Shik <58121508+AlexeyShik@users.noreply.github.com> --- .../vk/itmo/test/ryabovvadim/InMemoryDao.java | 79 +++++++++++++++++++ .../test/ryabovvadim/InMemoryDaoFactory.java | 39 +++++++++ 2 files changed, 118 insertions(+) create mode 100644 src/main/java/ru/vk/itmo/test/ryabovvadim/InMemoryDao.java create mode 100644 src/main/java/ru/vk/itmo/test/ryabovvadim/InMemoryDaoFactory.java diff --git a/src/main/java/ru/vk/itmo/test/ryabovvadim/InMemoryDao.java b/src/main/java/ru/vk/itmo/test/ryabovvadim/InMemoryDao.java new file mode 100644 index 000000000..2e8bb27cc --- /dev/null +++ b/src/main/java/ru/vk/itmo/test/ryabovvadim/InMemoryDao.java @@ -0,0 +1,79 @@ +package ru.vk.itmo.test.ryabovvadim; + +import ru.vk.itmo.Dao; +import ru.vk.itmo.Entry; + +import java.lang.foreign.MemorySegment; +import java.lang.foreign.ValueLayout; +import java.util.Comparator; +import java.util.Iterator; +import java.util.concurrent.ConcurrentNavigableMap; +import java.util.concurrent.ConcurrentSkipListMap; + +public class InMemoryDao implements Dao> { + private static final Comparator MEMORY_SEGMENT_COMPARATOR = + (firstSegment, secondSegment) -> { + long firstSegmentSize = firstSegment.byteSize(); + long secondSegmentSize = secondSegment.byteSize(); + long mismatchOffset = firstSegment.mismatch(secondSegment); + + if (mismatchOffset == firstSegmentSize) { + return -1; + } + if (mismatchOffset == secondSegmentSize) { + return 1; + } + if (mismatchOffset == -1) { + return Long.compare(firstSegmentSize, secondSegmentSize); + } + + return Byte.compare( + firstSegment.get(ValueLayout.JAVA_BYTE, mismatchOffset), + secondSegment.get(ValueLayout.JAVA_BYTE, mismatchOffset) + ); + }; + private final ConcurrentNavigableMap> storage = + new ConcurrentSkipListMap<>(MEMORY_SEGMENT_COMPARATOR); + + @Override + public Entry get(MemorySegment key) { + return storage.get(key); + } + + @Override + public Iterator> allFrom(MemorySegment from) { + if (from == null) { + return all(); + } + return storage.tailMap(from).values().iterator(); + } + + @Override + public Iterator> allTo(MemorySegment to) { + if (to == null) { + return all(); + } + return storage.headMap(to).values().iterator(); + } + + @Override + public Iterator> all() { + return storage.values().iterator(); + } + + @Override + public Iterator> get(MemorySegment from, MemorySegment to) { + if (from == null) { + return allTo(to); + } + if (to == null) { + return allFrom(from); + } + return storage.subMap(from, to).values().iterator(); + } + + @Override + public void upsert(Entry entry) { + storage.put(entry.key(), entry); + } +} diff --git a/src/main/java/ru/vk/itmo/test/ryabovvadim/InMemoryDaoFactory.java b/src/main/java/ru/vk/itmo/test/ryabovvadim/InMemoryDaoFactory.java new file mode 100644 index 000000000..e2cbc1d92 --- /dev/null +++ b/src/main/java/ru/vk/itmo/test/ryabovvadim/InMemoryDaoFactory.java @@ -0,0 +1,39 @@ +package ru.vk.itmo.test.ryabovvadim; + +import ru.vk.itmo.Dao; +import ru.vk.itmo.Entry; +import ru.vk.itmo.test.DaoFactory; + +import java.lang.foreign.MemorySegment; +import java.lang.foreign.ValueLayout; + +import static java.nio.charset.StandardCharsets.UTF_8; + +@DaoFactory +public class InMemoryDaoFactory implements DaoFactory.Factory> { + @Override + public String toString(MemorySegment memorySegment) { + if (memorySegment == null) { + return null; + } + return new String(memorySegment.toArray(ValueLayout.JAVA_BYTE), UTF_8); + } + + @Override + public MemorySegment fromString(String data) { + if (data == null) { + return null; + } + return MemorySegment.ofArray(data.getBytes(UTF_8)); + } + + @Override + public Entry fromBaseEntry(Entry baseEntry) { + return baseEntry; + } + + @Override + public Dao> createDao() { + return new InMemoryDao(); + } +} From 5f328bbd88f5af4a66028d354afeca38ca88485f Mon Sep 17 00:00:00 2001 From: Almaz <71963023+Almasgali@users.noreply.github.com> Date: Mon, 2 Oct 2023 18:41:39 +0300 Subject: [PATCH 16/45] ITMO, Khadyrov Almasgali, M3335, H/W 1 (#27) Co-authored-by: Vadim Tsesko Co-authored-by: Alexey Shik <58121508+AlexeyShik@users.noreply.github.com> --- .../itmo/khadyrovalmasgali/InMemoryDao.java | 53 +++++++++++++++++++ .../khadyrovalmasgali/DaoFactoryImpl.java | 35 ++++++++++++ 2 files changed, 88 insertions(+) create mode 100644 src/main/java/ru/vk/itmo/khadyrovalmasgali/InMemoryDao.java create mode 100644 src/main/java/ru/vk/itmo/test/khadyrovalmasgali/DaoFactoryImpl.java diff --git a/src/main/java/ru/vk/itmo/khadyrovalmasgali/InMemoryDao.java b/src/main/java/ru/vk/itmo/khadyrovalmasgali/InMemoryDao.java new file mode 100644 index 000000000..92b8fb971 --- /dev/null +++ b/src/main/java/ru/vk/itmo/khadyrovalmasgali/InMemoryDao.java @@ -0,0 +1,53 @@ +package ru.vk.itmo.khadyrovalmasgali; + +import ru.vk.itmo.Dao; +import ru.vk.itmo.Entry; + +import java.lang.foreign.MemorySegment; +import java.lang.foreign.ValueLayout; +import java.util.Iterator; +import java.util.concurrent.ConcurrentNavigableMap; +import java.util.concurrent.ConcurrentSkipListMap; + +public class InMemoryDao implements Dao> { + + private final ConcurrentNavigableMap> data = new ConcurrentSkipListMap<>((o1, o2) -> { + long mismatch = o1.mismatch(o2); + if (mismatch == o2.byteSize()) { + return 1; + } else if (mismatch == o1.byteSize()) { + return -1; + } else if (mismatch == -1) { + return 0; + } + return Byte.compare( + o1.get(ValueLayout.JAVA_BYTE, mismatch), + o2.get(ValueLayout.JAVA_BYTE, mismatch)); + }); + + @Override + public Iterator> get(MemorySegment from, MemorySegment to) { + if (from == null && to == null) { + return data.values().iterator(); + } else if (from == null) { + return data.headMap(to).values().iterator(); + } else if (to == null) { + return data.tailMap(from).values().iterator(); + } else { + return data.subMap(from, to).values().iterator(); + } + } + + @Override + public Entry get(MemorySegment key) { + return data.get(key); + } + + @Override + public void upsert(Entry entry) { + if (entry != null) { + data.put(entry.key(), entry); + } + } +} diff --git a/src/main/java/ru/vk/itmo/test/khadyrovalmasgali/DaoFactoryImpl.java b/src/main/java/ru/vk/itmo/test/khadyrovalmasgali/DaoFactoryImpl.java new file mode 100644 index 000000000..de9db503c --- /dev/null +++ b/src/main/java/ru/vk/itmo/test/khadyrovalmasgali/DaoFactoryImpl.java @@ -0,0 +1,35 @@ +package ru.vk.itmo.test.khadyrovalmasgali; + +import ru.vk.itmo.Dao; +import ru.vk.itmo.Entry; +import ru.vk.itmo.khadyrovalmasgali.InMemoryDao; +import ru.vk.itmo.test.DaoFactory; + +import java.lang.foreign.MemorySegment; +import java.lang.foreign.ValueLayout; +import java.nio.charset.StandardCharsets; + +@DaoFactory +public class DaoFactoryImpl implements DaoFactory.Factory> { + @Override + public Dao> createDao() { + return new InMemoryDao(); + } + + @Override + public String toString(MemorySegment memorySegment) { + return memorySegment == null + ? null + : new String(memorySegment.toArray(ValueLayout.JAVA_BYTE), StandardCharsets.UTF_8); + } + + @Override + public MemorySegment fromString(String data) { + return data == null ? null : MemorySegment.ofArray(data.getBytes(StandardCharsets.UTF_8)); + } + + @Override + public Entry fromBaseEntry(Entry baseEntry) { + return baseEntry; + } +} From f99ab75fa72baa47e3afc1d30bb885c4656741e3 Mon Sep 17 00:00:00 2001 From: Nikita Sherepa <43075924+beatHunteRcode@users.noreply.github.com> Date: Tue, 3 Oct 2023 11:32:58 +0300 Subject: [PATCH 17/45] =?UTF-8?q?=D0=A8=D0=B5=D1=80=D0=B5=D0=BF=D0=B0=20?= =?UTF-8?q?=D0=9D=D0=B8=D0=BA=D0=B8=D1=82=D0=B0,=20HW=201,=20=D0=9F=D0=BE?= =?UTF-8?q?=D0=BB=D0=B8=D1=82=D0=B5=D1=85=20(#54)?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- .../ru/vk/itmo/sherepanikita/InMemoryDao.java | 44 ++++++++++++++++++ .../MemorySegmentComparator.java | 27 +++++++++++ .../itmo/test/sherepanikita/FactoryImpl.java | 45 +++++++++++++++++++ 3 files changed, 116 insertions(+) create mode 100644 src/main/java/ru/vk/itmo/sherepanikita/InMemoryDao.java create mode 100644 src/main/java/ru/vk/itmo/sherepanikita/MemorySegmentComparator.java create mode 100644 src/main/java/ru/vk/itmo/test/sherepanikita/FactoryImpl.java diff --git a/src/main/java/ru/vk/itmo/sherepanikita/InMemoryDao.java b/src/main/java/ru/vk/itmo/sherepanikita/InMemoryDao.java new file mode 100644 index 000000000..a0b39bdaa --- /dev/null +++ b/src/main/java/ru/vk/itmo/sherepanikita/InMemoryDao.java @@ -0,0 +1,44 @@ +package ru.vk.itmo.sherepanikita; + +import ru.vk.itmo.Dao; +import ru.vk.itmo.Entry; + +import java.lang.foreign.MemorySegment; +import java.util.Iterator; +import java.util.NavigableMap; +import java.util.concurrent.ConcurrentSkipListMap; + +public class InMemoryDao implements Dao> { + + private final NavigableMap> segments; + + public InMemoryDao() { + segments = new ConcurrentSkipListMap<>(new MemorySegmentComparator()); + } + + @Override + public Iterator> get(MemorySegment from, MemorySegment to) { + if (from == null && to == null) { + return segments.values().iterator(); + } else if (from == null) { + return segments.headMap(to).values().iterator(); + } else if (to == null) { + return segments.tailMap(from).values().iterator(); + } + return segments.subMap(from, to).values().iterator(); + } + + @Override + public Entry get(MemorySegment key) { + return segments.get(key); + } + + @Override + public void upsert(Entry entry) { + if (entry == null) { + throw new IllegalArgumentException("Incoming entry is NULL"); + } + segments.put(entry.key(), entry); + } + +} diff --git a/src/main/java/ru/vk/itmo/sherepanikita/MemorySegmentComparator.java b/src/main/java/ru/vk/itmo/sherepanikita/MemorySegmentComparator.java new file mode 100644 index 000000000..f2288bb1c --- /dev/null +++ b/src/main/java/ru/vk/itmo/sherepanikita/MemorySegmentComparator.java @@ -0,0 +1,27 @@ +package ru.vk.itmo.sherepanikita; + +import java.lang.foreign.MemorySegment; +import java.lang.foreign.ValueLayout; +import java.util.Comparator; + +public class MemorySegmentComparator implements Comparator { + @Override + public int compare(MemorySegment segmentOne, MemorySegment segmentTwo) { + + long offsetInBytes = segmentOne.mismatch(segmentTwo); + long segmentOneSizeInBytes = segmentOne.byteSize(); + long segmentTwoSizeInBytes = segmentTwo.byteSize(); + + if (offsetInBytes == -1) { + return 0; + } else if (offsetInBytes == segmentOneSizeInBytes) { + return -1; + } else if (offsetInBytes == segmentTwoSizeInBytes) { + return 1; + } + return Byte.compare( + segmentOne.get(ValueLayout.JAVA_BYTE, offsetInBytes), + segmentTwo.get(ValueLayout.JAVA_BYTE, offsetInBytes) + ); + } +} diff --git a/src/main/java/ru/vk/itmo/test/sherepanikita/FactoryImpl.java b/src/main/java/ru/vk/itmo/test/sherepanikita/FactoryImpl.java new file mode 100644 index 000000000..a4ef0f680 --- /dev/null +++ b/src/main/java/ru/vk/itmo/test/sherepanikita/FactoryImpl.java @@ -0,0 +1,45 @@ +package ru.vk.itmo.test.sherepanikita; + +import ru.vk.itmo.Dao; +import ru.vk.itmo.Entry; +import ru.vk.itmo.sherepanikita.InMemoryDao; +import ru.vk.itmo.test.DaoFactory; + +import java.lang.foreign.MemorySegment; +import java.lang.foreign.ValueLayout; +import java.nio.charset.StandardCharsets; + +@DaoFactory +public class FactoryImpl implements DaoFactory.Factory> { + + @Override + public Dao> createDao() { + return new InMemoryDao(); + } + + @Override + public String toString(MemorySegment memorySegment) { + if (memorySegment == null) { + return null; + } else { + return new String( + memorySegment.toArray(ValueLayout.JAVA_BYTE), + StandardCharsets.UTF_8 + ); + } + } + + @Override + public MemorySegment fromString(String data) { + if (data == null) { + return null; + } else { + return MemorySegment.ofArray(data.getBytes(StandardCharsets.UTF_8)); + } + } + + @Override + public Entry fromBaseEntry(Entry baseEntry) { + return baseEntry; + } +} From 1734ed213852551a072d706a3d486d14ff5fb2c2 Mon Sep 17 00:00:00 2001 From: Maxim Trofimov <57316041+trofik00777@users.noreply.github.com> Date: Tue, 3 Oct 2023 11:57:20 +0300 Subject: [PATCH 18/45] =?UTF-8?q?=D0=A2=D1=80=D0=BE=D1=84=D0=B8=D0=BC?= =?UTF-8?q?=D0=BE=D0=B2=20=D0=9C=D0=B0=D0=BA=D1=81=D0=B8=D0=BC,=20=D0=A4?= =?UTF-8?q?=D0=98=D0=A2=D0=B8=D0=9F,=20M33351=20(#18)?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Co-authored-by: Vadim Tsesko Co-authored-by: Daniil Ushkov <42135591+daniil-ushkov@users.noreply.github.com> --- .../test/trofimovmaxim/DaoFactoryImpl.java | 35 +++++++++++ .../ru/vk/itmo/trofimovmaxim/InMemoryDao.java | 63 +++++++++++++++++++ 2 files changed, 98 insertions(+) create mode 100644 src/main/java/ru/vk/itmo/test/trofimovmaxim/DaoFactoryImpl.java create mode 100644 src/main/java/ru/vk/itmo/trofimovmaxim/InMemoryDao.java diff --git a/src/main/java/ru/vk/itmo/test/trofimovmaxim/DaoFactoryImpl.java b/src/main/java/ru/vk/itmo/test/trofimovmaxim/DaoFactoryImpl.java new file mode 100644 index 000000000..d2aa95af0 --- /dev/null +++ b/src/main/java/ru/vk/itmo/test/trofimovmaxim/DaoFactoryImpl.java @@ -0,0 +1,35 @@ +package ru.vk.itmo.test.trofimovmaxim; + +import ru.vk.itmo.Dao; +import ru.vk.itmo.Entry; +import ru.vk.itmo.test.DaoFactory; +import ru.vk.itmo.trofimovmaxim.InMemoryDao; + +import java.lang.foreign.MemorySegment; +import java.lang.foreign.ValueLayout; +import java.nio.charset.StandardCharsets; + +@DaoFactory +public class DaoFactoryImpl implements DaoFactory.Factory> { + @Override + public Dao> createDao() { + return new InMemoryDao(); + } + + @Override + public String toString(MemorySegment memorySegment) { + return memorySegment == null ? null : + new String(memorySegment.toArray(ValueLayout.OfByte.JAVA_BYTE), StandardCharsets.UTF_8); + } + + @Override + public MemorySegment fromString(String data) { + return data == null ? null : + MemorySegment.ofArray(data.getBytes(StandardCharsets.UTF_8)); + } + + @Override + public Entry fromBaseEntry(Entry baseEntry) { + return baseEntry; + } +} diff --git a/src/main/java/ru/vk/itmo/trofimovmaxim/InMemoryDao.java b/src/main/java/ru/vk/itmo/trofimovmaxim/InMemoryDao.java new file mode 100644 index 000000000..9769dfdaf --- /dev/null +++ b/src/main/java/ru/vk/itmo/trofimovmaxim/InMemoryDao.java @@ -0,0 +1,63 @@ +package ru.vk.itmo.trofimovmaxim; + +import ru.vk.itmo.Dao; +import ru.vk.itmo.Entry; + +import java.lang.foreign.MemorySegment; +import java.lang.foreign.ValueLayout; +import java.util.Comparator; +import java.util.Iterator; +import java.util.concurrent.ConcurrentNavigableMap; +import java.util.concurrent.ConcurrentSkipListMap; + +public class InMemoryDao implements Dao> { + + private final ConcurrentNavigableMap> data; + + private static final Comparator COMPARE_SEGMENT = (o1, o2) -> { + if (o1 == null || o2 == null) { + return o1 == null ? -1 : 1; + } + + long mism = o1.mismatch(o2); + if (mism == -1) { + return (int) (o1.byteSize() - o2.byteSize()); + } + if (mism == o1.byteSize() || mism == o2.byteSize()) { + return mism == o1.byteSize() ? -1 : 1; + } + return Byte.compare( + o1.get(ValueLayout.OfByte.JAVA_BYTE, mism), + o2.get(ValueLayout.OfByte.JAVA_BYTE, mism) + ); + }; + + public InMemoryDao() { + data = new ConcurrentSkipListMap<>(COMPARE_SEGMENT); + } + + @Override + public Iterator> get(MemorySegment from, MemorySegment to) { + if (from == null || to == null) { + if (from == null && to == null) { + return data.values().iterator(); + } else if (from == null) { + return data.headMap(to).values().iterator(); + } else { + return data.tailMap(from).values().iterator(); + } + } else { + return data.subMap(from, to).values().iterator(); + } + } + + @Override + public Entry get(MemorySegment key) { + return data.get(key); + } + + @Override + public void upsert(Entry entry) { + data.put(entry.key(), entry); + } +} From c5a3155ed473d9b1269efe45a0eae6601cd8f62b Mon Sep 17 00:00:00 2001 From: croil <113173579+croil@users.noreply.github.com> Date: Tue, 3 Oct 2023 12:00:03 +0300 Subject: [PATCH 19/45] =?UTF-8?q?=D0=9D=D0=BE=D0=B2=D0=B8=D1=87=D0=BA?= =?UTF-8?q?=D0=BE=D0=B2=20=D0=90=D0=BD=D0=B4=D1=80=D0=B5=D0=B9,=20=D0=98?= =?UTF-8?q?=D0=A2=D0=9C=D0=9E=20=D0=A4=D0=98=D0=A2=D0=B8=D0=9F,=20=D0=9C33?= =?UTF-8?q?321,=20HW1=20(#30)?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Co-authored-by: Vadim Tsesko Co-authored-by: Daniil Ushkov <42135591+daniil-ushkov@users.noreply.github.com> --- .../vk/itmo/novichkovandrew/InMemoryDao.java | 62 +++++++++++++++++++ .../novichkovandrew/InMemoryDaoFactory.java | 33 ++++++++++ 2 files changed, 95 insertions(+) create mode 100644 src/main/java/ru/vk/itmo/novichkovandrew/InMemoryDao.java create mode 100644 src/main/java/ru/vk/itmo/test/novichkovandrew/InMemoryDaoFactory.java diff --git a/src/main/java/ru/vk/itmo/novichkovandrew/InMemoryDao.java b/src/main/java/ru/vk/itmo/novichkovandrew/InMemoryDao.java new file mode 100644 index 000000000..b98859c30 --- /dev/null +++ b/src/main/java/ru/vk/itmo/novichkovandrew/InMemoryDao.java @@ -0,0 +1,62 @@ +package ru.vk.itmo.novichkovandrew; + +import ru.vk.itmo.Dao; +import ru.vk.itmo.Entry; + +import java.lang.foreign.MemorySegment; +import java.lang.foreign.ValueLayout; +import java.util.Iterator; +import java.util.NavigableMap; +import java.util.concurrent.ConcurrentSkipListMap; + +public class InMemoryDao implements Dao> { + + private final ConcurrentSkipListMap> entriesMap; + + public InMemoryDao() { + this.entriesMap = new ConcurrentSkipListMap<>(this::compareMemorySegment); + } + + private NavigableMap> getSubMap(MemorySegment from, MemorySegment to) { + if (from != null && to != null) { + return entriesMap.subMap(from, to); + } + if (from != null) { + return entriesMap.tailMap(from, true); + } + if (to != null) { + return entriesMap.headMap(to, false); + } + return entriesMap; + } + + @Override + public Iterator> get(MemorySegment from, MemorySegment to) { + return getSubMap(from, to).values().iterator(); + } + + @Override + public Entry get(MemorySegment key) { + return entriesMap.get(key); + } + + @Override + public void upsert(Entry entry) { + entriesMap.put(entry.key(), entry); + } + + private int compareMemorySegment(MemorySegment first, MemorySegment second) { + if (first == null || second == null) return -1; + long missIndex = first.mismatch(second); + if (missIndex == first.byteSize()) { + return -1; + } + if (missIndex == second.byteSize()) { + return 1; + } + return missIndex == -1 ? 0 : Byte.compare( + first.getAtIndex(ValueLayout.JAVA_BYTE, missIndex), + second.getAtIndex(ValueLayout.JAVA_BYTE, missIndex) + ); + } +} diff --git a/src/main/java/ru/vk/itmo/test/novichkovandrew/InMemoryDaoFactory.java b/src/main/java/ru/vk/itmo/test/novichkovandrew/InMemoryDaoFactory.java new file mode 100644 index 000000000..7d9f1da9b --- /dev/null +++ b/src/main/java/ru/vk/itmo/test/novichkovandrew/InMemoryDaoFactory.java @@ -0,0 +1,33 @@ +package ru.vk.itmo.test.novichkovandrew; + +import ru.vk.itmo.Dao; +import ru.vk.itmo.Entry; +import ru.vk.itmo.novichkovandrew.InMemoryDao; +import ru.vk.itmo.test.DaoFactory; + +import java.lang.foreign.MemorySegment; +import java.lang.foreign.ValueLayout; +import java.nio.charset.StandardCharsets; + +@DaoFactory +public class InMemoryDaoFactory implements DaoFactory.Factory> { + @Override + public Dao> createDao() { + return new InMemoryDao(); + } + + @Override + public String toString(MemorySegment memorySegment) { + return new String(memorySegment.toArray(ValueLayout.JAVA_BYTE), StandardCharsets.UTF_8); + } + + @Override + public MemorySegment fromString(String data) { + return data == null ? null : MemorySegment.ofArray(data.getBytes(StandardCharsets.UTF_8)); + } + + @Override + public Entry fromBaseEntry(Entry baseEntry) { + return baseEntry; + } +} From 30386139a933fdd3f5c8f4c080be8f457ced73f4 Mon Sep 17 00:00:00 2001 From: PetyaVasya <37338356+PetyaVasya@users.noreply.github.com> Date: Tue, 3 Oct 2023 12:04:08 +0300 Subject: [PATCH 20/45] HW1 (#43) Co-authored-by: Vadim Tsesko Co-authored-by: Daniil Ushkov <42135591+daniil-ushkov@users.noreply.github.com> --- .../java/ru/vk/itmo/kovalevigor/DaoImpl.java | 84 +++++++++++++++++++ .../itmo/test/kovalevigor/DaoFactoryImpl.java | 37 ++++++++ 2 files changed, 121 insertions(+) create mode 100644 src/main/java/ru/vk/itmo/kovalevigor/DaoImpl.java create mode 100644 src/main/java/ru/vk/itmo/test/kovalevigor/DaoFactoryImpl.java diff --git a/src/main/java/ru/vk/itmo/kovalevigor/DaoImpl.java b/src/main/java/ru/vk/itmo/kovalevigor/DaoImpl.java new file mode 100644 index 000000000..e1c6e6f6f --- /dev/null +++ b/src/main/java/ru/vk/itmo/kovalevigor/DaoImpl.java @@ -0,0 +1,84 @@ +package ru.vk.itmo.kovalevigor; + +import ru.vk.itmo.Dao; +import ru.vk.itmo.Entry; + +import java.lang.foreign.MemorySegment; +import java.lang.foreign.ValueLayout; +import java.util.Comparator; +import java.util.Iterator; +import java.util.Objects; +import java.util.concurrent.ConcurrentNavigableMap; +import java.util.concurrent.ConcurrentSkipListMap; + +public class DaoImpl implements Dao> { + + private final ConcurrentNavigableMap> storage; + + public static final Comparator COMPARATOR = (lhs, rhs) -> { + final long mismatch = lhs.mismatch(rhs); + final long lhsSize = lhs.byteSize(); + final long rhsSize = rhs.byteSize(); + final long minSize = Math.min(lhsSize, rhsSize); + if (mismatch == -1) { + return 0; + } else if (minSize == mismatch) { + return Long.compare(lhsSize, rhsSize); + } + return Byte.compare(getByte(lhs, mismatch), getByte(rhs, mismatch)); + }; + + public DaoImpl() { + storage = new ConcurrentSkipListMap<>(COMPARATOR); + } + + private static Iterator getValuesIterator(final ConcurrentNavigableMap map) { + return map.values().iterator(); + } + + private static byte getByte(final MemorySegment memorySegment, final long offset) { + return memorySegment.get(ValueLayout.JAVA_BYTE, offset); + } + + @Override + public Iterator> get(final MemorySegment from, final MemorySegment to) { + if (from == null) { + if (to == null) { + return all(); + } + return allTo(to); + } else if (to == null) { + return allFrom(from); + } + return getValuesIterator(storage.subMap(from, to)); + } + + @Override + public void upsert(final Entry entry) { + Objects.requireNonNull(entry); + storage.put(entry.key(), entry); + } + + @Override + public Iterator> allFrom(final MemorySegment from) { + Objects.requireNonNull(from); + return getValuesIterator(storage.tailMap(from)); + } + + @Override + public Iterator> allTo(final MemorySegment to) { + Objects.requireNonNull(to); + return getValuesIterator(storage.headMap(to)); + } + + @Override + public Iterator> all() { + return getValuesIterator(storage); + } + + @Override + public Entry get(final MemorySegment key) { + Objects.requireNonNull(key); + return storage.get(key); + } +} diff --git a/src/main/java/ru/vk/itmo/test/kovalevigor/DaoFactoryImpl.java b/src/main/java/ru/vk/itmo/test/kovalevigor/DaoFactoryImpl.java new file mode 100644 index 000000000..cd3eef703 --- /dev/null +++ b/src/main/java/ru/vk/itmo/test/kovalevigor/DaoFactoryImpl.java @@ -0,0 +1,37 @@ +package ru.vk.itmo.test.kovalevigor; + +import ru.vk.itmo.Dao; +import ru.vk.itmo.Entry; +import ru.vk.itmo.kovalevigor.DaoImpl; +import ru.vk.itmo.test.DaoFactory; + +import java.lang.foreign.MemorySegment; +import java.lang.foreign.ValueLayout; +import java.nio.charset.Charset; +import java.nio.charset.StandardCharsets; + +@DaoFactory +public class DaoFactoryImpl implements DaoFactory.Factory> { + + public static final Charset CHARSET = StandardCharsets.UTF_8; + + @Override + public Dao> createDao() { + return new DaoImpl(); + } + + @Override + public String toString(final MemorySegment memorySegment) { + return memorySegment == null ? null : new String(memorySegment.toArray(ValueLayout.JAVA_BYTE), CHARSET); + } + + @Override + public MemorySegment fromString(final String data) { + return data == null ? null : MemorySegment.ofArray(data.getBytes(CHARSET)); + } + + @Override + public Entry fromBaseEntry(Entry baseEntry) { + return baseEntry; + } +} From e46298bed7b5efb56d4b26db9f826224b26f22f2 Mon Sep 17 00:00:00 2001 From: Kononov Vladimir <72575440+lukna5@users.noreply.github.com> Date: Tue, 3 Oct 2023 12:31:34 +0300 Subject: [PATCH 21/45] =?UTF-8?q?=D0=9A=D0=BE=D0=BD=D0=BE=D0=BD=D0=BE?= =?UTF-8?q?=D0=B2=20=D0=92=D0=BB=D0=B0=D0=B4=D0=B8=D0=BC=D0=B8=D1=80=20?= =?UTF-8?q?=D0=98=D0=A2=D0=9C=D0=9E=20=D0=A4=D0=98=D0=A2=D0=B8=D0=9F=20?= =?UTF-8?q?=D0=B1=D0=B0=D0=BA=D0=B0=D0=BB=D0=B0=D0=B2=D1=80,=20=D0=B4?= =?UTF-8?q?=D0=B7=201=20(#64)?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Co-authored-by: vkononov Co-authored-by: Daniil Ushkov <42135591+daniil-ushkov@users.noreply.github.com> --- .../test/kononovvladimir/FactoryImpl.java | 35 +++++++++++ .../test/kononovvladimir/InMemoryDao.java | 59 +++++++++++++++++++ 2 files changed, 94 insertions(+) create mode 100644 src/main/java/ru/vk/itmo/test/kononovvladimir/FactoryImpl.java create mode 100644 src/main/java/ru/vk/itmo/test/kononovvladimir/InMemoryDao.java diff --git a/src/main/java/ru/vk/itmo/test/kononovvladimir/FactoryImpl.java b/src/main/java/ru/vk/itmo/test/kononovvladimir/FactoryImpl.java new file mode 100644 index 000000000..b7550aa0d --- /dev/null +++ b/src/main/java/ru/vk/itmo/test/kononovvladimir/FactoryImpl.java @@ -0,0 +1,35 @@ +package ru.vk.itmo.test.kononovvladimir; + +import ru.vk.itmo.Config; +import ru.vk.itmo.Dao; +import ru.vk.itmo.Entry; +import ru.vk.itmo.test.DaoFactory; + +import java.lang.foreign.MemorySegment; +import java.lang.foreign.ValueLayout; +import java.nio.charset.StandardCharsets; + +@DaoFactory +public class FactoryImpl implements DaoFactory.Factory> { + @Override + public String toString(MemorySegment memorySegment) { + return memorySegment == null ? null + : new String(memorySegment.toArray(ValueLayout.JAVA_BYTE), StandardCharsets.UTF_8); + } + + @Override + public MemorySegment fromString(String data) { + return data == null ? null + : MemorySegment.ofArray(data.getBytes(StandardCharsets.UTF_8)); + } + + @Override + public Dao> createDao(Config config) { + return new InMemoryDao(); + } + + @Override + public Entry fromBaseEntry(Entry baseEntry) { + return baseEntry; + } +} diff --git a/src/main/java/ru/vk/itmo/test/kononovvladimir/InMemoryDao.java b/src/main/java/ru/vk/itmo/test/kononovvladimir/InMemoryDao.java new file mode 100644 index 000000000..7f73ebc3b --- /dev/null +++ b/src/main/java/ru/vk/itmo/test/kononovvladimir/InMemoryDao.java @@ -0,0 +1,59 @@ +package ru.vk.itmo.test.kononovvladimir; + +import ru.vk.itmo.Dao; +import ru.vk.itmo.Entry; + +import java.lang.foreign.MemorySegment; +import java.lang.foreign.ValueLayout; +import java.util.Comparator; +import java.util.Iterator; +import java.util.concurrent.ConcurrentNavigableMap; +import java.util.concurrent.ConcurrentSkipListMap; + +class InMemoryDao implements Dao> { + + private final Comparator memorySegmentComparator = (o1, o2) -> { + long mismatch = o1.mismatch(o2); + if (mismatch == -1) return 0; + else if (mismatch == o1.byteSize()) { + return -1; + } else if (mismatch == o2.byteSize()) { + return 1; + } else { + byte b1 = o1.get(ValueLayout.JAVA_BYTE, mismatch); + byte b2 = o2.get(ValueLayout.JAVA_BYTE, mismatch); + return Byte.compare(b1, b2); + } + }; + private final ConcurrentNavigableMap> concurrentSkipListMap + = new ConcurrentSkipListMap<>(memorySegmentComparator); + + @Override + public Entry get(MemorySegment key) { + return concurrentSkipListMap.get(key); + } + + @Override + public Iterator> get(MemorySegment from, MemorySegment to) { + if (from == null && to == null) { + return concurrentSkipListMap.values().iterator(); + } + + if (from == null) { + return concurrentSkipListMap.headMap(to).values().iterator(); + } + + if (to == null) { + return concurrentSkipListMap.tailMap(from).values().iterator(); + } + + return concurrentSkipListMap.subMap(from, to).values().iterator(); + } + + @Override + public void upsert(Entry entry) { + if (entry == null || entry.key() == null || entry.value() == null) return; + + concurrentSkipListMap.put(entry.key(), entry); + } +} From 34a69d8fdde92b358bf52e2510afe2a238477f2b Mon Sep 17 00:00:00 2001 From: Alexander Peskov <73636600+aosandy@users.noreply.github.com> Date: Tue, 3 Oct 2023 19:17:08 +0300 Subject: [PATCH 22/45] =?UTF-8?q?=D0=9F=D0=B5=D1=81=D0=BA=D0=BE=D0=B2=20?= =?UTF-8?q?=D0=90=D0=BB=D0=B5=D0=BA=D1=81=D0=B0=D0=BD=D0=B4=D1=80,=20?= =?UTF-8?q?=D0=9F=D0=BE=D0=BB=D0=B8=D1=82=D0=B5=D1=85,=20=D0=B7=D0=B0?= =?UTF-8?q?=D0=B4=D0=B0=D0=BD=D0=B8=D0=B5=201=20(#28)?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- .../vk/itmo/peskovalexandr/InMemoryDao.java | 43 +++++++++++++++++++ .../MemorySegmentComparator.java | 23 ++++++++++ .../itmo/test/peskovalexandr/MyFactory.java | 34 +++++++++++++++ 3 files changed, 100 insertions(+) create mode 100644 src/main/java/ru/vk/itmo/peskovalexandr/InMemoryDao.java create mode 100644 src/main/java/ru/vk/itmo/peskovalexandr/MemorySegmentComparator.java create mode 100644 src/main/java/ru/vk/itmo/test/peskovalexandr/MyFactory.java diff --git a/src/main/java/ru/vk/itmo/peskovalexandr/InMemoryDao.java b/src/main/java/ru/vk/itmo/peskovalexandr/InMemoryDao.java new file mode 100644 index 000000000..45bf1efbc --- /dev/null +++ b/src/main/java/ru/vk/itmo/peskovalexandr/InMemoryDao.java @@ -0,0 +1,43 @@ +package ru.vk.itmo.peskovalexandr; + +import ru.vk.itmo.Dao; +import ru.vk.itmo.Entry; +import java.lang.foreign.MemorySegment; +import java.util.Iterator; +import java.util.Map; +import java.util.concurrent.ConcurrentNavigableMap; +import java.util.concurrent.ConcurrentSkipListMap; + +public class InMemoryDao implements Dao> { + + private final ConcurrentNavigableMap> entryMap = + new ConcurrentSkipListMap<>(new MemorySegmentComparator()); + + @Override + public Entry get(MemorySegment key) { + return entryMap.get(key); + } + + @Override + public Iterator> get(MemorySegment from, MemorySegment to) { + return getSubMap(from, to).values().iterator(); + } + + @Override + public void upsert(Entry entry) { + entryMap.put(entry.key(), entry); + } + + private Map> getSubMap(MemorySegment from, MemorySegment to) { + if (from == null && to == null) { + return entryMap; + } + if (from == null) { + return entryMap.headMap(to, false); + } + if (to == null) { + return entryMap.tailMap(from, true); + } + return entryMap.subMap(from, true, to, false); + } +} diff --git a/src/main/java/ru/vk/itmo/peskovalexandr/MemorySegmentComparator.java b/src/main/java/ru/vk/itmo/peskovalexandr/MemorySegmentComparator.java new file mode 100644 index 000000000..db0160b85 --- /dev/null +++ b/src/main/java/ru/vk/itmo/peskovalexandr/MemorySegmentComparator.java @@ -0,0 +1,23 @@ +package ru.vk.itmo.peskovalexandr; + +import java.lang.foreign.MemorySegment; +import java.lang.foreign.ValueLayout; +import java.util.Comparator; + +public class MemorySegmentComparator implements Comparator { + + @Override + public int compare(MemorySegment o1, MemorySegment o2) { + long mismatchOffset = o1.mismatch(o2); + if (mismatchOffset == -1) { + return 0; + } + if (mismatchOffset == o1.byteSize()) { + return -1; + } + if (mismatchOffset == o2.byteSize()) { + return 1; + } + return o1.get(ValueLayout.JAVA_BYTE, mismatchOffset) - o2.get(ValueLayout.JAVA_BYTE, mismatchOffset); + } +} diff --git a/src/main/java/ru/vk/itmo/test/peskovalexandr/MyFactory.java b/src/main/java/ru/vk/itmo/test/peskovalexandr/MyFactory.java new file mode 100644 index 000000000..827df1975 --- /dev/null +++ b/src/main/java/ru/vk/itmo/test/peskovalexandr/MyFactory.java @@ -0,0 +1,34 @@ +package ru.vk.itmo.test.peskovalexandr; + +import ru.vk.itmo.Dao; +import ru.vk.itmo.Entry; +import ru.vk.itmo.peskovalexandr.InMemoryDao; +import ru.vk.itmo.test.DaoFactory; +import java.lang.foreign.MemorySegment; +import java.lang.foreign.ValueLayout; +import java.nio.charset.StandardCharsets; + +@DaoFactory +public class MyFactory implements DaoFactory.Factory> { + + @Override + public Dao> createDao() { + return new InMemoryDao(); + } + + @Override + public String toString(MemorySegment memorySegment) { + return memorySegment == null ? null : + new String(memorySegment.toArray(ValueLayout.JAVA_BYTE), StandardCharsets.UTF_8); + } + + @Override + public MemorySegment fromString(String data) { + return data == null ? null : MemorySegment.ofArray(data.getBytes(StandardCharsets.UTF_8)); + } + + @Override + public Entry fromBaseEntry(Entry baseEntry) { + return baseEntry; + } +} From db50d253b019e137afbab51a9d58c6d8a38b4c81 Mon Sep 17 00:00:00 2001 From: fo-xi <60314037+fo-xi@users.noreply.github.com> Date: Tue, 3 Oct 2023 23:50:08 +0300 Subject: [PATCH 23/45] =?UTF-8?q?HW1=20=D0=94=D1=8F=D0=B3=D0=B0=D0=B9=20?= =?UTF-8?q?=D0=90=D0=BB=D0=B5=D0=BA=D1=81=D0=B0=D0=BD=D0=B4=D1=80=D0=B0,?= =?UTF-8?q?=20=D0=9F=D0=BE=D0=BB=D0=B8=D1=82=D0=B5=D1=85=20(#33)?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- .../vk/itmo/dyagayalexandra/InMemoryDao.java | 48 +++++++++++++++++++ .../MemorySegmentComparator.java | 28 +++++++++++ .../dyagayalexandra/InMemoryDaoFactory.java | 35 ++++++++++++++ 3 files changed, 111 insertions(+) create mode 100644 src/main/java/ru/vk/itmo/dyagayalexandra/InMemoryDao.java create mode 100644 src/main/java/ru/vk/itmo/dyagayalexandra/MemorySegmentComparator.java create mode 100644 src/main/java/ru/vk/itmo/test/dyagayalexandra/InMemoryDaoFactory.java diff --git a/src/main/java/ru/vk/itmo/dyagayalexandra/InMemoryDao.java b/src/main/java/ru/vk/itmo/dyagayalexandra/InMemoryDao.java new file mode 100644 index 000000000..52754fb84 --- /dev/null +++ b/src/main/java/ru/vk/itmo/dyagayalexandra/InMemoryDao.java @@ -0,0 +1,48 @@ +package ru.vk.itmo.dyagayalexandra; + +import ru.vk.itmo.Dao; +import ru.vk.itmo.Entry; + +import java.lang.foreign.MemorySegment; +import java.util.Collection; +import java.util.Comparator; +import java.util.Iterator; +import java.util.concurrent.ConcurrentNavigableMap; +import java.util.concurrent.ConcurrentSkipListMap; + +public class InMemoryDao implements Dao> { + + private final Comparator comparator = new MemorySegmentComparator(); + + private final ConcurrentNavigableMap> storage; + + public InMemoryDao() { + storage = new ConcurrentSkipListMap<>(comparator); + } + + @Override + public Iterator> get(MemorySegment from, MemorySegment to) { + Collection> values; + if (from == null && to == null) { + values = storage.values(); + } else if (from == null) { + values = storage.headMap(to).values(); + } else if (to == null) { + values = storage.tailMap(from).values(); + } else { + values = storage.subMap(from, to).values(); + } + + return values.iterator(); + } + + @Override + public Entry get(MemorySegment key) { + return storage.get(key); + } + + @Override + public void upsert(Entry entry) { + storage.put(entry.key(), entry); + } +} diff --git a/src/main/java/ru/vk/itmo/dyagayalexandra/MemorySegmentComparator.java b/src/main/java/ru/vk/itmo/dyagayalexandra/MemorySegmentComparator.java new file mode 100644 index 000000000..a350f8c24 --- /dev/null +++ b/src/main/java/ru/vk/itmo/dyagayalexandra/MemorySegmentComparator.java @@ -0,0 +1,28 @@ +package ru.vk.itmo.dyagayalexandra; + +import java.lang.foreign.MemorySegment; +import java.lang.foreign.ValueLayout; +import java.util.Comparator; + +public final class MemorySegmentComparator implements Comparator { + + @Override + public int compare(MemorySegment memorySegment1, MemorySegment memorySegment2) { + long offset = memorySegment1.mismatch(memorySegment2); + + if (offset == -1) { + return 0; + } + if (offset == memorySegment1.byteSize()) { + return -1; + } + if (offset == memorySegment2.byteSize()) { + return 1; + } + + byte firstMemorySegmentByte = memorySegment1.get(ValueLayout.JAVA_BYTE, offset); + byte secondMemorySegmentByte = memorySegment2.get(ValueLayout.JAVA_BYTE, offset); + + return Byte.compare(firstMemorySegmentByte, secondMemorySegmentByte); + } +} diff --git a/src/main/java/ru/vk/itmo/test/dyagayalexandra/InMemoryDaoFactory.java b/src/main/java/ru/vk/itmo/test/dyagayalexandra/InMemoryDaoFactory.java new file mode 100644 index 000000000..e3ecbc49b --- /dev/null +++ b/src/main/java/ru/vk/itmo/test/dyagayalexandra/InMemoryDaoFactory.java @@ -0,0 +1,35 @@ +package ru.vk.itmo.test.dyagayalexandra; + +import ru.vk.itmo.Dao; +import ru.vk.itmo.Entry; +import ru.vk.itmo.dyagayalexandra.InMemoryDao; +import ru.vk.itmo.test.DaoFactory; + +import java.lang.foreign.MemorySegment; +import java.lang.foreign.ValueLayout; +import java.nio.charset.StandardCharsets; + +@DaoFactory +public class InMemoryDaoFactory implements DaoFactory.Factory> { + + @Override + public Dao> createDao() { + return new InMemoryDao(); + } + + @Override + public String toString(MemorySegment memorySegment) { + return memorySegment == null ? null : new String(memorySegment.toArray(ValueLayout.JAVA_BYTE), + StandardCharsets.UTF_8); + } + + @Override + public MemorySegment fromString(String data) { + return data == null ? null : MemorySegment.ofArray(data.getBytes(StandardCharsets.UTF_8)); + } + + @Override + public Entry fromBaseEntry(Entry baseEntry) { + return baseEntry; + } +} From 0a7b501b06f833d833d8ba5c7004d59994f17caf Mon Sep 17 00:00:00 2001 From: Viktor <36002722+vitekkor@users.noreply.github.com> Date: Wed, 4 Oct 2023 10:11:59 +0300 Subject: [PATCH 24/45] =?UTF-8?q?=D0=92=D0=B8=D0=BA=D1=82=D0=BE=D1=80=20?= =?UTF-8?q?=D0=9A=D0=BE=D1=80=D0=BE=D1=82=D0=BA=D0=B8=D1=85=20/=20=D0=98?= =?UTF-8?q?=D0=A2=D0=9C=D0=9E=20DWS=20/=20HW=201=20(#13)?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Co-authored-by: vitekkor --- .../test/viktorkorotkikh/FactoryImpl.java | 36 +++++++++++++++ .../itmo/viktorkorotkikh/InMemoryDaoImpl.java | 45 +++++++++++++++++++ .../MemorySegmentComparator.java | 26 +++++++++++ 3 files changed, 107 insertions(+) create mode 100644 src/main/java/ru/vk/itmo/test/viktorkorotkikh/FactoryImpl.java create mode 100644 src/main/java/ru/vk/itmo/viktorkorotkikh/InMemoryDaoImpl.java create mode 100644 src/main/java/ru/vk/itmo/viktorkorotkikh/MemorySegmentComparator.java diff --git a/src/main/java/ru/vk/itmo/test/viktorkorotkikh/FactoryImpl.java b/src/main/java/ru/vk/itmo/test/viktorkorotkikh/FactoryImpl.java new file mode 100644 index 000000000..f6beacb37 --- /dev/null +++ b/src/main/java/ru/vk/itmo/test/viktorkorotkikh/FactoryImpl.java @@ -0,0 +1,36 @@ +package ru.vk.itmo.test.viktorkorotkikh; + +import ru.vk.itmo.Dao; +import ru.vk.itmo.Entry; +import ru.vk.itmo.test.DaoFactory; +import ru.vk.itmo.viktorkorotkikh.InMemoryDaoImpl; + +import java.lang.foreign.MemorySegment; +import java.lang.foreign.ValueLayout; +import java.nio.charset.StandardCharsets; + +@DaoFactory +public class FactoryImpl implements DaoFactory.Factory> { + @Override + public Dao> createDao() { + return new InMemoryDaoImpl(); + } + + @Override + public String toString(MemorySegment memorySegment) { + if (memorySegment == null) { + return null; + } + return new String(memorySegment.toArray(ValueLayout.JAVA_BYTE), StandardCharsets.UTF_8); + } + + @Override + public MemorySegment fromString(String data) { + return data == null ? null : MemorySegment.ofArray(data.getBytes(StandardCharsets.UTF_8)); + } + + @Override + public Entry fromBaseEntry(Entry baseEntry) { + return baseEntry; + } +} diff --git a/src/main/java/ru/vk/itmo/viktorkorotkikh/InMemoryDaoImpl.java b/src/main/java/ru/vk/itmo/viktorkorotkikh/InMemoryDaoImpl.java new file mode 100644 index 000000000..15074ceab --- /dev/null +++ b/src/main/java/ru/vk/itmo/viktorkorotkikh/InMemoryDaoImpl.java @@ -0,0 +1,45 @@ +package ru.vk.itmo.viktorkorotkikh; + +import ru.vk.itmo.Dao; +import ru.vk.itmo.Entry; + +import java.lang.foreign.MemorySegment; +import java.util.Iterator; +import java.util.NavigableMap; +import java.util.concurrent.ConcurrentSkipListMap; + +public class InMemoryDaoImpl implements Dao> { + + private final NavigableMap> storage; + + public InMemoryDaoImpl() { + this.storage = new ConcurrentSkipListMap<>(new MemorySegmentComparator()); + } + + @Override + public Iterator> get(MemorySegment from, MemorySegment to) { + if (from == null && to == null) { + return storage.sequencedValues().iterator(); + } + + if (from == null) { + return storage.headMap(to).sequencedValues().iterator(); + } + + if (to == null) { + return storage.tailMap(from).sequencedValues().iterator(); + } + + return storage.subMap(from, to).sequencedValues().iterator(); + } + + @Override + public Entry get(MemorySegment key) { + return storage.get(key); + } + + @Override + public void upsert(Entry entry) { + storage.put(entry.key(), entry); + } +} diff --git a/src/main/java/ru/vk/itmo/viktorkorotkikh/MemorySegmentComparator.java b/src/main/java/ru/vk/itmo/viktorkorotkikh/MemorySegmentComparator.java new file mode 100644 index 000000000..c531421d0 --- /dev/null +++ b/src/main/java/ru/vk/itmo/viktorkorotkikh/MemorySegmentComparator.java @@ -0,0 +1,26 @@ +package ru.vk.itmo.viktorkorotkikh; + +import java.lang.foreign.MemorySegment; +import java.lang.foreign.ValueLayout; +import java.util.Comparator; + +public class MemorySegmentComparator implements Comparator { + @Override + public int compare(MemorySegment o1, MemorySegment o2) { + // range of 0 (inclusive) up to the size (in bytes) of the smaller memory segment (exclusive). + long mismatch = o1.mismatch(o2); + if (mismatch == -1) { // equals + return 0; + } + + if (mismatch == o1.byteSize()) { // o1 is smaller memory segment + return -1; + } + + if (mismatch == o2.byteSize()) { // o2 is smaller memory segment + return 1; + } + + return o1.get(ValueLayout.JAVA_BYTE, mismatch) - o2.get(ValueLayout.JAVA_BYTE, mismatch); + } +} From d78c89677a72d571fc669b45aed8af5900701deb Mon Sep 17 00:00:00 2001 From: Vadim Ershov <53083986+vadim01er@users.noreply.github.com> Date: Wed, 4 Oct 2023 10:12:32 +0300 Subject: [PATCH 25/45] =?UTF-8?q?=D0=95=D1=80=D1=88=D0=BE=D0=B2=20=D0=92?= =?UTF-8?q?=D0=B0=D0=B4=D0=B8=D0=BC,=20=D0=9C=D0=B0=D0=B3=D0=B8=D1=81?= =?UTF-8?q?=D1=82=D1=80=D0=B0=D1=82=D1=83=D1=80=D0=B0=20=D0=98=D0=A2=D0=9C?= =?UTF-8?q?=D0=9E=20"=D0=A0=D0=B0=D1=81=D0=BF=D1=80=D0=B5=D0=B4=D0=B5?= =?UTF-8?q?=D0=BB=D0=B5=D0=BD=D0=BD=D1=8B=D0=B5=20=D0=B2=D0=B5=D0=B1-?= =?UTF-8?q?=D1=81=D0=B5=D1=80=D0=B2=D0=B8=D1=81=D1=8B",=20=D0=B7=D0=B0?= =?UTF-8?q?=D0=B4=D0=B0=D0=BD=D0=B8=D0=B5=201=20=20(#10)?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Co-authored-by: Vadim Tsesko --- .../vk/itmo/ershovvadim/InMemoryDaoImpl.java | 52 +++++++++++++++++++ .../vk/itmo/test/ershovvadim/FactoryImpl.java | 37 +++++++++++++ 2 files changed, 89 insertions(+) create mode 100644 src/main/java/ru/vk/itmo/ershovvadim/InMemoryDaoImpl.java create mode 100644 src/main/java/ru/vk/itmo/test/ershovvadim/FactoryImpl.java diff --git a/src/main/java/ru/vk/itmo/ershovvadim/InMemoryDaoImpl.java b/src/main/java/ru/vk/itmo/ershovvadim/InMemoryDaoImpl.java new file mode 100644 index 000000000..7f719464a --- /dev/null +++ b/src/main/java/ru/vk/itmo/ershovvadim/InMemoryDaoImpl.java @@ -0,0 +1,52 @@ +package ru.vk.itmo.ershovvadim; + +import ru.vk.itmo.Dao; +import ru.vk.itmo.Entry; + +import java.lang.foreign.MemorySegment; +import java.util.Iterator; +import java.util.concurrent.ConcurrentSkipListMap; + +import static java.lang.foreign.ValueLayout.JAVA_BYTE; + +public class InMemoryDaoImpl implements Dao> { + private final ConcurrentSkipListMap> db = + new ConcurrentSkipListMap<>(InMemoryDaoImpl::comparator); + + private static int comparator(MemorySegment segment1, MemorySegment segment2) { + long mismatchOffset = segment1.mismatch(segment2); + if (mismatchOffset == -1) { + return 0; + } else if (mismatchOffset == segment1.byteSize()) { + return -1; + } else if (mismatchOffset == segment2.byteSize()) { + return 1; + } + + var offsetByte1 = segment1.get(JAVA_BYTE, mismatchOffset); + var offsetByte2 = segment2.get(JAVA_BYTE, mismatchOffset); + return Byte.compare(offsetByte1, offsetByte2); + } + + @Override + public Entry get(MemorySegment key) { + return db.get(key); + } + + @Override + public Iterator> get(MemorySegment from, MemorySegment to) { + if (from == null && to == null) { + return db.values().iterator(); + } else if (to == null) { + return db.tailMap(from).values().iterator(); + } else if (from == null) { + return db.headMap(to).values().iterator(); + } + return db.subMap(from, to).values().iterator(); + } + + @Override + public void upsert(Entry entry) { + db.put(entry.key(), entry); + } +} diff --git a/src/main/java/ru/vk/itmo/test/ershovvadim/FactoryImpl.java b/src/main/java/ru/vk/itmo/test/ershovvadim/FactoryImpl.java new file mode 100644 index 000000000..de31f2fad --- /dev/null +++ b/src/main/java/ru/vk/itmo/test/ershovvadim/FactoryImpl.java @@ -0,0 +1,37 @@ +package ru.vk.itmo.test.ershovvadim; + +import ru.vk.itmo.Dao; +import ru.vk.itmo.Entry; +import ru.vk.itmo.ershovvadim.InMemoryDaoImpl; +import ru.vk.itmo.test.DaoFactory; + +import java.lang.foreign.MemorySegment; +import java.lang.foreign.ValueLayout; +import java.nio.charset.StandardCharsets; + +@DaoFactory +public class FactoryImpl implements DaoFactory.Factory> { + @Override + public Dao> createDao() { + return new InMemoryDaoImpl(); + } + + @Override + public String toString(MemorySegment memorySegment) { + return memorySegment == null + ? null + : new String(memorySegment.toArray(ValueLayout.JAVA_BYTE), StandardCharsets.UTF_8); + } + + @Override + public MemorySegment fromString(String data) { + return data == null + ? null + : MemorySegment.ofArray(data.getBytes(StandardCharsets.UTF_8)); + } + + @Override + public Entry fromBaseEntry(Entry baseEntry) { + return baseEntry; + } +} From 383142d2e6a4f378254367282e461bc3da13a308 Mon Sep 17 00:00:00 2001 From: stormrvge <38988611+stormrvge@users.noreply.github.com> Date: Wed, 4 Oct 2023 10:12:52 +0300 Subject: [PATCH 26/45] =?UTF-8?q?=D0=A1=D0=B2=D0=B8=D1=81=D1=82=D1=83?= =?UTF-8?q?=D1=85=D0=B8=D0=BD=20=D0=90=D0=BD=D0=B4=D1=80=D0=B5=D0=B9,=20?= =?UTF-8?q?=D0=9C=D0=B0=D0=B3=D0=B8=D1=81=D1=82=D1=80=D0=B0=D1=82=D1=83?= =?UTF-8?q?=D1=80=D0=B0=20=D0=98=D0=A2=D0=9C=D0=9E=20"=D0=A0=D0=B0=D1=81?= =?UTF-8?q?=D0=BF=D1=80=D0=B5=D0=B4=D0=B5=D0=BB=D0=B5=D0=BD=D0=BD=D1=8B?= =?UTF-8?q?=D0=B5=20=D0=B2=D0=B5=D0=B1-=D1=81=D0=B5=D1=80=D0=B2=D0=B8?= =?UTF-8?q?=D1=81=D1=8B",=20=D0=B7=D0=B0=D0=B4=D0=B0=D0=BD=D0=B8=D0=B5=201?= =?UTF-8?q?=20(#14)?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Co-authored-by: Andrey Svistukhin Co-authored-by: Vadim Tsesko --- .../vk/itmo/svistukhinandrey/InMemoryDao.java | 46 +++++++++++++++++++ .../MemorySegmentComparator.java | 26 +++++++++++ .../test/svistukhinandrey/DaoFactoryImpl.java | 42 +++++++++++++++++ 3 files changed, 114 insertions(+) create mode 100644 src/main/java/ru/vk/itmo/svistukhinandrey/InMemoryDao.java create mode 100644 src/main/java/ru/vk/itmo/svistukhinandrey/MemorySegmentComparator.java create mode 100644 src/main/java/ru/vk/itmo/test/svistukhinandrey/DaoFactoryImpl.java diff --git a/src/main/java/ru/vk/itmo/svistukhinandrey/InMemoryDao.java b/src/main/java/ru/vk/itmo/svistukhinandrey/InMemoryDao.java new file mode 100644 index 000000000..a05f56b40 --- /dev/null +++ b/src/main/java/ru/vk/itmo/svistukhinandrey/InMemoryDao.java @@ -0,0 +1,46 @@ +package ru.vk.itmo.svistukhinandrey; + +import ru.vk.itmo.Dao; +import ru.vk.itmo.Entry; + +import java.lang.foreign.MemorySegment; +import java.util.Iterator; +import java.util.NavigableMap; +import java.util.concurrent.ConcurrentSkipListMap; + +public class InMemoryDao implements Dao> { + + private final NavigableMap> inMemoryStorage; + + public InMemoryDao() { + inMemoryStorage = new ConcurrentSkipListMap<>(new MemorySegmentComparator()); + } + + @Override + public Entry get(MemorySegment key) { + return inMemoryStorage.get(key); + } + + @Override + public Iterator> get(MemorySegment from, MemorySegment to) { + if (from == null && to == null) { + return inMemoryStorage.sequencedValues().iterator(); + } + + boolean isLastInclusive = false; + MemorySegment localFrom = (from == null) ? inMemoryStorage.firstKey() : from; + MemorySegment localTo = to; + + if (to == null) { + localTo = inMemoryStorage.lastKey(); + isLastInclusive = true; + } + + return inMemoryStorage.subMap(localFrom, true, localTo, isLastInclusive).sequencedValues().iterator(); + } + + @Override + public synchronized void upsert(Entry entry) { + inMemoryStorage.put(entry.key(), entry); + } +} diff --git a/src/main/java/ru/vk/itmo/svistukhinandrey/MemorySegmentComparator.java b/src/main/java/ru/vk/itmo/svistukhinandrey/MemorySegmentComparator.java new file mode 100644 index 000000000..b62722327 --- /dev/null +++ b/src/main/java/ru/vk/itmo/svistukhinandrey/MemorySegmentComparator.java @@ -0,0 +1,26 @@ +package ru.vk.itmo.svistukhinandrey; + +import java.lang.foreign.MemorySegment; +import java.lang.foreign.ValueLayout; +import java.util.Comparator; + +public class MemorySegmentComparator implements Comparator { + + @Override + public int compare(MemorySegment o1, MemorySegment o2) { + long mismatch = o1.mismatch(o2); + if (mismatch == -1) { + return 0; + } + + if (mismatch == o1.byteSize()) { + return -1; + } + + if (mismatch == o2.byteSize()) { + return 1; + } + + return o1.get(ValueLayout.JAVA_BYTE, mismatch) - o2.get(ValueLayout.JAVA_BYTE, mismatch); + } +} diff --git a/src/main/java/ru/vk/itmo/test/svistukhinandrey/DaoFactoryImpl.java b/src/main/java/ru/vk/itmo/test/svistukhinandrey/DaoFactoryImpl.java new file mode 100644 index 000000000..7409c07ee --- /dev/null +++ b/src/main/java/ru/vk/itmo/test/svistukhinandrey/DaoFactoryImpl.java @@ -0,0 +1,42 @@ +package ru.vk.itmo.test.svistukhinandrey; + +import ru.vk.itmo.Dao; +import ru.vk.itmo.Entry; +import ru.vk.itmo.svistukhinandrey.InMemoryDao; +import ru.vk.itmo.test.DaoFactory; + +import java.lang.foreign.MemorySegment; +import java.lang.foreign.ValueLayout; +import java.nio.charset.StandardCharsets; + +@DaoFactory +public class DaoFactoryImpl implements DaoFactory.Factory> { + + @Override + public String toString(MemorySegment memorySegment) { + if (memorySegment == null) { + return null; + } + + return new String(memorySegment.toArray(ValueLayout.JAVA_BYTE), StandardCharsets.UTF_8); + } + + @Override + public MemorySegment fromString(String data) { + if (data == null) { + return null; + } + + return MemorySegment.ofArray(data.getBytes(StandardCharsets.UTF_8)); + } + + @Override + public Entry fromBaseEntry(Entry baseEntry) { + return baseEntry; + } + + @Override + public Dao> createDao() { + return new InMemoryDao(); + } +} From 28a252fba7432650c9e82e1c0838d36a5f0f0bff Mon Sep 17 00:00:00 2001 From: Egor Savkovskiy Date: Wed, 4 Oct 2023 10:13:10 +0300 Subject: [PATCH 27/45] Savkovskiy Egor, web scale systems, lab-1 (#15) Co-authored-by: savkovkii --- .../vk/itmo/savkovskiyegor/InMemoryDao.java | 41 +++++++++++++++++++ .../MemorySegmentComparator.java | 29 +++++++++++++ .../savkovskiyegor/InMemoryFactoryImpl.java | 41 +++++++++++++++++++ 3 files changed, 111 insertions(+) create mode 100644 src/main/java/ru/vk/itmo/savkovskiyegor/InMemoryDao.java create mode 100644 src/main/java/ru/vk/itmo/savkovskiyegor/MemorySegmentComparator.java create mode 100644 src/main/java/ru/vk/itmo/test/savkovskiyegor/InMemoryFactoryImpl.java diff --git a/src/main/java/ru/vk/itmo/savkovskiyegor/InMemoryDao.java b/src/main/java/ru/vk/itmo/savkovskiyegor/InMemoryDao.java new file mode 100644 index 000000000..3eefaafd4 --- /dev/null +++ b/src/main/java/ru/vk/itmo/savkovskiyegor/InMemoryDao.java @@ -0,0 +1,41 @@ +package ru.vk.itmo.savkovskiyegor; + +import ru.vk.itmo.Dao; +import ru.vk.itmo.Entry; + +import java.lang.foreign.MemorySegment; +import java.util.Iterator; +import java.util.concurrent.ConcurrentNavigableMap; +import java.util.concurrent.ConcurrentSkipListMap; + +public class InMemoryDao implements Dao> { + private final ConcurrentNavigableMap> memoryTable = + new ConcurrentSkipListMap<>(new MemorySegmentComparator()); + + @Override + public Iterator> get(MemorySegment from, MemorySegment to) { + if (from == null && to == null) { + return memoryTable.values().iterator(); + } + + if (to == null) { + return memoryTable.tailMap(from).values().iterator(); + } + + if (from == null) { + return memoryTable.headMap(to).values().iterator(); + } + + return memoryTable.subMap(from, to).values().iterator(); + } + + @Override + public Entry get(MemorySegment key) { + return memoryTable.get(key); + } + + @Override + public void upsert(Entry entry) { + memoryTable.put(entry.key(), entry); + } +} diff --git a/src/main/java/ru/vk/itmo/savkovskiyegor/MemorySegmentComparator.java b/src/main/java/ru/vk/itmo/savkovskiyegor/MemorySegmentComparator.java new file mode 100644 index 000000000..cccbf4c10 --- /dev/null +++ b/src/main/java/ru/vk/itmo/savkovskiyegor/MemorySegmentComparator.java @@ -0,0 +1,29 @@ +package ru.vk.itmo.savkovskiyegor; + +import java.lang.foreign.MemorySegment; +import java.util.Comparator; + +import static java.lang.foreign.ValueLayout.JAVA_BYTE; + +class MemorySegmentComparator implements Comparator { + + @Override + public int compare(MemorySegment s1, MemorySegment s2) { + long mismatch = s1.mismatch(s2); + + // segments are equal + if (mismatch == -1) { + return 0; + } + // first segment is smaller than second + if (mismatch == s1.byteSize()) { + return -1; + } + // second segment is smaller than first + if (mismatch == s2.byteSize()) { + return 1; + } + + return Byte.compare(s1.get(JAVA_BYTE, mismatch), s2.get(JAVA_BYTE, mismatch)); + } +} diff --git a/src/main/java/ru/vk/itmo/test/savkovskiyegor/InMemoryFactoryImpl.java b/src/main/java/ru/vk/itmo/test/savkovskiyegor/InMemoryFactoryImpl.java new file mode 100644 index 000000000..17b3b5abf --- /dev/null +++ b/src/main/java/ru/vk/itmo/test/savkovskiyegor/InMemoryFactoryImpl.java @@ -0,0 +1,41 @@ +package ru.vk.itmo.test.savkovskiyegor; + +import ru.vk.itmo.Dao; +import ru.vk.itmo.Entry; +import ru.vk.itmo.savkovskiyegor.InMemoryDao; +import ru.vk.itmo.test.DaoFactory; + +import java.lang.foreign.MemorySegment; +import java.lang.foreign.ValueLayout; +import java.nio.charset.StandardCharsets; + +@DaoFactory +public class InMemoryFactoryImpl implements DaoFactory.Factory> { + + @Override + public Dao> createDao() { + return new InMemoryDao(); + } + + @Override + public String toString(MemorySegment memorySegment) { + if (memorySegment == null) { + return null; + } + return new String(memorySegment.toArray(ValueLayout.JAVA_BYTE), StandardCharsets.UTF_8); + } + + @Override + public MemorySegment fromString(String data) { + if (data == null) { + return null; + } + byte[] bytes = data.getBytes(StandardCharsets.UTF_8); + return MemorySegment.ofArray(bytes); + } + + @Override + public Entry fromBaseEntry(Entry baseEntry) { + return baseEntry; + } +} From 2fbbfbde97574c62441dfe8ffc3bd29c1b9607b8 Mon Sep 17 00:00:00 2001 From: Victor Ekhmenin <38165631+wasderedsaw@users.noreply.github.com> Date: Wed, 4 Oct 2023 10:15:19 +0300 Subject: [PATCH 28/45] =?UTF-8?q?=D0=95=D1=85=D0=BC=D0=B5=D0=BD=D0=B8?= =?UTF-8?q?=D0=BD=20=D0=92=D0=B8=D0=BA=D1=82=D0=BE=D1=80,=20=D0=9C=D0=B0?= =?UTF-8?q?=D0=B3=D0=B8=D1=81=D1=82=D1=80=D0=B0=D1=82=D1=83=D1=80=D0=B0=20?= =?UTF-8?q?=D0=98=D0=A2=D0=9C=D0=9E=20"=D0=A0=D0=B0=D1=81=D0=BF=D1=80?= =?UTF-8?q?=D0=B5=D0=B4=D0=B5=D0=BB=D0=B5=D0=BD=D0=BD=D1=8B=D0=B5=20=D0=B2?= =?UTF-8?q?=D0=B5=D0=B1-=D1=81=D0=B5=D1=80=D0=B2=D0=B8=D1=81=D1=8B",=20?= =?UTF-8?q?=D0=B7=D0=B0=D0=B4=D0=B0=D0=BD=D0=B8=D0=B5=201=20(#11)?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Co-authored-by: Vadim Tsesko --- .../test/ekhmeninvictor/DaoFactoryImpl.java | 34 +++++++++++++++ .../itmo/test/ekhmeninvictor/InMemoryDao.java | 41 +++++++++++++++++++ 2 files changed, 75 insertions(+) create mode 100644 src/main/java/ru/vk/itmo/test/ekhmeninvictor/DaoFactoryImpl.java create mode 100644 src/main/java/ru/vk/itmo/test/ekhmeninvictor/InMemoryDao.java diff --git a/src/main/java/ru/vk/itmo/test/ekhmeninvictor/DaoFactoryImpl.java b/src/main/java/ru/vk/itmo/test/ekhmeninvictor/DaoFactoryImpl.java new file mode 100644 index 000000000..7028fada4 --- /dev/null +++ b/src/main/java/ru/vk/itmo/test/ekhmeninvictor/DaoFactoryImpl.java @@ -0,0 +1,34 @@ +package ru.vk.itmo.test.ekhmeninvictor; + +import ru.vk.itmo.Dao; +import ru.vk.itmo.Entry; +import ru.vk.itmo.test.DaoFactory; + +import java.lang.foreign.MemorySegment; +import java.nio.charset.StandardCharsets; + +@DaoFactory +public class DaoFactoryImpl implements DaoFactory.Factory> { + @Override + public Dao> createDao() { + return new InMemoryDao(); + } + + @Override + public String toString(MemorySegment memorySegment) { + return new String(memorySegment.asByteBuffer().array(), StandardCharsets.UTF_8); + } + + @Override + public MemorySegment fromString(String data) { + if (data == null) { + return null; + } + return MemorySegment.ofArray(data.getBytes(StandardCharsets.UTF_8)); + } + + @Override + public Entry fromBaseEntry(Entry baseEntry) { + return baseEntry; + } +} diff --git a/src/main/java/ru/vk/itmo/test/ekhmeninvictor/InMemoryDao.java b/src/main/java/ru/vk/itmo/test/ekhmeninvictor/InMemoryDao.java new file mode 100644 index 000000000..fb5122a24 --- /dev/null +++ b/src/main/java/ru/vk/itmo/test/ekhmeninvictor/InMemoryDao.java @@ -0,0 +1,41 @@ +package ru.vk.itmo.test.ekhmeninvictor; + +import ru.vk.itmo.Dao; +import ru.vk.itmo.Entry; +import ru.vk.itmo.test.DaoFactory; + +import java.lang.foreign.MemorySegment; +import java.util.Collections; +import java.util.Comparator; +import java.util.Iterator; +import java.util.concurrent.ConcurrentSkipListMap; + +public class InMemoryDao implements Dao> { + + private final DaoFactory.Factory> myFactory = new DaoFactoryImpl(); + + private final ConcurrentSkipListMap> cache = + new ConcurrentSkipListMap<>(Comparator.comparing(myFactory::toString)); + + @Override + public Entry get(MemorySegment key) { + return cache.get(key); + } + + @Override + public Iterator> get(MemorySegment from, MemorySegment to) { + + if (cache.isEmpty()) { + return Collections.emptyIterator(); + } + return cache.subMap( + from == null ? cache.firstKey() : from, true, + to == null ? cache.lastKey() : to, to == null + ).values().iterator(); + } + + @Override + public void upsert(Entry entry) { + cache.put(entry.key(), entry); + } +} From 7ac3ca2ca2621895603e024703ddcdb5e04baad9 Mon Sep 17 00:00:00 2001 From: Vlad Korzh <61206345+sold666@users.noreply.github.com> Date: Wed, 4 Oct 2023 13:20:59 +0300 Subject: [PATCH 29/45] =?UTF-8?q?=D0=9A=D0=BE=D1=80=D0=B6=20=D0=92=D0=BB?= =?UTF-8?q?=D0=B0=D0=B4=D0=B8=D1=81=D0=BB=D0=B0=D0=B2,=20=D0=9F=D0=BE?= =?UTF-8?q?=D0=BB=D0=B8=D1=82=D0=B5=D1=85,=20=D0=B7=D0=B0=D0=B4=D0=B0?= =?UTF-8?q?=D0=BD=D0=B8=D0=B5=201=20(#41)?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- .../vk/itmo/korzhvladislav/InMemoryDao.java | 37 +++++++++++++++++++ .../MemorySegmentComparator.java | 21 +++++++++++ .../korzhvladislav/InMemoryDaoFactory.java | 34 +++++++++++++++++ 3 files changed, 92 insertions(+) create mode 100644 src/main/java/ru/vk/itmo/korzhvladislav/InMemoryDao.java create mode 100644 src/main/java/ru/vk/itmo/korzhvladislav/MemorySegmentComparator.java create mode 100644 src/main/java/ru/vk/itmo/test/korzhvladislav/InMemoryDaoFactory.java diff --git a/src/main/java/ru/vk/itmo/korzhvladislav/InMemoryDao.java b/src/main/java/ru/vk/itmo/korzhvladislav/InMemoryDao.java new file mode 100644 index 000000000..4baf0931e --- /dev/null +++ b/src/main/java/ru/vk/itmo/korzhvladislav/InMemoryDao.java @@ -0,0 +1,37 @@ +package ru.vk.itmo.korzhvladislav; + +import ru.vk.itmo.Dao; +import ru.vk.itmo.Entry; + +import java.lang.foreign.MemorySegment; +import java.util.Iterator; +import java.util.concurrent.ConcurrentNavigableMap; +import java.util.concurrent.ConcurrentSkipListMap; + +public class InMemoryDao implements Dao> { + private final ConcurrentNavigableMap> dataStore = + new ConcurrentSkipListMap<>(new MemorySegmentComparator()); + + @Override + public Entry get(MemorySegment key) { + return dataStore.get(key); + } + + @Override + public Iterator> get(MemorySegment from, MemorySegment to) { + if (from == null && to == null) { + return dataStore.values().iterator(); + } else if (from == null) { + return dataStore.headMap(to, false).values().iterator(); + } else if (to == null) { + return dataStore.tailMap(from, true).values().iterator(); + } else { + return dataStore.subMap(from, to).values().iterator(); + } + } + + @Override + public void upsert(Entry entry) { + dataStore.put(entry.key(), entry); + } +} diff --git a/src/main/java/ru/vk/itmo/korzhvladislav/MemorySegmentComparator.java b/src/main/java/ru/vk/itmo/korzhvladislav/MemorySegmentComparator.java new file mode 100644 index 000000000..e03c46bd1 --- /dev/null +++ b/src/main/java/ru/vk/itmo/korzhvladislav/MemorySegmentComparator.java @@ -0,0 +1,21 @@ +package ru.vk.itmo.korzhvladislav; + +import java.lang.foreign.MemorySegment; +import java.lang.foreign.ValueLayout; +import java.util.Comparator; + +public class MemorySegmentComparator implements Comparator { + @Override + public int compare(MemorySegment segFirst, MemorySegment segSecond) { + long offSetMismatch = segFirst.mismatch(segSecond); + if (offSetMismatch == -1) { + return 0; + } else if (offSetMismatch == segFirst.byteSize()) { + return -1; + } else if (offSetMismatch == segSecond.byteSize()) { + return 1; + } + return Byte.compare(segFirst.getAtIndex(ValueLayout.JAVA_BYTE, offSetMismatch), + segSecond.getAtIndex(ValueLayout.JAVA_BYTE, offSetMismatch)); + } +} diff --git a/src/main/java/ru/vk/itmo/test/korzhvladislav/InMemoryDaoFactory.java b/src/main/java/ru/vk/itmo/test/korzhvladislav/InMemoryDaoFactory.java new file mode 100644 index 000000000..fbe86737a --- /dev/null +++ b/src/main/java/ru/vk/itmo/test/korzhvladislav/InMemoryDaoFactory.java @@ -0,0 +1,34 @@ +package ru.vk.itmo.test.korzhvladislav; + +import ru.vk.itmo.Dao; +import ru.vk.itmo.Entry; +import ru.vk.itmo.korzhvladislav.InMemoryDao; +import ru.vk.itmo.test.DaoFactory; + +import java.lang.foreign.MemorySegment; +import java.lang.foreign.ValueLayout; + +import static java.nio.charset.StandardCharsets.UTF_8; + +@DaoFactory +public class InMemoryDaoFactory implements DaoFactory.Factory> { + @Override + public Dao> createDao() { + return new InMemoryDao(); + } + + @Override + public String toString(MemorySegment memorySegment) { + return memorySegment == null ? null : new String(memorySegment.toArray(ValueLayout.JAVA_BYTE), UTF_8); + } + + @Override + public MemorySegment fromString(String data) { + return data == null ? null : MemorySegment.ofArray(data.getBytes(UTF_8)); + } + + @Override + public Entry fromBaseEntry(Entry baseEntry) { + return baseEntry; + } +} From 553b14043778d4c35b7275c0d76bc50f764de721 Mon Sep 17 00:00:00 2001 From: Ekaterina Zelenkina <58700289+katemewow@users.noreply.github.com> Date: Wed, 4 Oct 2023 18:45:57 +0300 Subject: [PATCH 30/45] =?UTF-8?q?HW1,=20=D0=97=D0=B5=D0=BB=D0=B5=D0=BD?= =?UTF-8?q?=D0=BA=D0=B8=D0=BD=D0=B0=20=D0=95=D0=BA=D0=B0=D1=82=D0=B5=D1=80?= =?UTF-8?q?=D0=B8=D0=BD=D0=B0,=20=D0=9F=D0=BE=D0=BB=D0=B8=D1=82=D0=B5?= =?UTF-8?q?=D1=85=20(#71)?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- .../zelenkinaekaterina/CustomFactory.java | 34 ++++++++++ .../test/zelenkinaekaterina/InMemoryDao.java | 62 +++++++++++++++++++ 2 files changed, 96 insertions(+) create mode 100644 src/main/java/ru/vk/itmo/test/zelenkinaekaterina/CustomFactory.java create mode 100644 src/main/java/ru/vk/itmo/test/zelenkinaekaterina/InMemoryDao.java diff --git a/src/main/java/ru/vk/itmo/test/zelenkinaekaterina/CustomFactory.java b/src/main/java/ru/vk/itmo/test/zelenkinaekaterina/CustomFactory.java new file mode 100644 index 000000000..c95f4b304 --- /dev/null +++ b/src/main/java/ru/vk/itmo/test/zelenkinaekaterina/CustomFactory.java @@ -0,0 +1,34 @@ +package ru.vk.itmo.test.zelenkinaekaterina; + +import ru.vk.itmo.Dao; +import ru.vk.itmo.Entry; +import ru.vk.itmo.test.DaoFactory; + +import java.lang.foreign.MemorySegment; +import java.lang.foreign.ValueLayout; +import java.nio.charset.StandardCharsets; + +@DaoFactory +public class CustomFactory implements DaoFactory.Factory> { + + @Override + public Dao> createDao() { + return new InMemoryDao(); + } + + @Override + public String toString(MemorySegment memorySegment) { + return memorySegment == null ? null + : new String(memorySegment.toArray(ValueLayout.JAVA_BYTE), StandardCharsets.UTF_8); + } + + @Override + public MemorySegment fromString(String data) { + return data == null ? null : MemorySegment.ofArray(data.getBytes(StandardCharsets.UTF_8)); + } + + @Override + public Entry fromBaseEntry(Entry baseEntry) { + return baseEntry; + } +} diff --git a/src/main/java/ru/vk/itmo/test/zelenkinaekaterina/InMemoryDao.java b/src/main/java/ru/vk/itmo/test/zelenkinaekaterina/InMemoryDao.java new file mode 100644 index 000000000..15a5e32c3 --- /dev/null +++ b/src/main/java/ru/vk/itmo/test/zelenkinaekaterina/InMemoryDao.java @@ -0,0 +1,62 @@ +package ru.vk.itmo.test.zelenkinaekaterina; + +import ru.vk.itmo.Dao; +import ru.vk.itmo.Entry; + +import java.lang.foreign.MemorySegment; +import java.lang.foreign.ValueLayout; +import java.util.Comparator; +import java.util.Iterator; +import java.util.SortedMap; +import java.util.concurrent.ConcurrentSkipListMap; + +public class InMemoryDao implements Dao> { + private final SortedMap> storage; + + public InMemoryDao() { + storage = new ConcurrentSkipListMap<>(new MemorySegmentComparator()); + } + + @Override + public Entry get(MemorySegment key) { + return storage.get(key); + } + + @Override + public Iterator> get(MemorySegment from, MemorySegment to) { + SortedMap> subStorage; + if (from == null && to == null) { + subStorage = storage; + } else if (from == null) { + subStorage = storage.headMap(to); + } else if (to == null) { + subStorage = storage.tailMap(from); + } else { + subStorage = storage.subMap(from, to); + } + return subStorage.values().iterator(); + } + + @Override + public void upsert(Entry entry) { + storage.put(entry.key(), entry); + } + + private static class MemorySegmentComparator implements Comparator { + @Override + public int compare(MemorySegment ms1, MemorySegment ms2) { + long offset = ms1.mismatch(ms2); + if (offset == -1) { + return 0; + } + if (offset == ms1.byteSize()) { + return -1; + } + if (offset == ms2.byteSize()) { + return 1; + } + return Byte.compare(ms1.get(ValueLayout.JAVA_BYTE, offset), ms2.get(ValueLayout.JAVA_BYTE, offset)); + } + } + +} From 9e0f45549a89c4a6267d1455063c2e6d4dffc531 Mon Sep 17 00:00:00 2001 From: Vadim Kholoshnia Date: Wed, 4 Oct 2023 21:38:58 +0300 Subject: [PATCH 31/45] =?UTF-8?q?=D0=A5=D0=BE=D0=BB=D0=BE=D1=88=D0=BD?= =?UTF-8?q?=D1=8F=20=D0=92=D0=B0=D0=B4=D0=B8=D0=BC,=20=D0=9C=D0=B0=D0=B3?= =?UTF-8?q?=D0=B8=D1=81=D1=82=D1=80=D0=B0=D1=82=D1=83=D1=80=D0=B0=20=D0=98?= =?UTF-8?q?=D0=A2=D0=9C=D0=9E=20"=D0=A0=D0=B0=D1=81=D0=BF=D1=80=D0=B5?= =?UTF-8?q?=D0=B4=D0=B5=D0=BB=D0=B5=D0=BD=D0=BD=D1=8B=D0=B5=20=D0=B2=D0=B5?= =?UTF-8?q?=D0=B1-=D1=81=D0=B5=D1=80=D0=B2=D0=B8=D1=81=D1=8B",=20=D0=B7?= =?UTF-8?q?=D0=B0=D0=B4=D0=B0=D0=BD=D0=B8=D0=B5=201=20(#16)?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Co-authored-by: Vadim Tsesko Co-authored-by: Artyom Drozdov --- .../kholoshniavadim/inmemory/InMemoryDao.java | 42 +++++++++++++++++++ .../inmemory/InMemoryFactory.java | 31 ++++++++++++++ .../utils/MemorySegmentComparator.java | 18 ++++++++ .../utils/StringConverterUtil.java | 33 +++++++++++++++ 4 files changed, 124 insertions(+) create mode 100644 src/main/java/ru/vk/itmo/test/kholoshniavadim/inmemory/InMemoryDao.java create mode 100644 src/main/java/ru/vk/itmo/test/kholoshniavadim/inmemory/InMemoryFactory.java create mode 100644 src/main/java/ru/vk/itmo/test/kholoshniavadim/utils/MemorySegmentComparator.java create mode 100644 src/main/java/ru/vk/itmo/test/kholoshniavadim/utils/StringConverterUtil.java diff --git a/src/main/java/ru/vk/itmo/test/kholoshniavadim/inmemory/InMemoryDao.java b/src/main/java/ru/vk/itmo/test/kholoshniavadim/inmemory/InMemoryDao.java new file mode 100644 index 000000000..894b15c96 --- /dev/null +++ b/src/main/java/ru/vk/itmo/test/kholoshniavadim/inmemory/InMemoryDao.java @@ -0,0 +1,42 @@ +package ru.vk.itmo.test.kholoshniavadim.inmemory; + +import ru.vk.itmo.Dao; +import ru.vk.itmo.Entry; +import ru.vk.itmo.test.kholoshniavadim.utils.MemorySegmentComparator; + +import java.lang.foreign.MemorySegment; +import java.util.Iterator; +import java.util.NavigableMap; +import java.util.concurrent.ConcurrentSkipListMap; + +public final class InMemoryDao implements Dao> { + private final NavigableMap> data = + new ConcurrentSkipListMap<>(new MemorySegmentComparator()); + + @Override + public Iterator> get(MemorySegment from, MemorySegment to) { + if (from == null && to == null) { + return data.values().iterator(); + } + + if (from == null) { + return data.headMap(to).values().iterator(); + } + + if (to == null) { + return data.tailMap(from).values().iterator(); + } + + return data.subMap(from, to).values().iterator(); + } + + @Override + public Entry get(MemorySegment key) { + return data.get(key); + } + + @Override + public void upsert(Entry entry) { + data.put(entry.key(), entry); + } +} diff --git a/src/main/java/ru/vk/itmo/test/kholoshniavadim/inmemory/InMemoryFactory.java b/src/main/java/ru/vk/itmo/test/kholoshniavadim/inmemory/InMemoryFactory.java new file mode 100644 index 000000000..80726729a --- /dev/null +++ b/src/main/java/ru/vk/itmo/test/kholoshniavadim/inmemory/InMemoryFactory.java @@ -0,0 +1,31 @@ +package ru.vk.itmo.test.kholoshniavadim.inmemory; + +import ru.vk.itmo.Dao; +import ru.vk.itmo.Entry; +import ru.vk.itmo.test.DaoFactory; +import ru.vk.itmo.test.kholoshniavadim.utils.StringConverterUtil; + +import java.lang.foreign.MemorySegment; + +@DaoFactory +public final class InMemoryFactory implements DaoFactory.Factory> { + @Override + public Dao> createDao() { + return new InMemoryDao(); + } + + @Override + public String toString(MemorySegment memorySegment) { + return StringConverterUtil.toString(memorySegment); + } + + @Override + public MemorySegment fromString(String data) { + return StringConverterUtil.fromString(data); + } + + @Override + public Entry fromBaseEntry(Entry baseEntry) { + return baseEntry; + } +} diff --git a/src/main/java/ru/vk/itmo/test/kholoshniavadim/utils/MemorySegmentComparator.java b/src/main/java/ru/vk/itmo/test/kholoshniavadim/utils/MemorySegmentComparator.java new file mode 100644 index 000000000..14d8bc079 --- /dev/null +++ b/src/main/java/ru/vk/itmo/test/kholoshniavadim/utils/MemorySegmentComparator.java @@ -0,0 +1,18 @@ +package ru.vk.itmo.test.kholoshniavadim.utils; + +import java.lang.foreign.MemorySegment; +import java.util.Comparator; + +public final class MemorySegmentComparator implements Comparator { + @Override + public int compare(MemorySegment memorySegment1, MemorySegment memorySegment2) { + final String string1 = StringConverterUtil.toString(memorySegment1); + final String string2 = StringConverterUtil.toString(memorySegment2); + + if (string1 == null && string2 == null) return 0; + if (string1 == null) return -1; + if (string2 == null) return 1; + + return string1.compareTo(string2); + } +} diff --git a/src/main/java/ru/vk/itmo/test/kholoshniavadim/utils/StringConverterUtil.java b/src/main/java/ru/vk/itmo/test/kholoshniavadim/utils/StringConverterUtil.java new file mode 100644 index 000000000..5e4de3836 --- /dev/null +++ b/src/main/java/ru/vk/itmo/test/kholoshniavadim/utils/StringConverterUtil.java @@ -0,0 +1,33 @@ +package ru.vk.itmo.test.kholoshniavadim.utils; + +import java.lang.foreign.MemorySegment; +import java.nio.ByteBuffer; +import java.nio.charset.Charset; +import java.nio.charset.StandardCharsets; + +public final class StringConverterUtil { + private static final Charset charset = StandardCharsets.UTF_8; + + private StringConverterUtil() { + } + + public static String toString(MemorySegment memorySegment) { + if (memorySegment == null) { + return null; + } + + final ByteBuffer byteBuffer = memorySegment.asByteBuffer(); + final byte[] bytes = new byte[byteBuffer.remaining()]; + byteBuffer.get(bytes); + return new String(bytes, charset); + } + + public static MemorySegment fromString(String string) { + if (string == null) { + return null; + } + + final byte[] bytes = string.getBytes(charset); + return MemorySegment.ofArray(bytes); + } +} From e1d12c6b1f080e2673aad73048650897fe61f4ad Mon Sep 17 00:00:00 2001 From: solosenya <109814487+solosenya@users.noreply.github.com> Date: Wed, 4 Oct 2023 21:50:15 +0300 Subject: [PATCH 32/45] =?UTF-8?q?=D0=A1=D0=BE=D0=BB=D0=BE=D0=BD=D0=B5?= =?UTF-8?q?=D1=86=20=D0=90=D1=80=D1=81=D0=B5=D0=BD=D0=B8=D0=B9=20=D0=98?= =?UTF-8?q?=D0=A2=D0=9C=D0=9E=20=D1=80=D0=B0=D1=81=D0=BF=D1=80=D0=B5=D0=B4?= =?UTF-8?q?=D0=B5=D0=BB=D0=B5=D0=BD=D0=BD=D1=8B=D0=B5=20=D0=B2=D0=B5=D0=B1?= =?UTF-8?q?=20=D1=81=D0=B5=D1=80=D0=B2=D0=B8=D1=81=D1=8B=20(#19)?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Co-authored-by: Arseniy Solonets Co-authored-by: Vadim Tsesko Co-authored-by: Artyom Drozdov --- .../vk/itmo/solonetsarseniy/InMemoryDao.java | 55 +++++++++++++++++++ .../exception/DaoException.java | 13 +++++ .../exception/DaoExceptions.java | 17 ++++++ .../helpers/DatabaseBuilder.java | 14 +++++ .../helpers/MemorySegmentComparator.java | 26 +++++++++ .../ByteBufferMemorySegmentTransformer.java | 16 ++++++ .../StringByteBufferTransformer.java | 31 +++++++++++ .../StringMemorySegmentTransformer.java | 24 ++++++++ .../transformer/Transformer.java | 7 +++ .../solonetsarseniy/StringDaoFactory.java | 36 ++++++++++++ 10 files changed, 239 insertions(+) create mode 100644 src/main/java/ru/vk/itmo/solonetsarseniy/InMemoryDao.java create mode 100644 src/main/java/ru/vk/itmo/solonetsarseniy/exception/DaoException.java create mode 100644 src/main/java/ru/vk/itmo/solonetsarseniy/exception/DaoExceptions.java create mode 100644 src/main/java/ru/vk/itmo/solonetsarseniy/helpers/DatabaseBuilder.java create mode 100644 src/main/java/ru/vk/itmo/solonetsarseniy/helpers/MemorySegmentComparator.java create mode 100644 src/main/java/ru/vk/itmo/solonetsarseniy/transformer/ByteBufferMemorySegmentTransformer.java create mode 100644 src/main/java/ru/vk/itmo/solonetsarseniy/transformer/StringByteBufferTransformer.java create mode 100644 src/main/java/ru/vk/itmo/solonetsarseniy/transformer/StringMemorySegmentTransformer.java create mode 100644 src/main/java/ru/vk/itmo/solonetsarseniy/transformer/Transformer.java create mode 100644 src/main/java/ru/vk/itmo/test/solonetsarseniy/StringDaoFactory.java diff --git a/src/main/java/ru/vk/itmo/solonetsarseniy/InMemoryDao.java b/src/main/java/ru/vk/itmo/solonetsarseniy/InMemoryDao.java new file mode 100644 index 000000000..2db21893f --- /dev/null +++ b/src/main/java/ru/vk/itmo/solonetsarseniy/InMemoryDao.java @@ -0,0 +1,55 @@ +package ru.vk.itmo.solonetsarseniy; + +import ru.vk.itmo.Dao; +import ru.vk.itmo.Entry; +import ru.vk.itmo.solonetsarseniy.exception.DaoException; +import ru.vk.itmo.solonetsarseniy.exception.DaoExceptions; +import ru.vk.itmo.solonetsarseniy.helpers.DatabaseBuilder; + +import java.lang.foreign.MemorySegment; +import java.util.Iterator; +import java.util.concurrent.ConcurrentSkipListMap; + +public class InMemoryDao implements Dao> { + private static final DatabaseBuilder databaseBuilder = new DatabaseBuilder(); + private final ConcurrentSkipListMap> database = databaseBuilder.build(); + + @Override + public Iterator> get(MemorySegment from, MemorySegment to) { + if (from == null && to == null) { + return database.values() + .iterator(); + } + if (from == null) { + return database.headMap(to) + .values() + .iterator(); + } + if (to == null) { + return database.tailMap(from) + .values() + .iterator(); + } + + return database.subMap(from, to) + .values() + .iterator(); + } + + @Override + public Entry get(MemorySegment key) { + if (key == null) { + DaoException.throwException(DaoExceptions.NULL_KEY_GET); + } + return database.get(key); + } + + @Override + public void upsert(Entry entry) { + MemorySegment key = entry.key(); + if (key == null) { + DaoException.throwException(DaoExceptions.NULL_KEY_PUT); + } + database.put(key, entry); + } +} diff --git a/src/main/java/ru/vk/itmo/solonetsarseniy/exception/DaoException.java b/src/main/java/ru/vk/itmo/solonetsarseniy/exception/DaoException.java new file mode 100644 index 000000000..c8fe87971 --- /dev/null +++ b/src/main/java/ru/vk/itmo/solonetsarseniy/exception/DaoException.java @@ -0,0 +1,13 @@ +package ru.vk.itmo.solonetsarseniy.exception; + +public class DaoException extends RuntimeException { + + public DaoException(String message) { + super(message); + } + + public static void throwException(DaoExceptions exception) { + String errorMessage = exception.getErrorString(); + throw new DaoException(errorMessage); + } +} diff --git a/src/main/java/ru/vk/itmo/solonetsarseniy/exception/DaoExceptions.java b/src/main/java/ru/vk/itmo/solonetsarseniy/exception/DaoExceptions.java new file mode 100644 index 000000000..f9365fbb2 --- /dev/null +++ b/src/main/java/ru/vk/itmo/solonetsarseniy/exception/DaoExceptions.java @@ -0,0 +1,17 @@ +package ru.vk.itmo.solonetsarseniy.exception; + +public enum DaoExceptions { + NULL_KEY_PUT("Got null as Map key. Please do not try to put Entries with null keys."), + NULL_KEY_GET("Got null as Map key. Please do not try to get Entries with null keys. " + + "There is no such thing here!"); + + private final String errorString; + + DaoExceptions(String errorString) { + this.errorString = errorString; + } + + public String getErrorString() { + return errorString; + } +} diff --git a/src/main/java/ru/vk/itmo/solonetsarseniy/helpers/DatabaseBuilder.java b/src/main/java/ru/vk/itmo/solonetsarseniy/helpers/DatabaseBuilder.java new file mode 100644 index 000000000..16b20a7fe --- /dev/null +++ b/src/main/java/ru/vk/itmo/solonetsarseniy/helpers/DatabaseBuilder.java @@ -0,0 +1,14 @@ +package ru.vk.itmo.solonetsarseniy.helpers; + +import ru.vk.itmo.Entry; + +import java.lang.foreign.MemorySegment; +import java.util.concurrent.ConcurrentSkipListMap; + +public class DatabaseBuilder { + private static final MemorySegmentComparator COMPARATOR = new MemorySegmentComparator(); + + public ConcurrentSkipListMap> build() { + return new ConcurrentSkipListMap<>(COMPARATOR); + } +} diff --git a/src/main/java/ru/vk/itmo/solonetsarseniy/helpers/MemorySegmentComparator.java b/src/main/java/ru/vk/itmo/solonetsarseniy/helpers/MemorySegmentComparator.java new file mode 100644 index 000000000..939ae10ea --- /dev/null +++ b/src/main/java/ru/vk/itmo/solonetsarseniy/helpers/MemorySegmentComparator.java @@ -0,0 +1,26 @@ +package ru.vk.itmo.solonetsarseniy.helpers; + +import java.lang.foreign.MemorySegment; +import java.nio.ByteBuffer; +import java.nio.charset.StandardCharsets; +import java.util.Comparator; + +public class MemorySegmentComparator implements Comparator { + @Override + public int compare(MemorySegment first, MemorySegment second) { + ByteBuffer byteBufferFirst = first.asByteBuffer(); + byte[] byteArrayFirst = new byte[byteBufferFirst.remaining()]; + + byteBufferFirst.get(byteArrayFirst); + + String strFirst = new String(byteArrayFirst, StandardCharsets.UTF_8); + ByteBuffer byteBufferSecond = second.asByteBuffer(); + byte[] byteArraySecond = new byte[byteBufferSecond.remaining()]; + + byteBufferSecond.get(byteArraySecond); + + String strSecond = new String(byteArraySecond, StandardCharsets.UTF_8); + + return strFirst.compareTo(strSecond); + } +} diff --git a/src/main/java/ru/vk/itmo/solonetsarseniy/transformer/ByteBufferMemorySegmentTransformer.java b/src/main/java/ru/vk/itmo/solonetsarseniy/transformer/ByteBufferMemorySegmentTransformer.java new file mode 100644 index 000000000..9b27e2551 --- /dev/null +++ b/src/main/java/ru/vk/itmo/solonetsarseniy/transformer/ByteBufferMemorySegmentTransformer.java @@ -0,0 +1,16 @@ +package ru.vk.itmo.solonetsarseniy.transformer; + +import java.lang.foreign.MemorySegment; +import java.nio.ByteBuffer; + +public class ByteBufferMemorySegmentTransformer implements Transformer { + @Override + public ByteBuffer toTarget(MemorySegment source) { + return source.asByteBuffer(); + } + + @Override + public MemorySegment toSource(ByteBuffer target) { + return MemorySegment.ofBuffer(target); + } +} diff --git a/src/main/java/ru/vk/itmo/solonetsarseniy/transformer/StringByteBufferTransformer.java b/src/main/java/ru/vk/itmo/solonetsarseniy/transformer/StringByteBufferTransformer.java new file mode 100644 index 000000000..62a33a5f9 --- /dev/null +++ b/src/main/java/ru/vk/itmo/solonetsarseniy/transformer/StringByteBufferTransformer.java @@ -0,0 +1,31 @@ +package ru.vk.itmo.solonetsarseniy.transformer; + +import java.nio.ByteBuffer; +import java.nio.charset.Charset; +import java.nio.charset.StandardCharsets; + +public class StringByteBufferTransformer implements Transformer { + private static final Charset DEFAULT_CHARSET = StandardCharsets.UTF_8; + private final Charset charset; + + public StringByteBufferTransformer(Charset charset) { + this.charset = charset; + } + + public StringByteBufferTransformer() { + this.charset = DEFAULT_CHARSET; + } + + @Override + public String toTarget(ByteBuffer source) { + byte[] byteArray = new byte[source.remaining()]; + source.get(byteArray); + return new String(byteArray, charset); + } + + @Override + public ByteBuffer toSource(String target) { + byte[] byteArr = target.getBytes(charset); + return ByteBuffer.wrap(byteArr); + } +} diff --git a/src/main/java/ru/vk/itmo/solonetsarseniy/transformer/StringMemorySegmentTransformer.java b/src/main/java/ru/vk/itmo/solonetsarseniy/transformer/StringMemorySegmentTransformer.java new file mode 100644 index 000000000..313d83c3e --- /dev/null +++ b/src/main/java/ru/vk/itmo/solonetsarseniy/transformer/StringMemorySegmentTransformer.java @@ -0,0 +1,24 @@ +package ru.vk.itmo.solonetsarseniy.transformer; + +import java.lang.foreign.MemorySegment; +import java.nio.ByteBuffer; + +public class StringMemorySegmentTransformer implements Transformer { + private final Transformer stringByteBufferTransformer = + new StringByteBufferTransformer(); + + private final Transformer byteBufferMemorySegmentTransformer = + new ByteBufferMemorySegmentTransformer(); + + @Override + public String toTarget(MemorySegment source) { + var byteBuffer = byteBufferMemorySegmentTransformer.toTarget(source); + return stringByteBufferTransformer.toTarget(byteBuffer); + } + + @Override + public MemorySegment toSource(String target) { + var byteBuffer = stringByteBufferTransformer.toSource(target); + return byteBufferMemorySegmentTransformer.toSource(byteBuffer); + } +} diff --git a/src/main/java/ru/vk/itmo/solonetsarseniy/transformer/Transformer.java b/src/main/java/ru/vk/itmo/solonetsarseniy/transformer/Transformer.java new file mode 100644 index 000000000..6acfefac2 --- /dev/null +++ b/src/main/java/ru/vk/itmo/solonetsarseniy/transformer/Transformer.java @@ -0,0 +1,7 @@ +package ru.vk.itmo.solonetsarseniy.transformer; + +public interface Transformer { + T toTarget(S source); + + S toSource(T target); +} diff --git a/src/main/java/ru/vk/itmo/test/solonetsarseniy/StringDaoFactory.java b/src/main/java/ru/vk/itmo/test/solonetsarseniy/StringDaoFactory.java new file mode 100644 index 000000000..f447d889c --- /dev/null +++ b/src/main/java/ru/vk/itmo/test/solonetsarseniy/StringDaoFactory.java @@ -0,0 +1,36 @@ +package ru.vk.itmo.test.solonetsarseniy; + +import ru.vk.itmo.Dao; +import ru.vk.itmo.Entry; +import ru.vk.itmo.solonetsarseniy.InMemoryDao; +import ru.vk.itmo.solonetsarseniy.transformer.StringMemorySegmentTransformer; +import ru.vk.itmo.solonetsarseniy.transformer.Transformer; +import ru.vk.itmo.test.DaoFactory; + +import java.lang.foreign.MemorySegment; + +@DaoFactory +public class StringDaoFactory implements DaoFactory.Factory> { + private final Transformer transformer = new StringMemorySegmentTransformer(); + + @Override + public Dao> createDao() { + return new InMemoryDao(); + } + + @Override + public String toString(MemorySegment memorySegment) { + return transformer.toTarget(memorySegment); + } + + @Override + public MemorySegment fromString(String data) { + if (data == null) return null; + return transformer.toSource(data); + } + + @Override + public Entry fromBaseEntry(Entry baseEntry) { + return baseEntry; + } +} From 7eaa3cd5d0482d979727064eebc140946d53fec0 Mon Sep 17 00:00:00 2001 From: alexBlack01 Date: Wed, 4 Oct 2023 21:55:18 +0300 Subject: [PATCH 33/45] =?UTF-8?q?=D0=A2=D1=83=D0=B7=D0=B8=D0=BA=D0=BE?= =?UTF-8?q?=D0=B2=20=D0=90=D0=BB=D0=B5=D0=BA=D1=81=D0=B0=D0=BD=D0=B4=D1=80?= =?UTF-8?q?,=20=D0=9C=D0=B0=D0=B3=D0=B8=D1=81=D1=82=D1=80=D0=B0=D1=82?= =?UTF-8?q?=D1=83=D1=80=D0=B0=20=D0=98=D0=A2=D0=9C=D0=9E=20"=D0=A0=D0=B0?= =?UTF-8?q?=D1=81=D0=BF=D1=80=D0=B5=D0=B4=D0=B5=D0=BB=D0=B5=D0=BD=D0=BD?= =?UTF-8?q?=D1=8B=D0=B5=20=D0=B2=D0=B5=D0=B1-=D1=81=D0=B5=D1=80=D0=B2?= =?UTF-8?q?=D0=B8=D1=81=D1=8B",=201=20=D0=BB=D0=B0=D0=B1=D0=BE=D1=80=D0=B0?= =?UTF-8?q?=D1=82=D0=BE=D1=80=D0=BD=D0=B0=D1=8F=20(#21)?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Co-authored-by: Vadim Tsesko Co-authored-by: Artyom Drozdov --- .../test/tuzikovalexandr/DaoFactoryImpl.java | 37 ++++++++++++++++ .../itmo/tuzikovalexandr/InMemoryDaoImpl.java | 42 +++++++++++++++++++ .../MemorySegmentComparator.java | 13 ++++++ 3 files changed, 92 insertions(+) create mode 100644 src/main/java/ru/vk/itmo/test/tuzikovalexandr/DaoFactoryImpl.java create mode 100644 src/main/java/ru/vk/itmo/tuzikovalexandr/InMemoryDaoImpl.java create mode 100644 src/main/java/ru/vk/itmo/tuzikovalexandr/MemorySegmentComparator.java diff --git a/src/main/java/ru/vk/itmo/test/tuzikovalexandr/DaoFactoryImpl.java b/src/main/java/ru/vk/itmo/test/tuzikovalexandr/DaoFactoryImpl.java new file mode 100644 index 000000000..b1a101673 --- /dev/null +++ b/src/main/java/ru/vk/itmo/test/tuzikovalexandr/DaoFactoryImpl.java @@ -0,0 +1,37 @@ +package ru.vk.itmo.test.tuzikovalexandr; + +import ru.vk.itmo.Dao; +import ru.vk.itmo.Entry; +import ru.vk.itmo.test.DaoFactory; +import ru.vk.itmo.tuzikovalexandr.InMemoryDaoImpl; + +import java.lang.foreign.MemorySegment; +import java.nio.ByteBuffer; +import java.nio.charset.StandardCharsets; + +@DaoFactory +public class DaoFactoryImpl implements DaoFactory.Factory> { + + @Override + public Dao> createDao() { + return new InMemoryDaoImpl(); + } + + @Override + public String toString(MemorySegment memorySegment) { + + ByteBuffer byteBuffer = memorySegment.asByteBuffer(); + + return byteBuffer == null ? null : new String(byteBuffer.array(), StandardCharsets.UTF_8); + } + + @Override + public MemorySegment fromString(String data) { + return data == null ? null : MemorySegment.ofArray(data.getBytes(StandardCharsets.UTF_8)); + } + + @Override + public Entry fromBaseEntry(Entry baseEntry) { + return baseEntry; + } +} diff --git a/src/main/java/ru/vk/itmo/tuzikovalexandr/InMemoryDaoImpl.java b/src/main/java/ru/vk/itmo/tuzikovalexandr/InMemoryDaoImpl.java new file mode 100644 index 000000000..4a8c9e2a3 --- /dev/null +++ b/src/main/java/ru/vk/itmo/tuzikovalexandr/InMemoryDaoImpl.java @@ -0,0 +1,42 @@ +package ru.vk.itmo.tuzikovalexandr; + +import ru.vk.itmo.Dao; +import ru.vk.itmo.Entry; + +import java.lang.foreign.MemorySegment; +import java.util.Iterator; +import java.util.concurrent.ConcurrentSkipListMap; + +public class InMemoryDaoImpl implements Dao> { + private final ConcurrentSkipListMap> memory = + new ConcurrentSkipListMap<>(new MemorySegmentComparator()); + + @Override + public Iterator> get(MemorySegment from, MemorySegment to) { + + if (from == null && to == null) { + return memory.values().iterator(); + } else if (from == null) { + return memory.headMap(to, false).values().iterator(); + } else if (to == null) { + return memory.subMap(from, true, memory.lastKey(), false).values().iterator(); + } else { + return memory.subMap(from, true, to, false).values().iterator(); + } + } + + @Override + public Entry get(MemorySegment key) { + return memory.get(key); + } + + @Override + public void upsert(Entry entry) { + memory.put(entry.key(), entry); + } + + @Override + public Iterator> all() { + return memory.values().iterator(); + } +} diff --git a/src/main/java/ru/vk/itmo/tuzikovalexandr/MemorySegmentComparator.java b/src/main/java/ru/vk/itmo/tuzikovalexandr/MemorySegmentComparator.java new file mode 100644 index 000000000..7dd4c6b12 --- /dev/null +++ b/src/main/java/ru/vk/itmo/tuzikovalexandr/MemorySegmentComparator.java @@ -0,0 +1,13 @@ +package ru.vk.itmo.tuzikovalexandr; + +import java.lang.foreign.MemorySegment; +import java.util.Arrays; +import java.util.Comparator; + +public class MemorySegmentComparator implements Comparator { + + @Override + public int compare(MemorySegment o1, MemorySegment o2) { + return Arrays.compareUnsigned(o1.asByteBuffer().array(), o2.asByteBuffer().array()); + } +} From 64d6fdecfed2f61776520a36dd03ee1ad88abb99 Mon Sep 17 00:00:00 2001 From: slava_xfce <42910710+GenryEden@users.noreply.github.com> Date: Wed, 4 Oct 2023 22:00:21 +0300 Subject: [PATCH 34/45] Emelyanov Vitaliy, Polytechnic university, part 1 (#12) Co-authored-by: Vadim Tsesko Co-authored-by: vitaliy.emelyanov Co-authored-by: Igor Lopatinskii <9440533@gmail.com> --- .../test/emelyanovvitaliy/InMemoryDao.java | 37 +++++++++++++++++++ .../emelyanovvitaliy/InMemoryDaoFactory.java | 32 ++++++++++++++++ .../MemSegmentComparator.java | 26 +++++++++++++ 3 files changed, 95 insertions(+) create mode 100644 src/main/java/ru/vk/itmo/test/emelyanovvitaliy/InMemoryDao.java create mode 100644 src/main/java/ru/vk/itmo/test/emelyanovvitaliy/InMemoryDaoFactory.java create mode 100644 src/main/java/ru/vk/itmo/test/emelyanovvitaliy/MemSegmentComparator.java diff --git a/src/main/java/ru/vk/itmo/test/emelyanovvitaliy/InMemoryDao.java b/src/main/java/ru/vk/itmo/test/emelyanovvitaliy/InMemoryDao.java new file mode 100644 index 000000000..aa4b9f31b --- /dev/null +++ b/src/main/java/ru/vk/itmo/test/emelyanovvitaliy/InMemoryDao.java @@ -0,0 +1,37 @@ +package ru.vk.itmo.test.emelyanovvitaliy; + +import ru.vk.itmo.Dao; +import ru.vk.itmo.Entry; + +import java.lang.foreign.MemorySegment; +import java.util.Iterator; +import java.util.concurrent.ConcurrentSkipListMap; + +public class InMemoryDao implements Dao> { + private final ConcurrentSkipListMap> mappings = new ConcurrentSkipListMap<>( + new MemSegmentComparator() + ); + + @Override + public Entry get(MemorySegment key) { + return mappings.get(key); + } + + @Override + public Iterator> get(MemorySegment from, MemorySegment to) { + if (from == null && to == null) { + return mappings.values().iterator(); + } else if (from == null) { + return mappings.headMap(to).values().iterator(); + } else if (to == null) { + return mappings.headMap(from).values().iterator(); + } + return mappings.subMap(from, to) + .sequencedValues().iterator(); + } + + @Override + public void upsert(Entry entry) { + mappings.put(entry.key(), entry); + } +} diff --git a/src/main/java/ru/vk/itmo/test/emelyanovvitaliy/InMemoryDaoFactory.java b/src/main/java/ru/vk/itmo/test/emelyanovvitaliy/InMemoryDaoFactory.java new file mode 100644 index 000000000..0b98c52c6 --- /dev/null +++ b/src/main/java/ru/vk/itmo/test/emelyanovvitaliy/InMemoryDaoFactory.java @@ -0,0 +1,32 @@ +package ru.vk.itmo.test.emelyanovvitaliy; + +import ru.vk.itmo.Dao; +import ru.vk.itmo.Entry; +import ru.vk.itmo.test.DaoFactory; + +import java.lang.foreign.MemorySegment; +import java.lang.foreign.ValueLayout; +import java.nio.charset.StandardCharsets; + +@DaoFactory +public class InMemoryDaoFactory implements DaoFactory.Factory> { + @Override + public String toString(MemorySegment memorySegment) { + return new String(memorySegment.toArray(ValueLayout.JAVA_BYTE), StandardCharsets.UTF_8); + } + + @Override + public Dao> createDao() { + return new InMemoryDao(); + } + + @Override + public MemorySegment fromString(String data) { + return data == null ? null : MemorySegment.ofArray(data.getBytes(StandardCharsets.UTF_8)); + } + + @Override + public Entry fromBaseEntry(Entry baseEntry) { + return baseEntry; + } +} diff --git a/src/main/java/ru/vk/itmo/test/emelyanovvitaliy/MemSegmentComparator.java b/src/main/java/ru/vk/itmo/test/emelyanovvitaliy/MemSegmentComparator.java new file mode 100644 index 000000000..43ba96398 --- /dev/null +++ b/src/main/java/ru/vk/itmo/test/emelyanovvitaliy/MemSegmentComparator.java @@ -0,0 +1,26 @@ +package ru.vk.itmo.test.emelyanovvitaliy; + +import java.lang.foreign.MemorySegment; +import java.lang.foreign.ValueLayout; +import java.util.Comparator; + +public class MemSegmentComparator implements Comparator { + + @Override + public int compare(MemorySegment o1, MemorySegment o2) { + long mismatch = o1.mismatch(o2); + if (mismatch == -1) { + return 0; + } + if (mismatch == o1.byteSize()) { + return -1; + } + if (mismatch == o2.byteSize()) { + return 1; + } + return Byte.compare( + o1.getAtIndex(ValueLayout.JAVA_BYTE, mismatch), + o2.getAtIndex(ValueLayout.JAVA_BYTE, mismatch) + ); + } +} From 241ba7abb33cb2f9db091820a3cd6f38a0273821 Mon Sep 17 00:00:00 2001 From: Belonogov Nikolay <93780765+nickkkcc@users.noreply.github.com> Date: Wed, 4 Oct 2023 22:05:35 +0300 Subject: [PATCH 35/45] =?UTF-8?q?HW-1,=20=D0=91=D0=B5=D0=BB=D0=BE=D0=BD?= =?UTF-8?q?=D0=BE=D0=B3=D0=BE=D0=B2=20=D0=9D=D0=B8=D0=BA=D0=BE=D0=BB=D0=B0?= =?UTF-8?q?=D0=B9,=20=D0=A1=D0=9F=D0=91=D0=9F=D0=A3=20(#48)?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- .../belonogovnikolay/InMemoryTreeDao.java | 60 +++++++++++++++++++ .../MemorySegmentComparator.java | 25 ++++++++ .../InMemoryDaoFactoryImpl.java | 58 ++++++++++++++++++ 3 files changed, 143 insertions(+) create mode 100644 src/main/java/ru/vk/itmo/belonogovnikolay/InMemoryTreeDao.java create mode 100644 src/main/java/ru/vk/itmo/belonogovnikolay/MemorySegmentComparator.java create mode 100644 src/main/java/ru/vk/itmo/test/belonogovnikolay/InMemoryDaoFactoryImpl.java diff --git a/src/main/java/ru/vk/itmo/belonogovnikolay/InMemoryTreeDao.java b/src/main/java/ru/vk/itmo/belonogovnikolay/InMemoryTreeDao.java new file mode 100644 index 000000000..ab2b671f0 --- /dev/null +++ b/src/main/java/ru/vk/itmo/belonogovnikolay/InMemoryTreeDao.java @@ -0,0 +1,60 @@ +package ru.vk.itmo.belonogovnikolay; + +import ru.vk.itmo.Dao; +import ru.vk.itmo.Entry; + +import java.lang.foreign.MemorySegment; +import java.util.Iterator; +import java.util.NavigableMap; +import java.util.Objects; +import java.util.concurrent.ConcurrentSkipListMap; + +public final class InMemoryTreeDao implements Dao> { + + private final NavigableMap> arena; + + private InMemoryTreeDao() { + this.arena = new ConcurrentSkipListMap<>(new MemorySegmentComparator()); + } + + public static Dao> newInstance() { + return new InMemoryTreeDao(); + } + + @Override + public Iterator> allFrom(MemorySegment from) { + return this.arena.tailMap(from).values().iterator(); + } + + @Override + public Iterator> allTo(MemorySegment to) { + return this.arena.headMap(to).values().iterator(); + } + + @Override + public Iterator> get(MemorySegment from, MemorySegment to) { + if (Objects.isNull(from) && Objects.isNull(to)) { + return this.arena.values().iterator(); + } else if (Objects.isNull(from)) { + return allTo(to); + } else if (Objects.isNull(to)) { + return allFrom(from); + } + + return this.arena.subMap(from, to).values().iterator(); + } + + @Override + public Entry get(MemorySegment key) { + return this.arena.get(key); + } + + @Override + public void upsert(Entry entry) { + if (Objects.isNull(entry)) { + return; + } + + this.arena.put(entry.key(), entry); + } +} diff --git a/src/main/java/ru/vk/itmo/belonogovnikolay/MemorySegmentComparator.java b/src/main/java/ru/vk/itmo/belonogovnikolay/MemorySegmentComparator.java new file mode 100644 index 000000000..7b6b2c672 --- /dev/null +++ b/src/main/java/ru/vk/itmo/belonogovnikolay/MemorySegmentComparator.java @@ -0,0 +1,25 @@ +package ru.vk.itmo.belonogovnikolay; + +import java.lang.foreign.MemorySegment; +import java.lang.foreign.ValueLayout; +import java.util.Comparator; + +public class MemorySegmentComparator implements Comparator { + + @Override + public int compare(MemorySegment prevSegment, MemorySegment nextSegment) { + + long offset = prevSegment.mismatch(nextSegment); + + if (offset == nextSegment.byteSize()) { + return 1; + } else if (offset == prevSegment.byteSize()) { + return -1; + } else if (offset == -1) { + return 0; + } + + return Byte.compare(prevSegment.get(ValueLayout.JAVA_BYTE, offset), + nextSegment.get(ValueLayout.JAVA_BYTE, offset)); + } +} diff --git a/src/main/java/ru/vk/itmo/test/belonogovnikolay/InMemoryDaoFactoryImpl.java b/src/main/java/ru/vk/itmo/test/belonogovnikolay/InMemoryDaoFactoryImpl.java new file mode 100644 index 000000000..f62f39bcc --- /dev/null +++ b/src/main/java/ru/vk/itmo/test/belonogovnikolay/InMemoryDaoFactoryImpl.java @@ -0,0 +1,58 @@ +package ru.vk.itmo.test.belonogovnikolay; + +import ru.vk.itmo.Dao; +import ru.vk.itmo.Entry; +import ru.vk.itmo.belonogovnikolay.InMemoryTreeDao; +import ru.vk.itmo.test.DaoFactory; + +import java.lang.foreign.MemorySegment; +import java.lang.foreign.ValueLayout; +import java.nio.charset.StandardCharsets; +import java.util.Objects; + +@DaoFactory +public class InMemoryDaoFactoryImpl implements DaoFactory.Factory> { + /** + * Creates new instance of Dao. + * + * @return Dao. + */ + @Override + public Dao> createDao() { + return InMemoryTreeDao.newInstance(); + } + + /** + * Converts data represented in MemorySegment format to String format. + * + * @param memorySegment data in MemorySegment representation. + * @return representation of MemorySegment input data as a String. + */ + @Override + public String toString(MemorySegment memorySegment) { + if (Objects.isNull(memorySegment)) { + return null; + } + return new String(memorySegment.toArray(ValueLayout.JAVA_BYTE), StandardCharsets.UTF_8); + } + + /** + * Converts data represented in String format to MemorySegment format. + * + * @param data data in String representation. + * @return representation of input data as a MemorySegment + */ + @Override + public MemorySegment fromString(String data) { + if (Objects.isNull(data)) { + return null; + } + + return MemorySegment.ofArray(data.getBytes(StandardCharsets.UTF_8)); + } + + @Override + public Entry fromBaseEntry(Entry baseEntry) { + return baseEntry; + } +} From bf2bcabf4836db8ab514ac7ffddeadf31dd5d22d Mon Sep 17 00:00:00 2001 From: Timofeev Kirill Date: Wed, 4 Oct 2023 22:05:48 +0300 Subject: [PATCH 36/45] =?UTF-8?q?=D0=A2=D0=B8=D0=BC=D0=BE=D1=84=D0=B5?= =?UTF-8?q?=D0=B5=D0=B2=20=D0=9A=D0=B8=D1=80=D0=B8=D0=BB=D0=BB,=20=D0=9C?= =?UTF-8?q?=D0=B0=D0=B3=D0=B8=D1=81=D1=82=D1=80=D0=B0=D1=82=D1=83=D1=80?= =?UTF-8?q?=D0=B0=20=D0=98=D0=A2=D0=9C=D0=9E=20"=D0=A0=D0=B0=D1=81=D0=BF?= =?UTF-8?q?=D1=80=D0=B5=D0=B4=D0=B5=D0=BB=D0=B5=D0=BD=D0=BD=D1=8B=D0=B5=20?= =?UTF-8?q?=D0=B2=D0=B5=D0=B1-=D1=81=D0=B5=D1=80=D0=B2=D0=B8=D1=81=D1=8B",?= =?UTF-8?q?=20=D0=B7=D0=B0=D0=B4=D0=B0=D0=BD=D0=B8=D0=B5=201=20=20(#22)?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Co-authored-by: Vadim Tsesko Co-authored-by: Artyom Drozdov --- .../itmo/test/timofeevkirill/FactoryImpl.java | 34 +++++++++++++++ .../vk/itmo/timofeevkirill/InMemoryDao.java | 42 +++++++++++++++++++ .../MemorySegmentComparator.java | 21 ++++++++++ 3 files changed, 97 insertions(+) create mode 100644 src/main/java/ru/vk/itmo/test/timofeevkirill/FactoryImpl.java create mode 100644 src/main/java/ru/vk/itmo/timofeevkirill/InMemoryDao.java create mode 100644 src/main/java/ru/vk/itmo/timofeevkirill/MemorySegmentComparator.java diff --git a/src/main/java/ru/vk/itmo/test/timofeevkirill/FactoryImpl.java b/src/main/java/ru/vk/itmo/test/timofeevkirill/FactoryImpl.java new file mode 100644 index 000000000..c9f309a1b --- /dev/null +++ b/src/main/java/ru/vk/itmo/test/timofeevkirill/FactoryImpl.java @@ -0,0 +1,34 @@ +package ru.vk.itmo.test.timofeevkirill; + +import ru.vk.itmo.Dao; +import ru.vk.itmo.Entry; +import ru.vk.itmo.test.DaoFactory; +import ru.vk.itmo.timofeevkirill.InMemoryDao; + +import java.lang.foreign.MemorySegment; +import java.lang.foreign.ValueLayout; +import java.nio.charset.StandardCharsets; + +@DaoFactory +public class FactoryImpl implements DaoFactory.Factory> { + + @Override + public Dao> createDao() { + return new InMemoryDao(); + } + + @Override + public String toString(MemorySegment memorySegment) { + return new String(memorySegment.toArray(ValueLayout.JAVA_BYTE), StandardCharsets.UTF_8); + } + + @Override + public MemorySegment fromString(String data) { + return data == null ? null : MemorySegment.ofArray(data.getBytes(StandardCharsets.UTF_8)); + } + + @Override + public Entry fromBaseEntry(Entry baseEntry) { + return baseEntry; + } +} diff --git a/src/main/java/ru/vk/itmo/timofeevkirill/InMemoryDao.java b/src/main/java/ru/vk/itmo/timofeevkirill/InMemoryDao.java new file mode 100644 index 000000000..295847df0 --- /dev/null +++ b/src/main/java/ru/vk/itmo/timofeevkirill/InMemoryDao.java @@ -0,0 +1,42 @@ +package ru.vk.itmo.timofeevkirill; + +import ru.vk.itmo.Dao; +import ru.vk.itmo.Entry; + +import java.lang.foreign.MemorySegment; +import java.util.Iterator; +import java.util.concurrent.ConcurrentSkipListMap; + +public class InMemoryDao implements Dao> { + MemorySegmentComparator msComparator = new MemorySegmentComparator(); + ConcurrentSkipListMap> memorySegmentEntries = + new ConcurrentSkipListMap<>(msComparator); + + @Override + public Entry get(MemorySegment key) { + return memorySegmentEntries.get(key); + } + + @Override + public Iterator> get(MemorySegment from, MemorySegment to) { + if (from == null && to == null) { + return memorySegmentEntries.values().iterator(); + } else if (from == null) { + return memorySegmentEntries.headMap(to).values().iterator(); + } else if (to == null) { + return memorySegmentEntries.tailMap(from).values().iterator(); + } else { + return memorySegmentEntries.tailMap(from).headMap(to).values().iterator(); + } + } + + @Override + public void upsert(Entry entry) { + memorySegmentEntries.put(entry.key(), entry); + } + + @Override + public Iterator> all() { + return memorySegmentEntries.values().iterator(); + } +} diff --git a/src/main/java/ru/vk/itmo/timofeevkirill/MemorySegmentComparator.java b/src/main/java/ru/vk/itmo/timofeevkirill/MemorySegmentComparator.java new file mode 100644 index 000000000..6083fcd75 --- /dev/null +++ b/src/main/java/ru/vk/itmo/timofeevkirill/MemorySegmentComparator.java @@ -0,0 +1,21 @@ +package ru.vk.itmo.timofeevkirill; + +import java.lang.foreign.MemorySegment; +import java.util.Comparator; + +public class MemorySegmentComparator implements Comparator { + @Override + public int compare(MemorySegment segment1, MemorySegment segment2) { + byte[] byteArray1 = (byte[]) segment1.heapBase().orElseThrow(); + byte[] byteArray2 = (byte[]) segment2.heapBase().orElseThrow(); + + int minLength = Math.min(byteArray1.length, byteArray2.length); + for (int i = 0; i < minLength; i++) { + int cmp = Byte.compare(byteArray1[i], byteArray2[i]); + if (cmp != 0) { + return cmp; + } + } + return Integer.compare(byteArray1.length, byteArray2.length); + } +} From 77e3731a00dd798ca1e59094969264a0435962c7 Mon Sep 17 00:00:00 2001 From: I'm Lena <62670668+ImLena@users.noreply.github.com> Date: Wed, 4 Oct 2023 22:05:57 +0300 Subject: [PATCH 37/45] =?UTF-8?q?=D0=A5=D0=BE=D0=B4=D0=BE=D1=81=D0=BE?= =?UTF-8?q?=D0=B2=D0=B0=20=D0=95=D0=BB=D0=B5=D0=BD=D0=B0,=20=D0=9C=D0=B0?= =?UTF-8?q?=D0=B3=D0=B8=D1=81=D1=82=D1=80=D0=B0=D1=82=D1=83=D1=80=D0=B0=20?= =?UTF-8?q?=D0=98=D0=A2=D0=9C=D0=9E=20"=D0=A0=D0=B0=D1=81=D0=BF=D1=80?= =?UTF-8?q?=D0=B5=D0=B4=D0=B5=D0=BB=D0=B5=D0=BD=D0=BD=D1=8B=D0=B5=20=D0=B2?= =?UTF-8?q?=D0=B5=D0=B1-=D1=81=D0=B5=D1=80=D0=B2=D0=B8=D1=81=D1=8B",=20?= =?UTF-8?q?=D0=9B=D0=B0=D0=B1=D0=BE=D1=80=D0=B0=D1=82=D0=BE=D1=80=D0=BD?= =?UTF-8?q?=D0=B0=D1=8F=201=20(#23)?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Co-authored-by: Vadim Tsesko --- .../vk/itmo/khodosovaelena/InMemoryDao.java | 56 +++++++++++++++++++ .../itmo/test/khodosovaelena/MyFactory.java | 35 ++++++++++++ 2 files changed, 91 insertions(+) create mode 100644 src/main/java/ru/vk/itmo/khodosovaelena/InMemoryDao.java create mode 100644 src/main/java/ru/vk/itmo/test/khodosovaelena/MyFactory.java diff --git a/src/main/java/ru/vk/itmo/khodosovaelena/InMemoryDao.java b/src/main/java/ru/vk/itmo/khodosovaelena/InMemoryDao.java new file mode 100644 index 000000000..3656dccc4 --- /dev/null +++ b/src/main/java/ru/vk/itmo/khodosovaelena/InMemoryDao.java @@ -0,0 +1,56 @@ +package ru.vk.itmo.khodosovaelena; + +import ru.vk.itmo.Dao; +import ru.vk.itmo.Entry; + +import java.lang.foreign.MemorySegment; +import java.lang.foreign.ValueLayout; +import java.util.Comparator; +import java.util.Iterator; +import java.util.concurrent.ConcurrentNavigableMap; +import java.util.concurrent.ConcurrentSkipListMap; + +public class InMemoryDao implements Dao> { + private final ConcurrentNavigableMap> memorySegmentEntries + = new ConcurrentSkipListMap<>(new MemorySegmentComparator()); + + @Override + public Entry get(MemorySegment key) { + return memorySegmentEntries.get(key); + } + + @Override + public Iterator> get(MemorySegment from, MemorySegment to) { + if (from == null && to == null) { + return memorySegmentEntries.values().iterator(); + } + if (from == null) { + return memorySegmentEntries.headMap(to).values().iterator(); + } + if (to == null) { + return memorySegmentEntries.tailMap(from).values().iterator(); + } + return memorySegmentEntries.subMap(from, to).values().iterator(); + } + + @Override + public void upsert(Entry entry) { + memorySegmentEntries.put(entry.key(), entry); + } + + public static class MemorySegmentComparator implements Comparator { + @Override + public int compare(MemorySegment segment1, MemorySegment segment2) { + long offset = segment1.mismatch(segment2); + if (offset == -1) { + return 0; + } else if (offset == segment2.byteSize()) { + return 1; + } else if (offset == segment1.byteSize()) { + return -1; + } + return Byte.compare(segment1.get(ValueLayout.JAVA_BYTE, offset), + segment2.get(ValueLayout.JAVA_BYTE, offset)); + } + } +} diff --git a/src/main/java/ru/vk/itmo/test/khodosovaelena/MyFactory.java b/src/main/java/ru/vk/itmo/test/khodosovaelena/MyFactory.java new file mode 100644 index 000000000..2eb75d6eb --- /dev/null +++ b/src/main/java/ru/vk/itmo/test/khodosovaelena/MyFactory.java @@ -0,0 +1,35 @@ +package ru.vk.itmo.test.khodosovaelena; + +import ru.vk.itmo.Dao; +import ru.vk.itmo.Entry; +import ru.vk.itmo.khodosovaelena.InMemoryDao; +import ru.vk.itmo.test.DaoFactory; + +import java.lang.foreign.MemorySegment; +import java.lang.foreign.ValueLayout; +import java.nio.charset.StandardCharsets; + +@DaoFactory +public class MyFactory implements DaoFactory.Factory> { + @Override + public Dao> createDao() { + return new InMemoryDao(); + } + + @Override + public String toString(MemorySegment memorySegment) { + if (memorySegment == null) return null; + return new String(memorySegment.toArray(ValueLayout.JAVA_BYTE), StandardCharsets.UTF_8); + } + + @Override + public MemorySegment fromString(String data) { + if (data == null) return null; + return MemorySegment.ofArray(data.getBytes(StandardCharsets.UTF_8)); + } + + @Override + public Entry fromBaseEntry(Entry baseEntry) { + return baseEntry; + } +} From 4877118f2db6dec9d4fe849048aae4e0282554bc Mon Sep 17 00:00:00 2001 From: Alexandr Kobyzhev <43075975+alexnevskiy@users.noreply.github.com> Date: Wed, 4 Oct 2023 23:02:51 +0300 Subject: [PATCH 38/45] =?UTF-8?q?HW1=20=D0=9A=D0=BE=D0=B1=D1=8B=D0=B6?= =?UTF-8?q?=D0=B5=D0=B2=20=D0=90=D0=BB=D0=B5=D0=BA=D1=81=D0=B0=D0=BD=D0=B4?= =?UTF-8?q?=D1=80,=20=D0=9F=D0=BE=D0=BB=D0=B8=D1=82=D0=B5=D1=85=20=D0=98?= =?UTF-8?q?=D0=92=D0=A2=20(#4)?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Co-authored-by: Aleksandr Kobyzhev Co-authored-by: Vadim Tsesko --- .../itmo/kobyzhevaleksandr/InMemoryDao.java | 40 +++++++++++++++++++ .../MemorySegmentComparator.java | 22 ++++++++++ .../kobyzhevaleksandr/InMemoryFactory.java | 34 ++++++++++++++++ 3 files changed, 96 insertions(+) create mode 100644 src/main/java/ru/vk/itmo/kobyzhevaleksandr/InMemoryDao.java create mode 100644 src/main/java/ru/vk/itmo/kobyzhevaleksandr/MemorySegmentComparator.java create mode 100644 src/main/java/ru/vk/itmo/test/kobyzhevaleksandr/InMemoryFactory.java diff --git a/src/main/java/ru/vk/itmo/kobyzhevaleksandr/InMemoryDao.java b/src/main/java/ru/vk/itmo/kobyzhevaleksandr/InMemoryDao.java new file mode 100644 index 000000000..9a3156afd --- /dev/null +++ b/src/main/java/ru/vk/itmo/kobyzhevaleksandr/InMemoryDao.java @@ -0,0 +1,40 @@ +package ru.vk.itmo.kobyzhevaleksandr; + +import ru.vk.itmo.Dao; +import ru.vk.itmo.Entry; + +import java.lang.foreign.MemorySegment; +import java.util.Iterator; +import java.util.NavigableMap; +import java.util.concurrent.ConcurrentSkipListMap; + +public class InMemoryDao implements Dao> { + + private final NavigableMap> map = + new ConcurrentSkipListMap<>(new MemorySegmentComparator()); + + @Override + public Iterator> get(MemorySegment from, MemorySegment to) { + if (from == null && to == null) { + return map.values().iterator(); + } else if (from == null) { + return map.headMap(to).values().iterator(); + } else if (to == null) { + return map.tailMap(from).values().iterator(); + } + return map.subMap(from, to).values().iterator(); + } + + @Override + public Entry get(MemorySegment key) { + return map.get(key); + } + + @Override + public void upsert(Entry entry) { + if (entry == null) { + throw new IllegalArgumentException("Entry cannot be null."); + } + map.put(entry.key(), entry); + } +} diff --git a/src/main/java/ru/vk/itmo/kobyzhevaleksandr/MemorySegmentComparator.java b/src/main/java/ru/vk/itmo/kobyzhevaleksandr/MemorySegmentComparator.java new file mode 100644 index 000000000..e5135e7a7 --- /dev/null +++ b/src/main/java/ru/vk/itmo/kobyzhevaleksandr/MemorySegmentComparator.java @@ -0,0 +1,22 @@ +package ru.vk.itmo.kobyzhevaleksandr; + +import java.lang.foreign.MemorySegment; +import java.lang.foreign.ValueLayout; +import java.util.Comparator; + +public class MemorySegmentComparator implements Comparator { + + @Override + public int compare(MemorySegment memorySegment1, MemorySegment memorySegment2) { + long offset = memorySegment1.mismatch(memorySegment2); + if (offset == -1) { + return 0; + } else if (offset == memorySegment1.byteSize()) { + return -1; + } else if (offset == memorySegment2.byteSize()) { + return 1; + } + return Byte.compare(memorySegment1.get(ValueLayout.JAVA_BYTE, offset), + memorySegment2.get(ValueLayout.JAVA_BYTE, offset)); + } +} diff --git a/src/main/java/ru/vk/itmo/test/kobyzhevaleksandr/InMemoryFactory.java b/src/main/java/ru/vk/itmo/test/kobyzhevaleksandr/InMemoryFactory.java new file mode 100644 index 000000000..c5e67900f --- /dev/null +++ b/src/main/java/ru/vk/itmo/test/kobyzhevaleksandr/InMemoryFactory.java @@ -0,0 +1,34 @@ +package ru.vk.itmo.test.kobyzhevaleksandr; + +import ru.vk.itmo.Dao; +import ru.vk.itmo.Entry; +import ru.vk.itmo.kobyzhevaleksandr.InMemoryDao; +import ru.vk.itmo.test.DaoFactory; + +import java.lang.foreign.MemorySegment; +import java.lang.foreign.ValueLayout; +import java.nio.charset.StandardCharsets; + +@DaoFactory +public class InMemoryFactory implements DaoFactory.Factory> { + + @Override + public Dao> createDao() { + return new InMemoryDao(); + } + + @Override + public String toString(MemorySegment data) { + return data == null ? null : new String(data.toArray(ValueLayout.JAVA_BYTE), StandardCharsets.UTF_8); + } + + @Override + public MemorySegment fromString(String data) { + return data == null ? null : MemorySegment.ofArray(data.getBytes(StandardCharsets.UTF_8)); + } + + @Override + public Entry fromBaseEntry(Entry baseEntry) { + return baseEntry; + } +} From 2ff51a3e31ea3143df5e34a85577ebd69eb12133 Mon Sep 17 00:00:00 2001 From: Alisa Seletskaya <49619174+sealisaa@users.noreply.github.com> Date: Wed, 4 Oct 2023 23:07:23 +0300 Subject: [PATCH 39/45] =?UTF-8?q?HW1=20=D0=A1=D0=B5=D0=BB=D0=B5=D1=86?= =?UTF-8?q?=D0=BA=D0=B0=D1=8F=20=D0=90=D0=BB=D0=B8=D1=81=D0=B0,=20=D0=9F?= =?UTF-8?q?=D0=BE=D0=BB=D0=B8=D1=82=D0=B5=D1=85=20(#47)?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- .../vk/itmo/seletskayaalisa/InMemoryDao.java | 44 +++++++++++++++++++ .../MemorySegmentComparator.java | 24 ++++++++++ .../seletskayaalisa/InMemoryDaoFactory.java | 39 ++++++++++++++++ 3 files changed, 107 insertions(+) create mode 100644 src/main/java/ru/vk/itmo/seletskayaalisa/InMemoryDao.java create mode 100644 src/main/java/ru/vk/itmo/seletskayaalisa/MemorySegmentComparator.java create mode 100644 src/main/java/ru/vk/itmo/test/seletskayaalisa/InMemoryDaoFactory.java diff --git a/src/main/java/ru/vk/itmo/seletskayaalisa/InMemoryDao.java b/src/main/java/ru/vk/itmo/seletskayaalisa/InMemoryDao.java new file mode 100644 index 000000000..4fa0170ed --- /dev/null +++ b/src/main/java/ru/vk/itmo/seletskayaalisa/InMemoryDao.java @@ -0,0 +1,44 @@ +package ru.vk.itmo.seletskayaalisa; + +import ru.vk.itmo.Dao; +import ru.vk.itmo.Entry; +import java.lang.foreign.MemorySegment; +import java.util.Iterator; +import java.util.NavigableMap; +import java.util.concurrent.ConcurrentSkipListMap; + +public class InMemoryDao implements Dao> { + private final NavigableMap> segmentsMap; + + public InMemoryDao() { + segmentsMap = new ConcurrentSkipListMap<>(new MemorySegmentComparator()); + } + + @Override + public Entry get(MemorySegment key) { + return segmentsMap.get(key); + } + + @Override + public Iterator> get(MemorySegment from, MemorySegment to) { + if (from == null && to == null) { + return segmentsMap.values().iterator(); + } + if (from == null) { + return segmentsMap.headMap(to).values().iterator(); + } + if (to == null) { + return segmentsMap.tailMap(from).values().iterator(); + } + return segmentsMap.subMap(from, to).values().iterator(); + } + + @Override + public void upsert(Entry entry) { + if (entry == null) { + throw new IllegalArgumentException("The provided entry is null"); + } + segmentsMap.put(entry.key(), entry); + } + +} diff --git a/src/main/java/ru/vk/itmo/seletskayaalisa/MemorySegmentComparator.java b/src/main/java/ru/vk/itmo/seletskayaalisa/MemorySegmentComparator.java new file mode 100644 index 000000000..04a81644e --- /dev/null +++ b/src/main/java/ru/vk/itmo/seletskayaalisa/MemorySegmentComparator.java @@ -0,0 +1,24 @@ +package ru.vk.itmo.seletskayaalisa; + +import java.lang.foreign.MemorySegment; +import java.lang.foreign.ValueLayout; +import java.util.Comparator; + +public class MemorySegmentComparator implements Comparator { + + @Override + public int compare(MemorySegment ms1, MemorySegment ms2) { + long offset = ms1.mismatch(ms2); + if (offset == ms1.byteSize()) { + return -1; + } + if (offset == ms2.byteSize()) { + return 1; + } + if (offset == -1) { + return 0; + } + return Byte.compare(ms1.get(ValueLayout.JAVA_BYTE, offset), + ms2.get(ValueLayout.JAVA_BYTE, offset)); + } +} diff --git a/src/main/java/ru/vk/itmo/test/seletskayaalisa/InMemoryDaoFactory.java b/src/main/java/ru/vk/itmo/test/seletskayaalisa/InMemoryDaoFactory.java new file mode 100644 index 000000000..e69464ed3 --- /dev/null +++ b/src/main/java/ru/vk/itmo/test/seletskayaalisa/InMemoryDaoFactory.java @@ -0,0 +1,39 @@ +package ru.vk.itmo.test.seletskayaalisa; + +import ru.vk.itmo.Dao; +import ru.vk.itmo.Entry; +import ru.vk.itmo.seletskayaalisa.InMemoryDao; +import ru.vk.itmo.test.DaoFactory; +import java.lang.foreign.MemorySegment; +import java.lang.foreign.ValueLayout; +import java.nio.charset.StandardCharsets; + +@DaoFactory +public class InMemoryDaoFactory implements DaoFactory.Factory> { + @Override + public Dao> createDao() { + return new InMemoryDao(); + } + + @Override + public String toString(MemorySegment memorySegment) { + if (memorySegment == null) { + return null; + } + return new String(memorySegment.toArray(ValueLayout.JAVA_BYTE), StandardCharsets.UTF_8); + } + + @Override + public MemorySegment fromString(String data) { + if (data == null) { + return null; + } + return MemorySegment.ofArray(data.getBytes(StandardCharsets.UTF_8)); + } + + @Override + public Entry fromBaseEntry(Entry baseEntry) { + return baseEntry; + } + +} From 43adc83ac1c9ad1742586e0f61b775081cb46df0 Mon Sep 17 00:00:00 2001 From: Andrey <70713475+Queenore@users.noreply.github.com> Date: Wed, 4 Oct 2023 23:19:59 +0300 Subject: [PATCH 40/45] =?UTF-8?q?=D0=A7=D0=B5=D1=88=D0=B5=D0=B2=20=D0=90?= =?UTF-8?q?=D0=BD=D0=B4=D1=80=D0=B5=D0=B9,=20=D0=9F=D0=BE=D0=BB=D0=B8?= =?UTF-8?q?=D1=82=D0=B5=D1=85,=20=D0=97=D0=B0=D0=B4=D0=B0=D0=BD=D0=B8?= =?UTF-8?q?=D0=B5=201=20(#45)?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Co-authored-by: Vadim Tsesko --- .../ru/vk/itmo/cheshevandrey/InMemoryDao.java | 69 +++++++++++++++++++ .../test/cheshevandrey/InMemoryFactory.java | 48 +++++++++++++ 2 files changed, 117 insertions(+) create mode 100644 src/main/java/ru/vk/itmo/cheshevandrey/InMemoryDao.java create mode 100644 src/main/java/ru/vk/itmo/test/cheshevandrey/InMemoryFactory.java diff --git a/src/main/java/ru/vk/itmo/cheshevandrey/InMemoryDao.java b/src/main/java/ru/vk/itmo/cheshevandrey/InMemoryDao.java new file mode 100644 index 000000000..eb15d09b3 --- /dev/null +++ b/src/main/java/ru/vk/itmo/cheshevandrey/InMemoryDao.java @@ -0,0 +1,69 @@ +package ru.vk.itmo.cheshevandrey; + +import ru.vk.itmo.Dao; +import ru.vk.itmo.Entry; + +import java.lang.foreign.MemorySegment; +import java.lang.foreign.ValueLayout; +import java.util.Iterator; +import java.util.concurrent.ConcurrentNavigableMap; +import java.util.concurrent.ConcurrentSkipListMap; + +public class InMemoryDao implements Dao> { + + private final ConcurrentNavigableMap> map = new ConcurrentSkipListMap<>( + (seg1, seg2) -> { + long segSize1 = seg1.byteSize(); + long segSize2 = seg2.byteSize(); + + if (segSize1 == 0 && segSize2 == 0) { + return 0; + } else if (segSize1 > segSize2 || segSize1 == 0) { + return -1; + } else if (segSize1 < segSize2) { + return 1; + } + + int offset = 0; + while (offset < segSize1) { + byte byte1 = seg1.get(ValueLayout.JAVA_BYTE, offset); + byte byte2 = seg2.get(ValueLayout.JAVA_BYTE, offset); + + int compareResult = Byte.compare(byte1, byte2); + if (compareResult != 0) { + return compareResult; + } + + offset++; + } + + return 0; + } + ); + + @Override + public Entry get(MemorySegment key) { + return map.get(key); + } + + @Override + public Iterator> get(MemorySegment from, MemorySegment to) { + + if (from == null && to == null) { + return map.values().iterator(); + } else if (from == MemorySegment.NULL) { + if (to == MemorySegment.NULL) { + return map.headMap(from, true).values().iterator(); + } else { + return map.subMap(map.firstKey(), to).values().iterator(); + } + } else { + return map.subMap(from, to).values().iterator(); + } + } + + @Override + public void upsert(Entry entry) { + map.put(entry.key(), entry); + } +} diff --git a/src/main/java/ru/vk/itmo/test/cheshevandrey/InMemoryFactory.java b/src/main/java/ru/vk/itmo/test/cheshevandrey/InMemoryFactory.java new file mode 100644 index 000000000..881a713f1 --- /dev/null +++ b/src/main/java/ru/vk/itmo/test/cheshevandrey/InMemoryFactory.java @@ -0,0 +1,48 @@ +package ru.vk.itmo.test.cheshevandrey; + +import ru.vk.itmo.Dao; +import ru.vk.itmo.Entry; +import ru.vk.itmo.cheshevandrey.InMemoryDao; +import ru.vk.itmo.test.DaoFactory; + +import java.lang.foreign.MemorySegment; +import java.lang.foreign.ValueLayout; + +import static java.nio.charset.StandardCharsets.UTF_8; + +@DaoFactory +public class InMemoryFactory implements DaoFactory.Factory> { + + @Override + public Dao> createDao() { + return new InMemoryDao(); + } + + @Override + public String toString(MemorySegment memorySegment) { + + int memorySegmentSize = (int) memorySegment.byteSize(); + + byte[] byteArray = new byte[memorySegmentSize]; + + int offset = 0; + while (offset < memorySegmentSize) { + byteArray[offset] = memorySegment.get(ValueLayout.JAVA_BYTE, offset); + offset++; + } + + return new String(byteArray, UTF_8); + } + + @Override + public MemorySegment fromString(String data) { + return (data == null) + ? MemorySegment.NULL : + MemorySegment.ofArray(data.getBytes(UTF_8)); + } + + @Override + public Entry fromBaseEntry(Entry baseEntry) { + return baseEntry; + } +} From 52e4eb5174fd7a2120dcc286fca4698ecbebae10 Mon Sep 17 00:00:00 2001 From: llav3ji2019 <56979109+llav3ji2019@users.noreply.github.com> Date: Wed, 4 Oct 2023 23:52:47 +0300 Subject: [PATCH 41/45] =?UTF-8?q?Emelyanov=20Pavel=20Polytech=20=D0=AD?= =?UTF-8?q?=D1=82=D0=B0=D0=BF=201=20(#29)?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Co-authored-by: Vadim Tsesko Co-authored-by: Anton Lamtev --- .../itmo/emelyanovpavel/InMemoryDaoImpl.java | 76 +++++++++++++++++++ .../test/emelyanovpavel/DaoFactoryImpl.java | 36 +++++++++ 2 files changed, 112 insertions(+) create mode 100644 src/main/java/ru/vk/itmo/emelyanovpavel/InMemoryDaoImpl.java create mode 100644 src/main/java/ru/vk/itmo/test/emelyanovpavel/DaoFactoryImpl.java diff --git a/src/main/java/ru/vk/itmo/emelyanovpavel/InMemoryDaoImpl.java b/src/main/java/ru/vk/itmo/emelyanovpavel/InMemoryDaoImpl.java new file mode 100644 index 000000000..e6d1f57c3 --- /dev/null +++ b/src/main/java/ru/vk/itmo/emelyanovpavel/InMemoryDaoImpl.java @@ -0,0 +1,76 @@ +package ru.vk.itmo.emelyanovpavel; + +import ru.vk.itmo.Dao; +import ru.vk.itmo.Entry; + +import java.lang.foreign.MemorySegment; +import java.util.Iterator; +import java.util.concurrent.ConcurrentNavigableMap; +import java.util.concurrent.ConcurrentSkipListMap; + +import static java.lang.foreign.ValueLayout.JAVA_BYTE; + +public class InMemoryDaoImpl implements Dao> { + + private final ConcurrentNavigableMap> storage = new ConcurrentSkipListMap<>( + (o1, o2) -> { + long offset = o1.mismatch(o2); + if (offset == -1) { + return 0; + } + if (offset == o1.byteSize()) { + return -1; + } + if (offset == o2.byteSize()) { + return 1; + } + return Byte.compare(o1.get(JAVA_BYTE, offset), o2.get(JAVA_BYTE, offset)); + }); + + @Override + public Iterator> get(MemorySegment from, MemorySegment to) { + if (from == null && to == null) { + return all(); + } + if (from == null) { + return allTo(to); + } + if (to == null) { + return allFrom(from); + } + return storage.subMap(from, to) + .values() + .iterator(); + } + + @Override + public Iterator> allFrom(MemorySegment from) { + return storage.tailMap(from) + .values() + .iterator(); + } + + @Override + public Iterator> allTo(MemorySegment to) { + return storage.headMap(to) + .values() + .iterator(); + } + + @Override + public Iterator> all() { + return storage.values() + .iterator(); + } + + @Override + public void upsert(Entry entry) { + storage.put(entry.key(), entry); + } + + @Override + public Entry get(MemorySegment key) { + return storage.get(key); + } + +} diff --git a/src/main/java/ru/vk/itmo/test/emelyanovpavel/DaoFactoryImpl.java b/src/main/java/ru/vk/itmo/test/emelyanovpavel/DaoFactoryImpl.java new file mode 100644 index 000000000..69e558f27 --- /dev/null +++ b/src/main/java/ru/vk/itmo/test/emelyanovpavel/DaoFactoryImpl.java @@ -0,0 +1,36 @@ +package ru.vk.itmo.test.emelyanovpavel; + +import ru.vk.itmo.Dao; +import ru.vk.itmo.Entry; +import ru.vk.itmo.emelyanovpavel.InMemoryDaoImpl; +import ru.vk.itmo.test.DaoFactory; + +import java.lang.foreign.MemorySegment; + +import static java.lang.foreign.ValueLayout.JAVA_BYTE; +import static java.nio.charset.StandardCharsets.UTF_8; + +@DaoFactory +public class DaoFactoryImpl implements DaoFactory.Factory> { + + @Override + public Dao> createDao() { + return new InMemoryDaoImpl(); + } + + @Override + public String toString(MemorySegment memorySegment) { + return memorySegment == null ? null : new String(memorySegment.toArray(JAVA_BYTE), UTF_8); + } + + @Override + public MemorySegment fromString(String data) { + return data == null ? null : MemorySegment.ofArray(data.getBytes(UTF_8)); + } + + @Override + public Entry fromBaseEntry(Entry baseEntry) { + return baseEntry; + } + +} From cf75cbfe8db72aef2be97ec7fa6ec504e0865e57 Mon Sep 17 00:00:00 2001 From: Kirill06344 <67016214+Kirill06344@users.noreply.github.com> Date: Thu, 5 Oct 2023 00:06:11 +0300 Subject: [PATCH 42/45] =?UTF-8?q?HW1=20-=20=D0=91=D0=B0=D0=B6=D0=B5=D0=BD?= =?UTF-8?q?=D0=BE=D0=B2=20=D0=9A=D0=B8=D1=80=D0=B8=D0=BB=D0=BB,=20=D0=9F?= =?UTF-8?q?=D0=BE=D0=BB=D0=B8=D1=82=D0=B5=D1=85=20(#59)?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Co-authored-by: Vadim Tsesko Co-authored-by: Anton Lamtev --- .../itmo/bazhenovkirill/InMemoryDaoImpl.java | 56 +++++++++++++++++++ .../test/bazhenovkirill/DaoFactoryImpl.java | 36 ++++++++++++ 2 files changed, 92 insertions(+) create mode 100644 src/main/java/ru/vk/itmo/bazhenovkirill/InMemoryDaoImpl.java create mode 100644 src/main/java/ru/vk/itmo/test/bazhenovkirill/DaoFactoryImpl.java diff --git a/src/main/java/ru/vk/itmo/bazhenovkirill/InMemoryDaoImpl.java b/src/main/java/ru/vk/itmo/bazhenovkirill/InMemoryDaoImpl.java new file mode 100644 index 000000000..4b43016be --- /dev/null +++ b/src/main/java/ru/vk/itmo/bazhenovkirill/InMemoryDaoImpl.java @@ -0,0 +1,56 @@ +package ru.vk.itmo.bazhenovkirill; + +import ru.vk.itmo.Dao; +import ru.vk.itmo.Entry; + +import java.lang.foreign.MemorySegment; +import java.lang.foreign.ValueLayout; +import java.util.Iterator; +import java.util.concurrent.ConcurrentNavigableMap; +import java.util.concurrent.ConcurrentSkipListMap; + +public class InMemoryDaoImpl implements Dao> { + + private final ConcurrentNavigableMap> storage = new ConcurrentSkipListMap<>( + (ms1, ms2) -> { + long mismatch = ms1.mismatch(ms2); + if (mismatch == -1) { + return 0; + } + if (ms2.byteSize() == mismatch) { + return 1; + } + if (ms1.byteSize() == mismatch) { + return -1; + } + return Byte.compare( + ms1.get(ValueLayout.JAVA_BYTE, mismatch), + ms2.get(ValueLayout.JAVA_BYTE, mismatch)); + } + ); + + @Override + public Iterator> get(MemorySegment from, MemorySegment to) { + if (from == null) { + if (to != null) { + return storage.headMap(to).values().iterator(); + } + return storage.values().iterator(); + } + if (to == null) { + return storage.tailMap(from).values().iterator(); + } + return storage.subMap(from, true, to, false).values().iterator(); + } + + @Override + public Entry get(MemorySegment key) { + return storage.get(key); + } + + @Override + public void upsert(Entry entry) { + storage.put(entry.key(), entry); + } + +} diff --git a/src/main/java/ru/vk/itmo/test/bazhenovkirill/DaoFactoryImpl.java b/src/main/java/ru/vk/itmo/test/bazhenovkirill/DaoFactoryImpl.java new file mode 100644 index 000000000..3d9acc97a --- /dev/null +++ b/src/main/java/ru/vk/itmo/test/bazhenovkirill/DaoFactoryImpl.java @@ -0,0 +1,36 @@ +package ru.vk.itmo.test.bazhenovkirill; + +import ru.vk.itmo.Dao; +import ru.vk.itmo.Entry; +import ru.vk.itmo.bazhenovkirill.InMemoryDaoImpl; +import ru.vk.itmo.test.DaoFactory; + +import java.lang.foreign.MemorySegment; +import java.lang.foreign.ValueLayout; +import java.nio.charset.StandardCharsets; + +@DaoFactory +public class DaoFactoryImpl implements DaoFactory.Factory> { + + @Override + public Dao> createDao() { + return new InMemoryDaoImpl(); + } + + @Override + public String toString(MemorySegment memorySegment) { + return memorySegment == null + ? null + : new String(memorySegment.toArray(ValueLayout.JAVA_BYTE), StandardCharsets.UTF_8); + } + + @Override + public MemorySegment fromString(String data) { + return data == null ? null : MemorySegment.ofArray(data.getBytes(StandardCharsets.UTF_8)); + } + + @Override + public Entry fromBaseEntry(Entry baseEntry) { + return baseEntry; + } +} From f5e49472b62c50321befdeca4346c44d655fe994 Mon Sep 17 00:00:00 2001 From: Dmitrij_Tyapuev <94751651+typuichik123@users.noreply.github.com> Date: Thu, 5 Oct 2023 00:11:09 +0300 Subject: [PATCH 43/45] =?UTF-8?q?=D0=A2=D1=8F=D0=BF=D1=83=D0=B5=D0=B2=20?= =?UTF-8?q?=D0=94=D0=BC=D0=B8=D1=82=D1=80=D0=B8=D0=B9.=20=D0=9C=D0=B0?= =?UTF-8?q?=D0=B3=D0=B8=D1=81=D1=82=D1=80=D0=B0=D1=82=D1=83=D1=80=D0=B0,?= =?UTF-8?q?=20=D0=9F=D0=BE=D0=BB=D0=B8=D1=82=D0=B5=D1=85,=20=D0=AD=D1=82?= =?UTF-8?q?=D0=B0=D0=BF=201=20(#46)?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Co-authored-by: Vadim Tsesko Co-authored-by: Anton Lamtev --- .../DaoFactoryImplementation.java | 36 +++++++++++++ .../vk/itmo/tyapuevdmitrij/InMemoryDao.java | 53 +++++++++++++++++++ 2 files changed, 89 insertions(+) create mode 100644 src/main/java/ru/vk/itmo/test/tyapuevdmitrij/DaoFactoryImplementation.java create mode 100644 src/main/java/ru/vk/itmo/tyapuevdmitrij/InMemoryDao.java diff --git a/src/main/java/ru/vk/itmo/test/tyapuevdmitrij/DaoFactoryImplementation.java b/src/main/java/ru/vk/itmo/test/tyapuevdmitrij/DaoFactoryImplementation.java new file mode 100644 index 000000000..bd3985830 --- /dev/null +++ b/src/main/java/ru/vk/itmo/test/tyapuevdmitrij/DaoFactoryImplementation.java @@ -0,0 +1,36 @@ +package ru.vk.itmo.test.tyapuevdmitrij; + +import ru.vk.itmo.Dao; +import ru.vk.itmo.Entry; +import ru.vk.itmo.test.DaoFactory; +import ru.vk.itmo.tyapuevdmitrij.InMemoryDao; + +import java.lang.foreign.MemorySegment; +import java.lang.foreign.ValueLayout; +import java.nio.charset.StandardCharsets; + +@DaoFactory +public class DaoFactoryImplementation implements DaoFactory.Factory> { + + @Override + public Dao> createDao() { + return new InMemoryDao(); + } + + @Override + public String toString(MemorySegment memorySegment) { + return memorySegment == null + ? null : new String(memorySegment.toArray(ValueLayout.JAVA_BYTE), StandardCharsets.UTF_8); + } + + @Override + public MemorySegment fromString(String data) { + return data == null ? null : MemorySegment.ofArray(data.getBytes(StandardCharsets.UTF_8)); + } + + @Override + public Entry fromBaseEntry(Entry baseEntry) { + return baseEntry; + } +} + diff --git a/src/main/java/ru/vk/itmo/tyapuevdmitrij/InMemoryDao.java b/src/main/java/ru/vk/itmo/tyapuevdmitrij/InMemoryDao.java new file mode 100644 index 000000000..b0b771962 --- /dev/null +++ b/src/main/java/ru/vk/itmo/tyapuevdmitrij/InMemoryDao.java @@ -0,0 +1,53 @@ +package ru.vk.itmo.tyapuevdmitrij; + +import ru.vk.itmo.Dao; +import ru.vk.itmo.Entry; + +import java.lang.foreign.MemorySegment; +import java.lang.foreign.ValueLayout; +import java.util.Comparator; +import java.util.Iterator; +import java.util.concurrent.ConcurrentNavigableMap; +import java.util.concurrent.ConcurrentSkipListMap; + +public class InMemoryDao implements Dao> { + private final Comparator memorySegmentComparator = (segment1, segment2) -> { + long offset = segment1.mismatch(segment2); + if (offset == -1) { + return 0; + } + if (offset == segment1.byteSize()) { + return -1; + } + if (offset == segment2.byteSize()) { + return 1; + } + return segment1.get(ValueLayout.JAVA_BYTE, offset) - segment2.get(ValueLayout.JAVA_BYTE, offset); + }; + private final ConcurrentNavigableMap> dataMap + = new ConcurrentSkipListMap<>(memorySegmentComparator); + + @Override + public Iterator> get(MemorySegment from, MemorySegment to) { + if (from == null && to == null) { + return dataMap.values().iterator(); + } else if (from == null) { + return dataMap.headMap(to).values().iterator(); + } else if (to == null) { + return dataMap.tailMap(from).values().iterator(); + } + return dataMap.subMap(from, to).values().iterator(); + } + + @Override + public Entry get(MemorySegment key) { + return dataMap.get(key); + } + + @Override + public void upsert(Entry entry) { + dataMap.put(entry.key(), entry); + } +} + + From 47d31c7a69d8ebc3c156a5092051464db0c61b1b Mon Sep 17 00:00:00 2001 From: Vadim Tsesko Date: Thu, 5 Oct 2023 14:39:12 +0300 Subject: [PATCH 44/45] Add -Werror compiler option and fix existing warnings --- build.gradle | 5 ++++- .../vk/itmo/boturkhonovkamron/MemorySegmentComparator.java | 2 +- .../java/ru/vk/itmo/test/tuzikovalexandr/DaoFactoryImpl.java | 2 +- 3 files changed, 6 insertions(+), 3 deletions(-) diff --git a/build.gradle b/build.gradle index da5e1e9c3..ed771f55c 100644 --- a/build.gradle +++ b/build.gradle @@ -13,6 +13,7 @@ java { repositories { mavenCentral() } + dependencies { // Checks errorprone 'com.google.errorprone:error_prone_core:2.11.0' @@ -37,9 +38,11 @@ checkstyle { compileJava { options.compilerArgs += ["--enable-preview"] + + // Enforce errors + options.compilerArgs += ["-Werror"] } compileTestJava { options.compilerArgs += ["--enable-preview"] } - diff --git a/src/main/java/ru/vk/itmo/boturkhonovkamron/MemorySegmentComparator.java b/src/main/java/ru/vk/itmo/boturkhonovkamron/MemorySegmentComparator.java index 2cac2f930..78b9069b5 100644 --- a/src/main/java/ru/vk/itmo/boturkhonovkamron/MemorySegmentComparator.java +++ b/src/main/java/ru/vk/itmo/boturkhonovkamron/MemorySegmentComparator.java @@ -27,6 +27,6 @@ public int compare(final MemorySegment left, final MemorySegment right) { return Byte.compare(left.get(ValueLayout.JAVA_BYTE, mismatch), right.get(ValueLayout.JAVA_BYTE, mismatch)); } - return (int) (leftSize - rightSize); + return Long.compare(leftSize, rightSize); } } diff --git a/src/main/java/ru/vk/itmo/test/tuzikovalexandr/DaoFactoryImpl.java b/src/main/java/ru/vk/itmo/test/tuzikovalexandr/DaoFactoryImpl.java index b1a101673..a04e67b96 100644 --- a/src/main/java/ru/vk/itmo/test/tuzikovalexandr/DaoFactoryImpl.java +++ b/src/main/java/ru/vk/itmo/test/tuzikovalexandr/DaoFactoryImpl.java @@ -22,7 +22,7 @@ public String toString(MemorySegment memorySegment) { ByteBuffer byteBuffer = memorySegment.asByteBuffer(); - return byteBuffer == null ? null : new String(byteBuffer.array(), StandardCharsets.UTF_8); + return byteBuffer == null ? null : new String(byteBuffer.array(), byteBuffer.arrayOffset(), byteBuffer.remaining(), StandardCharsets.UTF_8); } @Override From 1d737164f73aea7cb9b60a296cddfa6176964889 Mon Sep 17 00:00:00 2001 From: Vadim Tsesko Date: Thu, 5 Oct 2023 14:45:46 +0300 Subject: [PATCH 45/45] Add autoupdate GitHub action --- .github/workflows/autoupdate.yaml | 18 ++++++++++++++++++ 1 file changed, 18 insertions(+) create mode 100644 .github/workflows/autoupdate.yaml diff --git a/.github/workflows/autoupdate.yaml b/.github/workflows/autoupdate.yaml new file mode 100644 index 000000000..cd544b9cc --- /dev/null +++ b/.github/workflows/autoupdate.yaml @@ -0,0 +1,18 @@ +name: autoupdate +on: + push: + branches: + - main +jobs: + autoupdate: + name: autoupdate + runs-on: ubuntu-22.04 + steps: + - uses: docker://chinthakagodawita/autoupdate-action:v1 + env: + GITHUB_TOKEN: '${{ secrets.GITHUB_TOKEN }}' + - run: echo 'Merge conflicts found!' + if: ${{ steps.autoupdate.outputs.conflicted }} + - run: echo 'No merge conflicts' + if: ${{ !steps.autoupdate.outputs.conflicted }} +