Auto input format guessing (#63)

Author: mj-xmr

src/lib-base/src/TicksFormat.cpp

@@ -0,0 +1 @@
+#include "TicksFormat.h"

src/lib-base/src/TicksFormat.h

@@ -0,0 +1,12 @@
+#ifndef TICKSFORMATS_H
+#define TICKSFORMATS_H
+
+enum class TicksFormat
+{
+    FMT_FX,
+    FMT_ORDERED_SERIES,
+    FMT_TIMESTAMP_VALUE,
+    FMT_UNKNOWN
+};
+
+#endif // TICKSFORMATS_H

src/lib-base/src/TicksFormatGuesser.cpp

@@ -0,0 +1,45 @@
+#include "TicksFormatGuesser.h"
+
+#include <Util/CoutBuf.hpp>
+#include <Util/Tokenizer.hpp>
+
+using namespace EnjoLib;
+
+TicksFormatGuesser::TicksFormatGuesser(){}
+TicksFormatGuesser::~TicksFormatGuesser(){}
+
+TicksFormat TicksFormatGuesser::Run(const VecStr & lines) const
+{
+    const Str & line = lines.at(1); // It's safer to assume that the 1st (index = 0) line is the header
+
+    const Str delims = ",";  // Possibility to extend by other delims
+    const char delim = delims.at(0);
+    return Run(line, delim);
+}
+
+TicksFormat TicksFormatGuesser::Run(const EnjoLib::Str & line, const char delim) const
+{
+    const Tokenizer tok;
+    const VecStr & tokens = tok.Tokenize(line, delim);
+    const int len = tokens.size();
+    ELO
+    LOG << "TicksFormatGuesser: size = " << len << ", line = " << line << " ";
+    if (len == 1)
+    {
+        LOG << "Ordered series\n";
+        return TicksFormat::FMT_ORDERED_SERIES;
+    }
+    if (len == 2)
+    {
+        LOG << "Timestamp value\n";
+        return TicksFormat::FMT_TIMESTAMP_VALUE;
+    }
+    if (len == 8)
+    {
+        LOG << "Timestamp OHLC\n";
+        return TicksFormat::FMT_FX;
+    }
+
+    LOG << "Unknown!\n";
+    return TicksFormat::FMT_UNKNOWN;
+}

src/lib-base/src/TicksFormatGuesser.h

@@ -0,0 +1,23 @@
+#ifndef TICKSFORMATGUESSER_H
+#define TICKSFORMATGUESSER_H
+
+#include "TicksFormat.h"
+#include <Util/Str.hpp>
+#include "typesStr.h"
+
+class TicksFormatGuesser
+{
+    public:
+        TicksFormatGuesser();
+        virtual ~TicksFormatGuesser();
+
+        TicksFormat Run(const VecStr & lines) const;
+        TicksFormat Run(const EnjoLib::Str & line, const char delim) const;
+
+    protected:
+
+
+    private:
+};
+
+#endif // TICKSFORMATGUESSER_H

src/lib-base/src/TicksProviderAdaptive.cpp

@@ -0,0 +1,47 @@
+#include "TicksProviderAdaptive.h"
+
+#include "TicksFormat.h"
+#include "TicksProviderFake.h"
+#include "TicksProviderXMR.h"
+#include "TicksProviderOrderedSeries.h"
+#include "Ticks.h"
+#include "TradeUtil.h"
+#include "TicksFormatGuesser.h"
+
+#include <Ios/Osstream.hpp>
+#include <Util/Str.hpp>
+#include <Util/Tokenizer.hpp>
+//#include <Template/LoopThreadedT
+
+#include <Util/Str.hpp>
+#include <Util/Except.hpp>
+
+using namespace EnjoLib;
+
+TicksProviderAdaptive:: TicksProviderAdaptive(){}
+TicksProviderAdaptive::~TicksProviderAdaptive(){}
+
+CorPtr<TicksProviderBinary> TicksProviderAdaptive::Create(const TicksFormat & format) const
+{
+    switch (format)
+    {
+    case TicksFormat::FMT_FX:
+        return CorPtr<TicksProviderBinary>(new TicksProviderBinary());
+    case TicksFormat::FMT_ORDERED_SERIES:
+        return CorPtr<TicksProviderBinary>(new TicksProviderOrderedSeries());
+    case TicksFormat::FMT_TIMESTAMP_VALUE:
+        return CorPtr<TicksProviderBinary>(new TicksProviderXMR());
+    case TicksFormat::FMT_UNKNOWN:
+        break;
+    }
+    throw EnjoLib::ExceptNotImpl("TicksProviderAdaptive::Create(): Not implemented type");
+}
+
+VecStr TicksProviderAdaptive::Convert(const VecStr & raw) const
+{
+    const TicksFormatGuesser guesser;
+    const TicksFormat & format = guesser.Run(raw);
+    const CorPtr<TicksProviderBinary> provider = Create(format);
+
+    return provider->Convert(raw);
+}

src/lib-base/src/TicksProviderAdaptive.h

@@ -0,0 +1,21 @@
+#ifndef TICKSPROVIDERADAPTIVE_H
+#define TICKSPROVIDERADAPTIVE_H
+
+#include <TicksProviderBinary.h>
+
+enum class TicksFormat;
+
+class TicksProviderAdaptive : public TicksProviderBinary
+{
+    public:
+        TicksProviderAdaptive();
+        virtual ~TicksProviderAdaptive();
+
+    protected:
+        CorPtr<TicksProviderBinary> Create(const TicksFormat & format) const;
+        VecStr Convert(const VecStr & raw) const override;
+
+    private:
+};
+
+#endif // TICKSPROVIDERADAPTIVE_H

src/lib-base/src/TicksProviderAdaptiveFake.cpp

@@ -0,0 +1,16 @@
+#include "TicksProviderAdaptiveFake.h"
+
+#include "TicksProviderFake.h"
+
+TicksProviderAdaptiveFake::TicksProviderAdaptiveFake(){}
+TicksProviderAdaptiveFake::~TicksProviderAdaptiveFake(){}
+
+
+CorPtr<ITicks> TicksProviderAdaptiveFake::GetTicks(const EnjoLib::Str & symbolName, const ConfigSym * confSym) const
+{
+    return CorPtr<ITicks>(TicksProviderFake().GetTicks(symbolName, confSym).release());
+}
+CorPtr<ITicks> TicksProviderAdaptiveFake::GetPeriod(const EnjoLib::Str & symbolName, const EnjoLib::Str & periodName) const
+{
+    return CorPtr<ITicks>(TicksProviderFake().GetPeriod(symbolName, periodName).release());
+}

src/lib-base/src/TicksProviderAdaptiveFake.h

@@ -0,0 +1,21 @@
+#ifndef TICKSPROVIDERADAPTIVEFAKE_H
+#define TICKSPROVIDERADAPTIVEFAKE_H
+
+#include <ITicksProvider.h>
+
+
+class TicksProviderAdaptiveFake : public ITicksProvider
+{
+    public:
+        TicksProviderAdaptiveFake();
+        virtual ~TicksProviderAdaptiveFake();
+
+        CorPtr<ITicks> GetTicks(const EnjoLib::Str & symbolName, const ConfigSym * confSym = nullptr) const override;
+        CorPtr<ITicks> GetPeriod(const EnjoLib::Str & symbolName, const EnjoLib::Str & periodName) const override;
+
+    protected:
+
+    private:
+};
+
+#endif // TICKSPROVIDERADAPTIVEFAKE_H

src/lib-base/src/TicksProviderBinary.h

@@ -16,8 +16,10 @@ class TicksProviderBinary : public ITicksProvider
         CorPtr<ITicks> GetTicks(const EnjoLib::Str & symbol, const ConfigSym * confSym = nullptr) const override;
         CorPtr<ITicks> GetPeriod(const EnjoLib::Str & symbolName, const EnjoLib::Str & periodName) const override;
 
-    protected:
         virtual VecStr Convert(const VecStr & lines) const;
+
+    protected:
+
     private:
         CorPtr<ITicks> StoreOrRestore(const EnjoLib::Str & symbol, const EnjoLib::Str & fileName) const;
         void Archive(const EnjoLib::Str & symbol, const Ticks & t) const;

src/lib-base/src/TicksProviderFactory.cpp

@@ -8,31 +8,30 @@
 #include "TicksProviderXMR.h"
 #include "TicksProviderFake.h"
 #include "TicksProviderGenerated.h"
+#include "TicksProviderAdaptive.h"
+#include "TicksProviderAdaptiveFake.h"
 
-TickProviderFactory::TickProviderFactory()
-{
-    //ctor
-}
-
-TickProviderFactory::~TickProviderFactory()
-{
-    //dtor
-}
+TickProviderFactory::TickProviderFactory(){}
+TickProviderFactory::~TickProviderFactory(){}
 
-Corrade::Containers::Pointer<ITicksProvider> TickProviderFactory::Create(TickProviderType type) const
+CorPtr<ITicksProvider> TickProviderFactory::Create(TickProviderType type) const
 {
     switch (type)
     {
     case TickProviderType::ARCHIVER:
-        return Corrade::Containers::Pointer<ITicksProvider>(new TicksProviderBinary());
+        return CorPtr<ITicksProvider>(new TicksProviderAdaptive());
     case TickProviderType::SMALL:
-        return Corrade::Containers::Pointer<ITicksProvider>(new TicksProviderFake());
+        return CorPtr<ITicksProvider>(new TicksProviderFake());
     case TickProviderType::GENERATED:
-        return Corrade::Containers::Pointer<ITicksProvider>(new TicksProviderGenerated());
+        return CorPtr<ITicksProvider>(new TicksProviderGenerated());
     case TickProviderType::XMR_FAKE:
-        return Corrade::Containers::Pointer<ITicksProvider>(new TicksProviderXMRFake());
+        return CorPtr<ITicksProvider>(new TicksProviderXMRFake());
     case TickProviderType::XMR:
-        return Corrade::Containers::Pointer<ITicksProvider>(new TicksProviderXMR());
+        return CorPtr<ITicksProvider>(new TicksProviderAdaptive());
+    case TickProviderType::ADAPTIVE:
+        return CorPtr<ITicksProvider>(new TicksProviderAdaptive());
+    case TickProviderType::ADAPTIVE_FAKE:
+        return CorPtr<ITicksProvider>(new TicksProviderAdaptiveFake());
     }
     throw EnjoLib::ExceptRuntimeError("Not handled type ");
 }