1 files changed, 20 insertions, 14 deletions

diff --git a/src/codec/stream_value.h b/src/codec/stream_value.h
index df1334b..09203cb 100644
--- a/src/codec/stream_value.h
+++ b/src/codec/stream_value.h
@@ -1,7 +1,9 @@
 #pragma once
 
-#include "buffer.h"
-#include "error.h"
+#include "schema.h"
+
+#include <forstio/core/buffer.h>
+#include <forstio/core/error.h>
 
 #include <cstdint>
 #include <cstring>
@@ -13,44 +15,48 @@ namespace saw {
  * platform independent. So it does not matter if the memory layout is
  * little endian or big endian
  */
-template <typename T, size_t N> class ShiftStreamValue {
+template<typename T> class shift_stream_value {
+	static_assert(always_false<T>, "Shift Stream Value only supports Primitives");
+};
+
+template <typename T, size_t N> class shift_stream_value<schema::Primitive<T,N>> {
 public:
 	inline static error_or<void> decode(typename native_data_type<schema::Primitive<T,N>>::type &val, buffer &buff) {
-		if (buff.read_composite_length() < sizeof(T)) {
+		if (buff.read_composite_length() < N) {
 			return make_error<err::buffer_exhausted>();
 		}
 
 		typename native_data_type<schema::Primitive<schema::UnsignedInteger,N>>::type raw = 0;
 
-		for (size_t i = 0; i < sizeof(T); ++i) {
-			raw |= (static_cast<uint64_t>(buff.read(i)) << (i * 8));
+		for (size_t i = 0; i < N; ++i) {
+			raw |= (static_cast<typename native_data_type<schema::Primitive<T,N>>::type>(buff.read(i)) << (i * 8));
 		}
 
-		memcpy(&val, &raw, sizeof(T));
-		buff.read_advance(sizeof(T));
+		memcpy(&val, &raw, N);
+		buff.read_advance(N);
 
 		return void_t{};
 	}
 
 	inline static error_or<void> encode(const typename native_data_type<schema::Primitive<T,N>>::type &val, buffer &buff) {
-		error err = buff.write_require_length(sizeof(T));
+		error err = buff.write_require_length(N);
 		if (err.failed()) {
 			return err;
 		}
 
 		typename native_data_type<schema::Primitive<schema::UnsignedInteger,N>>::type raw{};
-		memcpy(&raw, &val, sizeof(T));
+		memcpy(&raw, &val, N);
 
-		for (size_t i = 0; i < sizeof(T); ++i) {
-			buffer.write(i) = raw >> (i * 8);
+		for (size_t i = 0; i < N; ++i) {
+			buff.write(i) = raw >> (i * 8);
 		}
 
-		buffer.write_advance(sizeof(T));
+		buff.write_advance(N);
 
 		return void_t{};
 	}
 
-	inline static size_t size() const { return N; }
+	inline static size_t size() { return N; }
 };
 
 template <typename T> using stream_value = shift_stream_value<T>;