init

.gitignore

@@ -0,0 +1,34 @@
+
+
+/.idea
+/build
+*.swp
+
+# Compiled Object files
+*.slo
+*.lo
+*.o
+*.obj
+
+# Precompiled Headers
+*.gch
+*.pch
+
+# Compiled Dynamic libraries
+*.so
+*.dylib
+*.dll
+
+# Fortran module files
+*.mod
+
+# Compiled Static libraries
+*.lai
+*.la
+*.a
+*.lib
+
+# Executables
+*.exe
+*.out
+*.app

CMakeLists.txt

@@ -0,0 +1,10 @@
+cmake_minimum_required(VERSION 2.8)
+set(CMAKE_MODULE_PATH ${CMAKE_MODULE_PATH} "${CMAKE_CURRENT_SOURCE_DIR}/CMakeModules/")
+set(PROJECT_NAME project)
+project(${PROJECT_NAME})
+find_package(GTest)
+add_subdirectory(src)
+if (GTEST_FOUND)
+    enable_testing()
+    add_subdirectory(tests)
+endif (GTEST_FOUND)

CMakeModules/FindJsonCpp.cmake

@@ -0,0 +1,46 @@
+# -*- cmake -*-
+# - Find JSONCpp
+# Find the JSONCpp includes and library
+# This module defines
+#  JSONCPP_INCLUDE_DIRS, where to find json.h, etc.
+#  JSONCPP_LIBRARIES, the libraries needed to use jsoncpp.
+#  JSONCPP_FOUND, If false, do not try to use jsoncpp.
+#  also defined, but not for general use are
+#  JSONCPP_LIBRARIES, where to find the jsoncpp library.
+
+FIND_PATH(JSONCPP_INCLUDE_DIRS json/json.h
+        /usr/include
+        /usr/local/include
+        ${CMAKE_SOURCE_DIR}/win32-deps/include
+        PATH_SUFFIXES jsoncpp/json jsoncpp
+        )
+
+
+FIND_LIBRARY(JSONCPP_LIBRARIES NAMES jsoncpp HINTS /usr/lib /usr/local/lib 	${CMAKE_SOURCE_DIR}/win32-deps/lib)
+
+IF (JSONCPP_LIBRARIES AND JSONCPP_INCLUDE_DIRS)
+    SET(JSONCPP_LIBRARIES ${JSONCPP_LIBRARIES})
+    SET(JSONCPP_FOUND "YES")
+ELSE (JSONCPP_LIBRARIES AND JSONCPP_INCLUDE_DIRS)
+    SET(JSONCPP_FOUND "NO")
+ENDIF (JSONCPP_LIBRARIES AND JSONCPP_INCLUDE_DIRS)
+
+
+IF (JSONCPP_FOUND)
+    IF (NOT JSONCPP_FIND_QUIETLY)
+        MESSAGE(STATUS "Found JSONCpp: ${JSONCPP_LIBRARIES}")
+    ENDIF (NOT JSONCPP_FIND_QUIETLY)
+ELSE (JSONCPP_FOUND)
+    IF (JSONCPP_FIND_REQUIRED)
+        MESSAGE(FATAL_ERROR "Could not find JSONCPP library include: ${JSONCPP_INCLUDE_DIRS}, lib: ${JSONCPP_LIBRARIES}")
+    ENDIF (JSONCPP_FIND_REQUIRED)
+ENDIF (JSONCPP_FOUND)
+
+# Deprecated declarations.
+SET (NATIVE_JSONCPP_INCLUDE_PATH ${JSONCPP_INCLUDE_DIRS} )
+GET_FILENAME_COMPONENT (NATIVE_JSONCPP_LIB_PATH ${JSONCPP_LIBRARIES} PATH)
+
+MARK_AS_ADVANCED(
+        JSONCPP_LIBRARIES
+        JSONCPP_INCLUDE_DIRS
+)

src/CMakeLists.txt

