cpp-cli/include/cli/cli.h

//
//  cli.h
//  tax-manager
//
//  Created by Sam Jaffe on 10/8/20.
//  Copyright © 2020 Sam Jaffe. All rights reserved.
//

#pragma once

#include <functional>
#include <iostream>
#include <string>
#include <tuple>
#include <unordered_map>
#include <vector>

#include "lambda_cast.h"

namespace cli {

template <typename T> struct is_string : std::false_type {};
template <typename T>
struct is_string<T*> : std::is_same<std::remove_cv_t<T>, char> {};
template <typename T>
struct is_string<T[]> : std::is_same<std::remove_cv_t<T>, char> {};
template <typename...Ts>
struct is_string<std::basic_string<Ts...>> : std::true_type {};

template <typename T, typename = void> struct is_container : std::false_type {};
template <typename T>
struct is_container<T, std::enable_if_t<!std::is_void_v<typename T::value_type>>> : std::true_type {};

template <typename T>
static constexpr bool const is_string_v = is_string<T>::value;
template <typename T>
static constexpr bool const is_container_v = is_container<T>::value;

class cli {
public:
  using args_t = std::vector<std::string>;
  using callback = std::function<void(args_t const &)>;

private:
  std::istream &in_;
  std::string prompt_;
  std::unordered_map<std::string, size_t> arguments_;
  std::unordered_map<std::string, callback> callbacks_;
  bool eof_;

public:
  cli(std::string const & prompt, std::istream &in = std::cin);
  cli(std::istream &in = std::cin);
  template <typename... Args>
  cli & register_callback(std::string const & handle,
                          std::function<void(Args...)> cb);
  template <typename F>
  cli & register_callback(std::string const & handle, F && cb) {
    return register_callback(handle, lambdas::FFL(cb));
  }
  template <typename T>
  cli & register_query(std::string const & handle, std::function<T()> cb);
  template <typename F>
  cli & register_query(std::string const & handle, F && cb) {
    return register_query(handle, lambdas::FFL(cb));
  }
  
  void run() const;
  template <typename T, size_t I>
  static auto from_string(std::string const & value) {
    using E = std::tuple_element_t<I, T>;
    using V = std::remove_cv_t<std::remove_reference_t<E>>;
    return from_string<V>(value);
  }
  
private:
  bool active() const;
  template <typename T> static T from_string(std::string const &);
};

template <typename... Args, size_t... Is>
void cli_invoke(std::function<void(Args...)> cb, cli::args_t const & args,
                std::index_sequence<Is...>) {
  using tuple = std::tuple<Args...>;
  cb(cli::from_string<tuple, Is>(args[Is])...);
}

template <typename... Args>
cli & cli::register_callback(std::string const & handle,
                             std::function<void(Args...)> cb) {
  arguments_.emplace(handle, sizeof...(Args));
  callbacks_.emplace(handle, [=](args_t const & args) {
    if (sizeof...(Args) > args.size()) {
      std::cerr << "Missing Args in command '" << handle << "', " <<
          sizeof...(Args) << " required, but " << args.size() << " input\n";
      return;
    }
    cli_invoke(cb, args, std::make_index_sequence<sizeof...(Args)>());
  });
  return *this;
}

template <typename T> void cli_print(T const & value) {
  if constexpr (is_container_v<T> && !is_string_v<T>) {
    using ::cli::cli_print;
    for (auto & elem : value) {
      cli_print(elem);
    }
  } else {
    std::cout << "  " << value << "\n";
  }
}

template <typename T>
cli & cli::register_query(std::string const & handle, std::function<T()> cb) {
  arguments_.emplace(handle, 0);
  callbacks_.emplace(handle, [=](args_t const & args) {
    using ::cli::cli_print;
    cli_print(cb());
  });
  return *this;
}

}