From 9074cd80ef9c3d73c23f5f368a7f6d0dc2d83cb7 Mon Sep 17 00:00:00 2001
From: Mototroller <tolstokor@gmail.com>
Date: Sat, 25 Mar 2017 19:48:12 +0300
Subject: [PATCH] init BETA

---
 .gitmodules             |   3 +
 .travis.yml             |  32 +++++
 CMakeLists.txt          |  14 +++
 README.md               |   2 +-
 ax.core                 |   1 +
 include/preFIX.hpp      | 165 +++++++++++++++++++++++++
 include/preFIX_dict.hpp | 263 ++++++++++++++++++++++++++++++++++++++++
 tests/tests.cpp         | 117 ++++++++++++++++++
 8 files changed, 596 insertions(+), 1 deletion(-)
 create mode 100644 .gitmodules
 create mode 100644 .travis.yml
 create mode 100644 CMakeLists.txt
 create mode 160000 ax.core
 create mode 100644 include/preFIX.hpp
 create mode 100644 include/preFIX_dict.hpp
 create mode 100644 tests/tests.cpp

diff --git a/.gitmodules b/.gitmodules
new file mode 100644
index 0000000..d03b0c4
--- /dev/null
+++ b/.gitmodules
@@ -0,0 +1,3 @@
+[submodule "ax.core"]
+	path = ax.core
+	url = https://github.com/Mototroller/ax.core.git
diff --git a/.travis.yml b/.travis.yml
new file mode 100644
index 0000000..fa9889e
--- /dev/null
+++ b/.travis.yml
@@ -0,0 +1,32 @@
+sudo: required
+dist: precise
+language: cpp
+
+matrix:
+  include:
+    - compiler: gcc
+      addons:
+        apt:
+          sources:
+            - ubuntu-toolchain-r-test
+          packages:
+            - g++-5
+      env: COMPILER=g++-5
+    - compiler: clang
+      addons:
+        apt:
+          sources:
+            - ubuntu-toolchain-r-test
+            - llvm-toolchain-precise-3.7
+          packages:
+            - clang-3.7
+      env: COMPILER=clang++-3.7
+
+before_install:
+  - sudo apt-get update -qq
+
+script:
+  - mkdir build
+  - cd build
+  - cmake -DCMAKE_CXX_COMPILER=$COMPILER .. && make
+  - ./AX_PREFIX_TEST
diff --git a/CMakeLists.txt b/CMakeLists.txt
new file mode 100644
index 0000000..bfa2805
--- /dev/null
+++ b/CMakeLists.txt
@@ -0,0 +1,14 @@
+cmake_minimum_required (VERSION 2.8.7)
+project (AX_PREFIX_TEST)
+
+set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -std=c++11 -Wall -pedantic")
+
+set(CMAKE_CXX_FLAGS_DEBUG   "${CMAKE_CXX_FLAGS_DEBUG}   -O0 -g")
+set(CMAKE_CXX_FLAGS_RELEASE "${CMAKE_CXX_FLAGS_RELEASE} -O3 -march=native")
+
+set(SRC_LIST tests/tests.cpp)
+
+include_directories(${CMAKE_CURRENT_SOURCE_DIR} ax.core/include)
+include_directories(${PROJECT_NAME} include)
+
+add_executable(${PROJECT_NAME} ${SRC_LIST})
diff --git a/README.md b/README.md
index bfaa008..6221e52 100644
--- a/README.md
+++ b/README.md
@@ -1 +1 @@
-# preFIX
\ No newline at end of file
+# preFIX [![Build Status](https://travis-ci.org/Mototroller/preFIX.svg?branch=master)](https://travis-ci.org/Mototroller/preFIX)
\ No newline at end of file
diff --git a/ax.core b/ax.core
new file mode 160000
index 0000000..4b9841a
--- /dev/null
+++ b/ax.core
@@ -0,0 +1 @@
+Subproject commit 4b9841ab0159388a0ef120a2633f9ddab1261115
diff --git a/include/preFIX.hpp b/include/preFIX.hpp
new file mode 100644
index 0000000..99f0c50
--- /dev/null
+++ b/include/preFIX.hpp
@@ -0,0 +1,165 @@
+#pragma once
+
+#include <algorithm>
+#include <cstdint>
+#include <cstring>
+#include <iomanip>
+#include <limits>
+#include <sstream>
+#include <string>
+#include <type_traits>
+
+#define LOG_HEAD "[preFIX]: "
+
+namespace preFIX {
+
+using size_t = std::size_t;
+
+enum : char { SOH = 0x1 };
+
+/// Peplaces SOH inside string by given symbol ('|' by default)
+std::string replace_SOH(std::string str, char symbol = '|') {
+    std::replace(str.begin(), str.end(), char(SOH), symbol);
+    return str;
+}
+
+/*// Contains compile-time djb2 hash implementation
+namespace hash {
+    constexpr size_t djb2_impl(char const* str, size_t hash) {
+        return  *str == char{0} ? hash :
+                djb2_impl(str + 1, ((hash << 5) + hash) + *str);
+    }
+
+    constexpr size_t djb2(char const* str) {
+        return djb2_impl(str, 5381); }
+    
+    /// some_tpl<H("string")>
+    constexpr size_t H(char const* str) {
+        return djb2(str); }
+    
+    /// some_tpl<"string"__>
+    constexpr size_t operator ""__(char const* str, size_t) {
+        return H(str); }
+}
+
+namespace meta {
+    /// Concatenates two tuple-like classes
+    template <class U, class V>
+    struct tuple_concat;
+
+    template <
+        template <class...> class T,
+        class... Alist,
+        class... Blist
+    > struct tuple_concat<T<Alist...>, T<Blist...>> { using type = T<Alist..., Blist...>; };
+
+    template <typename U, typename V>
+    using tuple_concat_t = typename tuple_concat<U,V>::type;
+
+
+    /// Pushes type to tuple-like class
+    template <class Tuple, class T>
+    struct tuple_push;
+
+    template <
+        template <class...> class Tuple,
+        class... Args,
+        class T
+    > struct tuple_push<Tuple<Args...>,T> { using type = Tuple<Args..., T>; };
+
+    template <typename Tuple, typename T>
+    using tuple_push_t = typename tuple_push<Tuple,T>::type;
+}
+//*/
+
+/// Contains basic types arithmetics and mapping (FIX <=> native)
+namespace types {
+    
+    /// Default serializer: {ostringstream(dst) << value}
+    template <typename T>
+    struct sstream_serializer {
+        template <typename U>
+        static size_t serialize(char* dst, U&& value, char delimiter = SOH) {
+            std::ostringstream ss; ss << std::forward<U>(value);
+            std::string str = ss.str();
+            std::memcpy(dst, str.data(), str.size());
+            dst[str.size()] = delimiter;
+            return str.size() + 1;
+        }
+    };
+    
+    /// Default deserializer: {istringstream(src) >> value}
+    template <typename T>
+    struct sstream_deserializer {
+        template <typename U>
+        static size_t deserialize(char const* src, U& value, char delimiter = SOH) {
+            std::string str(src, static_cast<char const*>(std::strchr(src, delimiter)));
+            std::istringstream ss(str); ss >> value;
+            return str.size() + 1;
+        }
+    };
+    
+    /// Special serializer
+    template <size_t Width>
+    struct fixed_width_int_serializer {
+        template <typename U>
+        static size_t serialize(char* dst, U&& value, char delimiter = SOH) {
+            std::ostringstream ss;
+            ss << std::setfill('0') << std::setw(Width) << std::forward<U>(value);
+            std::string str = ss.str();
+            std::memcpy(dst, str.data(), str.size());
+            dst[str.size()] = delimiter;
+            return str.size() + 1;
+        }
+    };
+    
+    template <
+        typename T,
+        class serializer    = sstream_serializer<T>,
+        class deserializer  = sstream_deserializer<T>
+    >
+    struct base_t : serializer, deserializer {
+        using underlying_type = T;
+        underlying_type value;
+        
+        base_t() = default;
+        explicit base_t(underlying_type const& v) : value(v) {}
+        
+        template <typename U>
+        base_t& operator=(U&& v) {
+            value = std::forward<U>(v);
+            return *this;
+        }
+        
+        using serializer::serialize;
+        using deserializer::deserialize;
+        
+        size_t serialize(char* dst) const {
+            return serialize(dst, value); }
+        
+        size_t deserialize(char const* src) {
+            return deserialize(src, value); }
+    };
+    
+    using Int       = base_t<size_t>;
+    using Float     = base_t<double>;
+    using Char      = base_t<char>;
+    using String    = base_t<std::string>;
+    
+    template <size_t Width>
+    using Fixed = base_t<int, fixed_width_int_serializer<Width>>;
+    
+    /// Writes preamble: "TAG=", @returns populated size
+    size_t serialize_tag(char* dst, int tag) {
+        return types::Int::serialize(dst, tag, '='); }
+    
+    /// Parses preamble: "TAG=" => tag, @returns read size
+    size_t deserialize_tag(char const* src, int& tag) {
+        return types::Int::deserialize(src, tag, '='); }
+}
+
+
+
+} // preFIX
+
+#undef LOG_HEAD
diff --git a/include/preFIX_dict.hpp b/include/preFIX_dict.hpp
new file mode 100644
index 0000000..3d364fc
--- /dev/null
+++ b/include/preFIX_dict.hpp
@@ -0,0 +1,263 @@
+#pragma once
+
+#include <array>
+#include <tuple>
+#include <unordered_map>
+
+#include <preFIX.hpp>
+
+namespace preFIX {
+
+namespace dict {
+    
+    using namespace preFIX::types;
+    
+    namespace details {
+        /// Contains index of type inside tuple-like class
+        template <typename tuple, typename T>
+        struct idx_of;
+        
+        template <template <class...> class tuple, typename T>
+        struct idx_of<tuple<>, T> : std::integral_constant<size_t, 0> {
+            static_assert(!sizeof(T), "can't find type"); };
+        
+        template <template <class...> class tuple, typename T, typename... V>
+        struct idx_of<tuple<T, V...>, T> : std::integral_constant<size_t, 0> {};
+        
+        template <template <class...> class tuple, typename T, typename U, typename... V>
+        struct idx_of<tuple<U, V...>, T> : std::integral_constant<size_t, (1 + idx_of<tuple<V...>, T>::value)> {};
+        
+        
+        /// Recursively calls "serialize" for every tuple element
+        template <size_t N = 0, typename Tuple>
+        auto serialize_tuple(char* dst, Tuple const& t) ->
+        typename std::enable_if<(N == std::tuple_size<Tuple>::value), size_t>::type {
+            return 0; }
+        
+        template <size_t N = 0, typename Tuple>
+        auto serialize_tuple(char* dst, Tuple const& t) ->
+        typename std::enable_if<(N != std::tuple_size<Tuple>::value), size_t>::type {
+            auto written = std::get<N>(t).serialize(dst); // member func
+            return written + serialize_tuple<(N+1)>(dst + written, t);
+        }
+    }
+    
+    /// Main tuple-like entity, contains fields to be serialized
+    template <typename... T>
+    class msg_t;
+    
+    /// Base class for all plain fields
+    template <int tag_value, typename FIX_type>
+    struct field_base {
+        using type = FIX_type;
+        enum : int { tag = tag_value };
+        
+        type data;
+        bool present = false;
+        
+        /// Performs standard serialization: "TAG=VALUE<SOH>", @returns written size
+        size_t serialize(char* dst) const {
+            if(present) {
+                size_t written = 0, chunk = 0;
+                chunk = types::serialize_tag(dst, tag);
+                written += chunk;
+                dst     += chunk;
+                return written + data.serialize(dst);
+            }
+            return 0;
+        }
+    };
+    
+    /// Base class for repetaing groups
+    template <int tag_value, size_t Size, typename... Fields>
+    struct group_base {
+        using atom_type = msg_t<Fields...>;
+        using type = std::array<atom_type, Size>;
+        enum : int { tag = tag_value };
+        
+        type data;
+        bool present = false;
+        
+        size_t serialize(char* dst) const {
+            if(present) {
+                int group_size = 0;
+                for(auto const& msg : data)
+                    group_size += msg.is_group_presented();
+                
+                if(group_size > 0) {
+                    size_t written = 0, chunk = 0;
+                    
+                    chunk = types::serialize_tag(dst, tag);
+                    written += chunk;
+                    dst     += chunk;
+                    
+                    chunk = types::Int::serialize(dst, int(group_size));
+                    written += chunk;
+                    dst     += chunk;
+                    
+                    for(auto const& msg : data) {
+                        chunk = msg.serialize(dst);
+                        written += chunk;
+                        dst     += chunk;
+                    }
+                    
+                    return written;
+                }
+            }
+            return 0;
+        }
+        
+        size_t max_size() const {
+            return data.size(); }
+        
+        atom_type const& operator[](size_t idx) const {
+            return data[idx]; }
+        
+        atom_type& operator[](size_t idx) {
+            return data[idx]; }
+    };
+    
+    template <typename... T>
+    class msg_t {
+    private:
+        using tuple_t = std::tuple<T...>;
+        tuple_t fields_;
+        
+        template <typename U, size_t idx = details::idx_of<tuple_t, U>::value>
+        inline auto get_field() -> decltype(std::get<idx>(fields_)) {
+            return std::get<idx>(fields_); }
+        
+        template <typename U, size_t idx = details::idx_of<tuple_t, U>::value>
+        inline auto get_field() const -> decltype(std::get<idx>(fields_)) {
+            return std::get<idx>(fields_); }
+        
+    public:
+        /// For groups: @returns if first field of group was set
+        bool is_group_presented() const {
+            return std::get<0>(fields_).present; }
+        
+        /// Assigns given value to field's data
+        template <typename U, typename Arg>
+        void set(Arg&& arg) {
+            auto& field = get_field<U>();
+            field.data = std::forward<Arg>(arg);
+            field.present = true;
+        }
+        
+        /// Returns mutable reference to underlying field/group
+        template <typename U>
+        U& set() {
+            auto& field = get_field<U>();
+            field.present = true;
+            return field;
+        }
+        
+        /// Set field to be omitted during serialization
+        template <typename U>
+        void omit() {
+            get_field<U>().present = false; }
+        
+        /// Extracts value from field
+        template <typename U, typename Arg>
+        void get(Arg&& arg) const {
+            std::forward<Arg>(arg) = get_field<U>().data; }
+        
+        /// Returns constant reference to underlying field/group
+        template <typename U>
+        U const& get() const {
+            return get_field<U>(); }
+        
+        /// Recursively serializes fields to given buffer
+        size_t serialize(char* dst) const {
+            return details::serialize_tuple(dst, fields_); }
+    };
+    
+    struct BeginString  : field_base<8,     String      >{};
+    struct Length       : field_base<9,     Fixed<5>    >{};
+    struct CheckSum     : field_base<10,    Fixed<3>    >{};
+    
+    template <typename H, typename Msg>
+    size_t serialize_body(char* dst, H& header, Msg const& msg) {
+        char* b_ptr = dst;
+        size_t written = 0, chunk = 0;
+        header.template set<Length>(0);
+        
+        chunk = header.serialize(dst);
+        written += chunk;
+        dst     += chunk;
+        
+        chunk = msg.serialize(dst);
+        written += chunk;
+        dst     += chunk;
+        
+        auto l_ptr = std::find(b_ptr, dst, char(SOH)) + 1;
+        auto r_ptr = std::find(l_ptr, dst, char(SOH)) + 1;
+        
+        header.template set<Length>(written - (r_ptr - b_ptr));
+        header.template get<Length>().serialize(l_ptr);
+        
+        return written;
+    }
+    
+    size_t serialize_chksum(char* base, size_t length) {
+        int sum = 0;
+        for(size_t i = 0; i < length; ++i)
+            sum += int(base[i]);
+        
+        using CS = msg_t<CheckSum>;
+        CS cs; cs.set<CheckSum>(sum % 256);
+        return cs.serialize(base + length);
+    }
+
+} // dict
+    
+} // preFIX
+
+/// Example of FIX-dictionary
+namespace test_dict {
+    using namespace preFIX::types; // isn't necessary
+    using namespace preFIX::dict;
+    
+    
+    struct MsgType      : field_base<35,    String> {};
+    struct SenderCompID : field_base<49,    String> {};
+    struct TargetCompID : field_base<56,    String> {};
+    struct MsgSeqNum    : field_base<34,    Int>    {};
+    
+    struct Account      : field_base<1,     String> {};
+    struct EncryptMethod: field_base<98,    Int>    {};
+    struct HeartBtInt   : field_base<108,   Int>    {};
+    struct Password     : field_base<554,   String> {};
+    
+    struct ClOrdID      : field_base<11,    String> {};
+    struct PartyID      : field_base<448,   String> {};
+    struct PartyIDSource: field_base<447,   Char>   {};
+    struct PartyRole    : field_base<452,   Int>    {};
+    struct Price        : field_base<44,    Float>  {};
+    struct Side         : field_base<54,    Char>   {};
+    
+    
+    struct NoPartyID : group_base<453, 3,
+        PartyID,
+        PartyIDSource,
+        PartyRole
+    > {};
+    
+    using Header = msg_t<
+        BeginString,
+        Length,
+        MsgType,
+        SenderCompID,
+        TargetCompID,
+        MsgSeqNum
+    >;
+    
+    using NewOrderSingle = msg_t<
+        ClOrdID,
+        Account,
+        NoPartyID,
+        Price,
+        Side
+    >;
+
+} // test_dict
diff --git a/tests/tests.cpp b/tests/tests.cpp
new file mode 100644
index 0000000..5367849
--- /dev/null
+++ b/tests/tests.cpp
@@ -0,0 +1,117 @@
+#include <ax.hpp>
+
+#include <algorithm>
+#include <array>
+#include <cmath>
+#include <list>
+#include <map>
+#include <memory>
+#include <fstream>
+#include <string>
+#include <tuple>
+#include <vector>
+
+#include <preFIX.hpp>
+#include <preFIX_dict.hpp>
+
+using namespace ax;
+
+int main() {
+    using namespace preFIX;
+    using namespace preFIX::types;
+    
+    char buf[1_KIB] = {0};
+    std::string str;
+    
+    auto clrbuf = [&buf]{ std::memset(buf, 0x0, sizeof(buf)); };
+    
+    {
+        Int i;
+        
+        i.value = 13;
+        Int::serialize(buf, i.value);
+        str = buf;
+        str = str.substr(0, str.size() - 1);
+        stdcout(str);
+        
+        int x;
+        Int::deserialize(buf, x);
+        stdcout(x);
+    }
+    
+    clrbuf();
+    
+    {
+        String s;
+        
+        s.value = "DHKDHK//HKHKHHJ";
+        String::serialize(buf, s.value);
+        str = buf;
+        str = str.substr(0, str.size() - 1);
+        stdcout(str);
+        
+        std::string x;
+        String::deserialize(buf, x);
+        stdcout(x);
+        
+        String::deserialize("abcde9823|", x, '|');
+        stdcout(x);
+    }
+    
+    clrbuf();
+    
+    {
+        using namespace test_dict;
+        
+        Header header;
+        stdcout(details::idx_of<Header, BeginString>::value);
+        stdcout(details::idx_of<Header, Length>::value);
+        stdcout(details::idx_of<Header, MsgType>::value);
+        
+        header.set<MsgType>(String("A"));
+        header.set<MsgType>("A");
+        
+        String s;
+        header.get<MsgType>(s);
+        stdcout(s.value);
+        
+        //header.set<Account>("FIX.4.4");
+        header.set<BeginString>("FIX.4.4");
+        header.set<SenderCompID>("MYCOMP");
+        header.set<TargetCompID>("THEIRTCOMP");
+        //header.omit<Length>();
+        //header.set<Length>(0);
+        
+        header.serialize(buf);
+        stdcout(replace_SOH(buf));
+        
+        clrbuf();
+        
+        NewOrderSingle nos;
+        nos.set<ClOrdID>("123ABC");
+        nos.set<Account>("ololo//OLOLO");
+        nos.set<Price>(66.6625);
+        nos.set<Side>('2');
+        
+        //NoPartyID parties;
+        auto& parties = nos.set<NoPartyID>();
+        parties[0].set<PartyID>("USER");
+        parties[1].set<PartyID>("FIRM");
+        
+        nos.serialize(buf);
+        stdcout(replace_SOH(buf));
+        
+        clrbuf();
+        
+        auto written = serialize_body(buf, header, nos);
+        written += serialize_chksum(buf, written);
+        stdcout(replace_SOH(buf));
+        stdcout(written);
+    }
+    
+    clrbuf();
+    
+    {
+        
+    }
+}
\ No newline at end of file