@@ -0,0 +1,16 @@
+include_directories(.)
+set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -std=c++11")
+set(SOURCE_FILES
+  main.cpp
+  Interface/MainClass.cpp
+  Interface/MainClass.h
+  Interface/CommandLineParser.cpp
+  Interface/CommandLineParser.h
+  DBO/CommandLineOption.cpp
+  DBO/CommandLineOption.h
+  DBO/Result.hxx
+  DBO/Result.h
+  )
+
+add_executable(${PROJECT_NAME} ${SOURCE_FILES})
+target_link_libraries(${PROJECT_NAME} ${LIBS})

src/DBO/CommandLineOption.cpp

@@ -0,0 +1,98 @@
+//
+// Created by robin on 8/8/15.
+//
+
+#include "CommandLineOption.h"
+
+CommandLineOption::CommandLineOption(const std::string &longName, char shortName, const std::string &description,
+                                     const std::string &valueName, const std::string &defaultValue)
+    : _longName(longName)
+    , _shortName(shortName)
+    , _description(description)
+    , _valueName(valueName)
+    , _defaultValue(defaultValue)
+    , _isSet(false)
+{
+}
+
+const std::string &CommandLineOption::getLongName() const
+{
+    return _longName;
+}
+
+void CommandLineOption::setLongName(const std::string &longName)
+{
+    _longName = longName;
+}
+
+char CommandLineOption::getShortName() const
+{
+    return _shortName;
+}
+
+void CommandLineOption::setShortName(char shortName)
+{
+    _shortName = shortName;
+}
+
+const std::string &CommandLineOption::getDescription() const
+{
+    return _description;
+}
+
+void CommandLineOption::setDescription(const std::string &description)
+{
+    _description = description;
+}
+
+const std::string &CommandLineOption::getValueName() const
+{
+    return _valueName;
+}
+
+void CommandLineOption::setValueName(const std::string &valueName)
+{
+    _valueName = valueName;
+}
+
+const std::string &CommandLineOption::getDefaultValue() const
+{
+    return _defaultValue;
+}
+
+void CommandLineOption::setDefaultValue(const std::string &defaultValue)
+{
+    _defaultValue = defaultValue;
+}
+
+const std::vector<std::string> &CommandLineOption::getValues() const
+{
+    return _values;
+}
+
+void CommandLineOption::addValue(const std::string &value)
+{
+    _values.push_back(value);
+}
+
+bool CommandLineOption::isSet() const
+{
+    return _isSet;
+}
+
+void CommandLineOption::setIsSet(bool isSet)
+{
+    _isSet = isSet;
+}
+
+bool CommandLineOption::hasValue() const
+{
+    return !_valueName.empty();
+}
+
+const std::string &CommandLineOption::getValue() const
+{
+    if (_values.empty())
+        return _defaultValue;
+    return _values[_values.size() - 1];
+}

src/DBO/CommandLineOption.h

@@ -0,0 +1,66 @@
+//
+// Created by robin on 8/8/15.
+//
+
+#ifndef PDNS_SLAVE_COMMANDLINEOPTION_H
+#define PDNS_SLAVE_COMMANDLINEOPTION_H
+
+# include <string>
+# include <vector>
+
+class CommandLineOption
+{
+public:
+    CommandLineOption(const std::string& longName, char shortName, const std::string& description,
+                      const std::string& valueName = "", const std::string& defaultValue = "");
+
+    const std::string &getLongName() const;
+
+    void setLongName(const std::string &longName);
+
+    char getShortName() const;
+
+    void setShortName(char shortName);
+
+    const std::string &getDescription() const;
+
+    void setDescription(const std::string &description);
+
+    const std::string &getValueName() const;
+
+    void setValueName(const std::string &valueName);
+
+    const std::string &getDefaultValue() const;
+
+    void setDefaultValue(const std::string &defaultValue);
+
+    const std::vector<std::string> &getValues() const;
+
+    const std::string &getValue() const;
+
+    void addValue(const std::string &value);
+
+    bool isSet() const;
+
+    void setIsSet(bool isSet);
+
+    bool hasValue() const;
+
+private:
+    std::string _longName;
+
+    char _shortName;
+
+    std::string _description;
+
+    std::string _valueName;
+
+    std::string _defaultValue;
+
+    std::vector<std::string> _values;
+
+    bool _isSet;
+};
+
+
+#endif //PDNS_SLAVE_COMMANDLINEOPTION_H

