diff options
Diffstat (limited to 'src/dpl/core/include')
-rw-r--r-- | src/dpl/core/include/cchecker/dpl/serialization.h | 496 |
1 files changed, 496 insertions, 0 deletions
diff --git a/src/dpl/core/include/cchecker/dpl/serialization.h b/src/dpl/core/include/cchecker/dpl/serialization.h new file mode 100644 index 0000000..5628350 --- /dev/null +++ b/src/dpl/core/include/cchecker/dpl/serialization.h @@ -0,0 +1,496 @@ +/* + * Copyright (c) 2011-2015 Samsung Electronics Co., Ltd All Rights Reserved + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +/** + * @file serialization.h + * @author Tomasz Swierczek (t.swierczek@samsung.com) + * @version 1.0 + * @brief Interfaces and templates used for data serialization. + */ +#ifndef CCHECKER_SERIALIZATION_H +#define CCHECKER_SERIALIZATION_H + +#include <stdint.h> + +#include <string> +#include <vector> +#include <list> +#include <map> +#include <memory> + +namespace CCHECKER { +// Abstract data stream buffer +class IStream +{ + public: + virtual void Read(size_t num, void * bytes) = 0; + virtual void Write(size_t num, const void * bytes) = 0; + virtual ~IStream(){} +}; + +// Serializable interface +class ISerializable +{ + public: + /* ISerializable(){}; + * ISerializable(IStream&){}; */ + virtual void Serialize(IStream &) const = 0; + virtual ~ISerializable(){} +}; + +struct Serialization { + // serialization + // normal functions + + // ISerializable objects + static void Serialize(IStream& stream, const ISerializable& object) + { + object.Serialize(stream); + } + + static void Serialize(IStream& stream, const ISerializable* const object) + { + object->Serialize(stream); + } + + // char + static void Serialize(IStream& stream, const char value) + { + stream.Write(sizeof(value), &value); + } + static void Serialize(IStream& stream, const char* const value) + { + stream.Write(sizeof(*value), value); + } + + // unsigned char + static void Serialize(IStream& stream, const unsigned char value) + { + stream.Write(sizeof(value), &value); + } + static void Serialize(IStream& stream, const unsigned char* const value) + { + stream.Write(sizeof(*value), value); + } + + // unsigned int32 + static void Serialize(IStream& stream, const uint32_t value) + { + stream.Write(sizeof(value), &value); + } + static void Serialize(IStream& stream, const uint32_t* const value) + { + stream.Write(sizeof(*value), value); + } + + // int32 + static void Serialize(IStream& stream, const int32_t value) + { + stream.Write(sizeof(value), &value); + } + static void Serialize(IStream& stream, const int32_t* const value) + { + stream.Write(sizeof(*value), value); + } + + // unsigned int64 + static void Serialize(IStream& stream, const uint64_t value) + { + stream.Write(sizeof(value), &value); + } + static void Serialize(IStream& stream, const uint64_t* const value) + { + stream.Write(sizeof(*value), value); + } + + // int64 + static void Serialize(IStream& stream, const int64_t value) + { + stream.Write(sizeof(value), &value); + } + static void Serialize(IStream& stream, const int64_t* const value) + { + stream.Write(sizeof(*value), value); + } + + // bool + static void Serialize(IStream& stream, const bool value) + { + stream.Write(sizeof(value), &value); + } + static void Serialize(IStream& stream, const bool* const value) + { + stream.Write(sizeof(*value), value); + } + + // std::string + template <typename T, typename R, typename A> + static void Serialize(IStream& stream, const std::basic_string<T,R,A>& str) + { + int length = str.size(); + stream.Write(sizeof(length), &length); + stream.Write(length*sizeof(T), str.data()); + } + + template<typename T, typename R, typename A> + static void Serialize(IStream& stream, const std::basic_string<T,R,A>* const str) + { + int length = str->size(); + stream.Write(sizeof(length), &length); + stream.Write(length*sizeof(T), str->data()); + } + + // STL templates + + // std::list + template <typename T> + static void Serialize(IStream& stream, const std::list<T>& list) + { + int length = list.size(); + stream.Write(sizeof(length), &length); + for (typename std::list<T>::const_iterator list_iter = list.begin(); + list_iter != list.end(); list_iter++) + { + Serialize(stream, *list_iter); + } + } + template <typename T> + static void Serialize(IStream& stream, const std::list<T>* const list) + { + Serialize(stream, *list); + } + + // RawBuffer + template <typename A> + static void Serialize(IStream& stream, const std::vector<unsigned char, A>& vec) + { + int length = vec.size(); + stream.Write(sizeof(length), &length); + stream.Write(length, vec.data()); + } + + template <typename A> + static void Serialize(IStream& stream, const std::vector<unsigned char, A>* const vec) + { + Serialize(stream, *vec); + } + + // std::vector + template <typename T, typename A> + static void Serialize(IStream& stream, const std::vector<T, A>& vec) + { + int length = vec.size(); + stream.Write(sizeof(length), &length); + for (const auto &i : vec) + { + Serialize(stream, i); + } + } + template <typename T, typename A> + static void Serialize(IStream& stream, const std::vector<T, A>* const vec) + { + Serialize(stream, *vec); + } + + // std::pair + template <typename A, typename B> + static void Serialize(IStream& stream, const std::pair<A, B>& p) + { + Serialize(stream, p.first); + Serialize(stream, p.second); + } + template <typename A, typename B> + static void Serialize(IStream& stream, const std::pair<A, B>* const p) + { + Serialize(stream, *p); + } + + // std::map + template <typename K, typename T> + static void Serialize(IStream& stream, const std::map<K, T>& map) + { + int length = map.size(); + stream.Write(sizeof(length), &length); + typename std::map<K, T>::const_iterator it; + for (it = map.begin(); it != map.end(); ++it) { + Serialize(stream, (*it).first); + Serialize(stream, (*it).second); + } + } + template <typename K, typename T> + static void Serialize(IStream& stream, const std::map<K, T>* const map) + { + Serialize(stream, *map); + } + + // std::unique_ptr + template <typename T> + static void Serialize(IStream& stream, const std::unique_ptr<T>& p) + { + Serialize(stream, *p); + } + +}; // struct Serialization + +struct Deserialization { + // deserialization + // normal functions + + // ISerializable objects + // T instead of ISerializable is needed to call proper constructor + template <typename T> + static void Deserialize(IStream& stream, T& object) + { + object = T(stream); + } + template <typename T> + static void Deserialize(IStream& stream, T*& object) + { + object = new T(stream); + } + + // char + static void Deserialize(IStream& stream, char& value) + { + stream.Read(sizeof(value), &value); + } + static void Deserialize(IStream& stream, char*& value) + { + value = new char; + stream.Read(sizeof(*value), value); + } + + // unsigned char + static void Deserialize(IStream& stream, unsigned char& value) + { + stream.Read(sizeof(value), &value); + } + static void Deserialize(IStream& stream, unsigned char*& value) + { + value = new unsigned char; + stream.Read(sizeof(*value), value); + } + + // unsigned int32 + static void Deserialize(IStream& stream, uint32_t& value) + { + stream.Read(sizeof(value), &value); + } + static void Deserialize(IStream& stream, uint32_t*& value) + { + value = new uint32_t; + stream.Read(sizeof(*value), value); + } + + // int32 + static void Deserialize(IStream& stream, int32_t& value) + { + stream.Read(sizeof(value), &value); + } + static void Deserialize(IStream& stream, int32_t*& value) + { + value = new int32_t; + stream.Read(sizeof(*value), value); + } + + // unsigned int64 + static void Deserialize(IStream& stream, uint64_t& value) + { + stream.Read(sizeof(value), &value); + } + static void Deserialize(IStream& stream, uint64_t*& value) + { + value = new uint64_t; + stream.Read(sizeof(*value), value); + } + + // int64 + static void Deserialize(IStream& stream, int64_t& value) + { + stream.Read(sizeof(value), &value); + } + static void Deserialize(IStream& stream, int64_t*& value) + { + value = new int64_t; + stream.Read(sizeof(*value), value); + } + + // bool + static void Deserialize(IStream& stream, bool& value) + { + stream.Read(sizeof(value), &value); + } + static void Deserialize(IStream& stream, bool*& value) + { + value = new bool; + stream.Read(sizeof(*value), value); + } + + template <typename T, typename R, typename A> + static void Deserialize(IStream& stream, std::basic_string<T,R,A>& str) + { + int length; + stream.Read(sizeof(length), &length); + std::vector<T> buf(length); + stream.Read(length*sizeof(T), buf.data()); + str = std::basic_string<T,R,A>(buf.data(), buf.data()+length); + } + + template <typename T, typename R, typename A> + static void Deserialize(IStream& stream, std::basic_string<T,R,A>*& str) + { + int length; + stream.Read(sizeof(length), &length); + std::vector<T> buf(length); + stream.Read(length*sizeof(T), buf.data()); + str = new std::basic_string<T,R,A>(buf.data(), buf.data()+length); + } + + // STL templates + + // std::list + template <typename T> + static void Deserialize(IStream& stream, std::list<T>& list) + { + int length; + stream.Read(sizeof(length), &length); + for (int i = 0; i < length; ++i) { + T obj; + Deserialize(stream, obj); + list.push_back(std::move(obj)); + } + } + template <typename T> + static void Deserialize(IStream& stream, std::list<T>*& list) + { + list = new std::list<T>; + Deserialize(stream, *list); + } + + // RawBuffer + template <typename A> + static void Deserialize(IStream& stream, std::vector<unsigned char, A>& vec) + { + int length; + stream.Read(sizeof(length), &length); + vec.resize(length); + stream.Read(length, vec.data()); + } + + template <typename A> + static void Deserialize(IStream& stream, std::vector<unsigned char, A>*& vec) + { + vec = new std::vector<unsigned char,A>; + Deserialize(stream, *vec); + } + + // std::vector + template <typename T, typename A> + static void Deserialize(IStream& stream, std::vector<T,A>& vec) + { + int length; + stream.Read(sizeof(length), &length); + for (int i = 0; i < length; ++i) { + T obj; + Deserialize(stream, obj); + vec.push_back(std::move(obj)); + } + } + template <typename T, typename A> + static void Deserialize(IStream& stream, std::vector<T,A>*& vec) + { + vec = new std::vector<T,A>; + Deserialize(stream, *vec); + } + + // std::pair + template <typename A, typename B> + static void Deserialize(IStream& stream, std::pair<A, B>& p) + { + Deserialize(stream, p.first); + Deserialize(stream, p.second); + } + template <typename A, typename B> + static void Deserialize(IStream& stream, std::pair<A, B>*& p) + { + p = new std::pair<A, B>; + Deserialize(stream, *p); + } + + // std::map + template <typename K, typename T> + static void Deserialize(IStream& stream, std::map<K, T>& map) + { + int length; + stream.Read(sizeof(length), &length); + for (int i = 0; i < length; ++i) { + K key; + T obj; + Deserialize(stream, key); + Deserialize(stream, obj); + map[key] = std::move(obj); + } + } + template <typename K, typename T> + static void Deserialize(IStream& stream, std::map<K, T>*& map) + { + map = new std::map<K, T>; + Deserialize(stream, *map); + } +}; // struct Deserialization + +// generic serialization +template <typename... Args> +struct Serializer; + +template <typename First, typename... Args> +struct Serializer<First, Args...> : public Serializer<Args...> { + static void Serialize(IStream& stream, const First& f, const Args&... args) { + Serialization::Serialize(stream, f); + Serializer<Args...>::Serialize(stream, args...); + } +}; + +// end of recursion +template <> +struct Serializer<> { + static void Serialize(IStream&) { + return; + } +}; + +// generic deserialization +template <typename... Args> +struct Deserializer; + +template <typename First, typename... Args> +struct Deserializer<First, Args...> : public Deserializer<Args...> { + static void Deserialize(IStream& stream, First& f, Args&... args) { + Deserialization::Deserialize(stream, f); + Deserializer<Args...>::Deserialize(stream, args...); + } +}; + +// end of recursion +template <> +struct Deserializer<> { + static void Deserialize(IStream&) { + return; + } +}; + +} // CCHECKER + +#endif // CCHECKER_SERIALIZATION_H |