From 646482c555e121e4fd44fbcbfa63fa97b5d10e54 Mon Sep 17 00:00:00 2001 From: Avril Date: Fri, 11 Jun 2021 20:35:18 +0100 Subject: [PATCH] scrapped fuck this language honsetly what shit --- include/cow.hpp | 2 ++ include/cow/area.hpp | 9 ++++++++- include/cow/slice.hpp | 25 ++++++++++++++----------- include/cow/typed.hpp | 37 ++++++++++++++++++++++++------------- src/test/main.cpp | 4 ++-- 5 files changed, 50 insertions(+), 27 deletions(-) diff --git a/include/cow.hpp b/include/cow.hpp index 80e3c0e..e0202bf 100644 --- a/include/cow.hpp +++ b/include/cow.hpp @@ -27,6 +27,7 @@ struct Cow : public _cow_util::Span { virtual Fake clone() const; + protected: inline void* area() override { auto raw = get_raw(); return raw ? cow_ptr(raw) : nullptr; @@ -35,6 +36,7 @@ struct Cow : public _cow_util::Span { auto raw = get_raw(); return raw ? cow_ptr_of(const void, raw) : nullptr; } + public: /// Get the size of the mapped area. /// diff --git a/include/cow/area.hpp b/include/cow/area.hpp index 9bc26e4..f62381a 100644 --- a/include/cow/area.hpp +++ b/include/cow/area.hpp @@ -5,9 +5,10 @@ #include #include +#include "slice.hpp" namespace _cow_util { - struct Area { + struct Area : public Span { Area() = delete; explicit Area(size_t sz); @@ -30,7 +31,13 @@ namespace _cow_util { inline cow_t* raw() const { return _area->raw(); } + inline size_t size() const override { return _area->size(); } + ~Area(); + protected: + inline void* area() override { return _area->ptr(); } + inline const void* area() const override { return _area->ptr(); } + private: const std::unique_ptr _area; }; diff --git a/include/cow/slice.hpp b/include/cow/slice.hpp index 76a3ab1..4d6555e 100644 --- a/include/cow/slice.hpp +++ b/include/cow/slice.hpp @@ -4,17 +4,19 @@ namespace _cow_util { /// A type that spans a sized region of memory template struct Span { + protected: virtual const void* area() const =0; virtual void* area() = 0; + public: virtual size_t size() const = 0; - inline T* ptr() { return (T*)area(); } - inline const T* ptr() const { return (const T*)area(); } + inline T* ptr() { return reinterpret_cast(area()); } + inline const T* ptr() const { return reinterpret_cast(area()); } inline size_t size_bytes() const { return size() * sizeof(T); } - inline unsigned char* as_bytes() { return (unsigned char*)area(); } - inline const unsigned char* as_bytes() const { return (const unsigned char*)area(); } + inline unsigned char* as_bytes() { return area_as(); } + inline const unsigned char* as_bytes() const { return area_as(); } inline T& operator[](size_t index) { if(index >= size()) throw "index out of range"; @@ -38,9 +40,9 @@ namespace _cow_util { inline operator T*() { return &(*this)[0]; } template - inline U* area_as() requires(sizeof(T) % sizeof(U) == 0) { return (U*)area(); } + inline U* area_as() requires(sizeof(T) % sizeof(U) == 0) { return reinterpret_cast(area()); } template - inline const U* area_as() const requires(sizeof(T) % sizeof(U) == 0) { return (U*)area(); } + inline const U* area_as() const requires(sizeof(T) % sizeof(U) == 0) { return reinterpret_cast(area()); } template size_t size_as() const requires(sizeof(T) % sizeof(U) == 0) { return size_bytes() / sizeof(U); } @@ -89,23 +91,24 @@ namespace _cow_util { inline const Slice slice_wrap(ssize_t len) const { return slice_abs((size_t)wrap_len(len)); } template - inline Span::Slice reinterpret() { return typename Span::Slice((U*)area(), size_bytes() / sizeof(U)); } + inline Span::Slice reinterpret() { return typename Span::Slice(area_as(), size_bytes() / sizeof(U)); } template - inline Span::Slice reinterpret() const { return typename Span::Slice((const U*)area(), size_bytes() / sizeof(U)); } + inline Span::Slice reinterpret() const { return typename Span::Slice(area_as(), size_bytes() / sizeof(U)); } }; /// A slice of memory with a backing pointer and size. template struct Span::Slice : public Span { - inline Slice(T* ptr, size_t sz) : _area((void*)ptr), _size(sz){} + inline Slice(T* ptr, size_t sz) : _area(reinterpret_cast(ptr)), _size(sz){} inline Slice(const Span& slice) : _area(const_cast(slice.area())), _size(slice.size()){} inline Slice(const Slice& copy) = default; inline Slice(Slice&& copy) : _area(copy._area), _size(copy._size){ *const_cast(©._size) = 0; } Slice() = delete; - + + inline size_t size() const override { return _size; } + protected: inline const void* area() const override { return _area; } inline void* area() override { return _area; } - inline size_t size() const override { return _size; } private: void* const _area; diff --git a/include/cow/typed.hpp b/include/cow/typed.hpp index dedadd7..695ca9a 100644 --- a/include/cow/typed.hpp +++ b/include/cow/typed.hpp @@ -3,6 +3,8 @@ #include #include +XXX: Fuck this. Rewrite to use composition. Inheritance is a comlpete joke. + template struct TypedCow : private Cow, public _cow_util::Span { struct Fake; @@ -17,35 +19,44 @@ struct TypedCow : private Cow, public _cow_util::Span { template inline TypedCow(size_t sz, Args&&... args) : TypedCow(sz) { init_copy( T(std::forward(args)...) ); } - inline ~TypedCow() { uninit(); } - - inline void* area() { return Cow::area(); } - inline const void* area() const { return Cow::area(); } - inline size_t size() const override { return Cow::size() / sizeof(T); } + virtual inline ~TypedCow() { uninit(); } - inline T& operator[](size_t i) { if (i>=size()) throw "idx"; else return *reinterpret_cast(this->as_bytes() + (sizeof(T) * i)); } - inline const T& operator[](size_t i) const { if (i>=size()) throw "idx"; else return *reinterpret_cast(this->as_bytes() + (sizeof(T) * i)); } + inline Cow::Fake clone() const override { return Cow::clone(); } + inline Fake clone() const { return Fake(Cow::clone()); } + inline size_t size() const override { return Cow::size() / sizeof(T); } + protected: - // Should only be used for creating Fakes. Copies the refcounted pointer. - inline TypedCow(const TypedCow& copy) : Cow(copy.super) {} + inline void* area() override { return Cow::area(); } + inline const void* area() const override { return Cow::area(); } + //// Should only be used for creating Fakes. Copies the refcounted pointer. + //inline TypedCow(const TypedCow& copy) : Cow(copy.super) {} // UNSAFE: Placement-new's copys of `copy_from` into `0..size()` of this instance. inline void init_copy(const T& copy_from) { - unsigned char* bytes = this->as_bytes(); + T* ptr = _cow_util::Span::ptr(); for(size_t i=0;ias_bytes(); + T* ptr = _cow_util::Span::ptr(); for(size_t i=0;i(bytes + (sizeof(T)*i))->~T(); + (ptr+i)->~T(); } }; template struct TypedCow::Fake : private Cow::Fake, public _cow_util::Span { + Fake() = delete; + explicit inline Fake(Cow::Fake&& untyped) : Cow::Fake(untyped){} + inline Fake(const Fake& copy) : Fake(copy.Cow::Fake::clone()){} + inline Fake(Fake&& move) : Cow::Fake(std::move(move)) {} + inline ~Fake(){} + inline size_t size() const override { return Cow::Fake::size(); } + protected: + inline const void* area() const override { return Cow::Fake::area(); } + inline void* area() override { return Cow::Fake::area(); } }; diff --git a/src/test/main.cpp b/src/test/main.cpp index 8df8991..5379c46 100644 --- a/src/test/main.cpp +++ b/src/test/main.cpp @@ -147,7 +147,7 @@ namespace Tiling { template void print_slice(Slice memory) { - printf("slice: { %p, %lu (%lu bytes) }\n", memory.area(), memory.size(), memory.size_bytes()); + printf("slice: { %p, %lu (%lu bytes) }\n", memory.ptr(), memory.size(), memory.size_bytes()); } @@ -210,7 +210,7 @@ int main() Cow::Fake clone = real; printf("Fake size: %lu\n", clone.size()); - printf("Fake ptr: %p\n", clone.area()); + printf("Fake ptr: %p\n", clone.ptr()); read_fake(clone); write_fake(clone, "hello fake!");