src/DBO/Result.h

@@ -0,0 +1,52 @@
+//
+// Created by robin on 8/9/15.
+//
+
+#ifndef PDNS_SLAVE_RESULT_H
+#define PDNS_SLAVE_RESULT_H
+
+# include <string>
+# include <vector>
+
+template <class T> class Result
+{
+public:
+    Result();
+
+    Result(const T& data);
+
+    virtual ~Result();
+
+    Result<T>& ok(const T& data);
+
+    T& getData();
+
+    bool isSuccess() const;
+
+    Result<T>& addWarning(const std::string& warning);
+
+    const std::vector<std::string>& getWarnings() const;
+
+    Result<T>& error(const std::string& error);
+
+    const std::string& getError() const;
+
+    bool operator !() const;
+
+    operator bool() const;
+
+    const Result<T>& print() const;
+
+private:
+    T _data;
+
+    std::vector<std::string> _warnings;
+
+    std::string _error;
+};
+
+typedef Result<bool> BResult;
+
+# include "DBO/Result.hxx"
+
+#endif //PDNS_SLAVE_RESULT_H

src/DBO/Result.hxx

@@ -0,0 +1,89 @@
+//
+// Created by robin on 8/9/15.
+//
+
+#include <iostream>
+#include "Result.h"
+
+template<class T>
+Result<T>::Result()
+{
+}
+
+template<class T>
+Result<T>::Result(const T &data)
+        : _data(data)
+{
+}
+
+template<class T>
+Result<T>::~Result()
+{
+}
+
+template<class T>
+Result<T> &Result<T>::ok(const T &data)
+{
+    _data = data;
+    return *this;
+}
+
+template<class T>
+T &Result<T>::getData()
+{
+    return _data;
+}
+
+template<class T>
+bool Result<T>::isSuccess() const
+{
+    return _error.empty();
+}
+
+template<class T>
+const std::vector<std::string>& Result<T>::getWarnings() const
+{
+    return _warnings;
+}
+
+template<class T>
+Result<T>& Result<T>::addWarning(const std::string &warning)
+{
+    _warnings.push_back(warning);
+    return *this;
+}
+
+template<class T>
+bool Result<T>::operator!() const
+{
+    return !isSuccess();
+}
+
+template<class T>
+Result<T>::operator bool() const
+{
+    return isSuccess();
+}
+
+template<class T>
+Result<T> &Result<T>::error(const std::string &error)
+{
+    _error = error;
+    return *this;
+}
+
+template<class T>
+const std::string &Result<T>::getError() const
+{
+    return _error;
+}
+
+template<class T>
+const Result<T>& Result<T>::print() const
+{
+    for (auto warning : _warnings)
+        std::cerr << "WARNING: " << warning << std::endl;
+    if (!isSuccess())
+        std::cerr << "ERROR: " << _error << std::endl;
+    return *this;
+}

src/Interface/CommandLineParser.cpp

@@ -0,0 +1,74 @@
+//
+// Created by robin on 8/8/15.
+//
+
+#include <getopt.h>
+#include <iostream>
+#include "CommandLineParser.h"
+
+CommandLineParser::CommandLineParser(int argc, char **argv)
+    : _argc(argc)
+    , _argv(argv)
+{
+}
+
+bool CommandLineParser::parse()
+{
+    std::string shortOpts;
+    option opts[_options.size() + 1];
+    for (unsigned i = 0; i < _options.size(); ++i)
+    {
+        auto opt = _options[i];
+        shortOpts += opt->getShortName();
+        if (opt->hasValue())
+            shortOpts += ":";
+        opts[i].name = opt->getLongName().c_str();
+        opts[i].has_arg = opt->hasValue();
+        opts[i].flag = 0;
+        opts[i].val = opt->getShortName();
+    }
+    opts[_options.size()] = {0, 0, 0, 0};
+    int option;
+    extern int optind;
+    extern char* optarg;
+    bool valid = true;
+    while ((option = getopt_long(_argc, _argv, shortOpts.c_str(), opts, 0)) != -1)
+    {
+        bool optValid = false;
+        for (unsigned i = 0; i < _options.size(); ++i)
+        {
+            auto opt = _options[i];
+            if (opt->getShortName() == option)
+            {
+                optValid = true;
+                opt->setIsSet(true);
+                if (opt->hasValue())
+                    opt->addValue(optarg);
+            }
+        }
+        if (!optValid)
+            valid = false;
+    }
+    return optind == _argc && valid;
+}
+
+void CommandLineParser::addOption(CommandLineOption* opt)
+{
+    _options.push_back(opt);
+}
+
+int CommandLineParser::showHelp(int status, bool stdErr)
+{
+    auto& out = stdErr ? std::cerr : std::cout;
+    out << "Options:" << std::endl;
+    for (auto opt : _options)
+    {
+        out << "  -" << opt->getShortName() << ", --" << opt->getLongName();
+        if (opt->hasValue())
+        {
+            out << " <" << opt->getValueName() << "=" << opt->getDefaultValue() << ">";
+        }
+        out << " " << opt->getDescription() << std::endl;
+    }
+    return status;
+}

src/Interface/CommandLineParser.h

@@ -0,0 +1,30 @@
+//
+// Created by robin on 8/8/15.
+//
+
+#ifndef PDNS_SLAVE_COMMANDLINEPARSER_H
+#define PDNS_SLAVE_COMMANDLINEPARSER_H
+
+# include "DBO/CommandLineOption.h"
+
+class CommandLineParser
+{
+public:
+    CommandLineParser(int argc, char** argv);
+
+    bool parse();
+
+    int showHelp(int status = 0, bool stdErr = true);
+
+    void addOption(CommandLineOption* opt);
+
+private:
+    int _argc;
+
+    char** _argv;
+
+    std::vector<CommandLineOption*> _options;
+};
+
+
+#endif //PDNS_SLAVE_COMMANDLINEPARSER_H

src/Interface/MainClass.cpp

@@ -0,0 +1,21 @@
+//
+// Created by robin on 8/8/15.
+//
+
+#include <iostream>
+#include <sysexits.h>
+#include <DBO/Result.h>
+#include "CommandLineParser.h"
+#include "MainClass.h"
+
+MainClass::MainClass(int argc, char *argv[])
+    : _argc(argc)
+    , _argv(argv)
+{
+}
+
+int MainClass::main()
+{
+
+    return 0;
+}

src/Interface/MainClass.h

@@ -0,0 +1,23 @@
+//
+// Created by robin on 8/8/15.
+//
+
+#ifndef PDNS_SLAVE_MAINCLASS_H
+#define PDNS_SLAVE_MAINCLASS_H
+
+
+class MainClass {
+public:
+    MainClass(int argc, char* argv[]);
+
+    int main();
+
+private:
+    int _argc;
+
+    char** _argv;
+
+};
+
+
+#endif //PDNS_SLAVE_MAINCLASS_H

src/main.cpp

@@ -0,0 +1,7 @@
+#include "Interface/MainClass.h"
+
+int main(int argc, char* argv[])
+{
+    MainClass m(argc, argv);
+    return m.main();
+}

tests/CMakeLists.txt

@@ -0,0 +1,11 @@
+enable_testing()
+include_directories(${CHECK_INCLUDE_DIRS})
+include_directories(. ../src)
+find_package (Threads)
+set(LIBS ${LIBS} gtest pthread)
+set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -std=c++11")
+add_executable(test-${PROJECT_NAME}
+        test-main.cpp
+  )
+target_link_libraries(test-${PROJECT_NAME} ${LIBS})
+add_test(test-${PROJECT_NAME} ${CMAKE_CURRENT_BINARY_DIR}/test-${PROJECT_NAME})

tests/test-main.cpp

@@ -0,0 +1,14 @@
+#include <iostream>
+#include <string.h>
+#include <gtest/gtest.h>
+
+TEST(None, None)
+{
+  ASSERT_TRUE(true);
+}
+
+int main(int argc, char* argv[])
+{
+  ::testing::InitGoogleTest(&argc, argv);
+  return RUN_ALL_TESTS();
+}