string_list.hpp

//--------------------------------------------------------------------------------------------------
// Copyright (c) 2018 Marcus Geelnard
//
// This software is provided 'as-is', without any express or implied warranty. In no event will the
// authors be held liable for any damages arising from the use of this software.
//
// Permission is granted to anyone to use this software for any purpose, including commercial
// applications, and to alter it and redistribute it freely, subject to the following restrictions:
//
//  1. The origin of this software must not be misrepresented; you must not claim that you wrote
//     the original software. If you use this software in a product, an acknowledgment in the
//     product documentation would be appreciated but is not required.
//
//  2. Altered source versions must be plainly marked as such, and must not be misrepresented as
//     being the original software.
//
//  3. This notice may not be removed or altered from any source distribution.
//--------------------------------------------------------------------------------------------------
 
#ifndef BUILDCACHE_STRING_LIST_HPP_
#define BUILDCACHE_STRING_LIST_HPP_
 
#include <initializer_list>
#include <string>
#include <vector>
 
namespace bcache {
class string_list_t {
public:
  typedef typename std::vector<std::string>::iterator iterator;
  typedef typename std::vector<std::string>::const_iterator const_iterator;
 
  string_list_t() {
  }
 
  string_list_t(std::initializer_list<std::string> list) : m_strings(list) {
  }
 
  string_list_t(const std::vector<std::string>& vec) : m_strings(vec) {
  }
 
  string_list_t(const int argc, const char** argv) {
    for (int i = 0; i < argc; ++i) {
      m_strings.emplace_back(std::string(argv[i]));
    }
  }
 
  string_list_t(const std::string& str, const std::string& delimiter);
 
  static string_list_t split_args(const std::string& cmd);
 
  std::string join(const std::string& separator, const bool escape = false) const;
 
  void clear() {
    m_strings.clear();
  }
 
  void pop_back() {
    m_strings.pop_back();
  }
 
  std::string& operator[](const size_t idx) {
    return m_strings[idx];
  }
 
  const std::string& operator[](const size_t idx) const {
    return m_strings[idx];
  }
 
  string_list_t& operator+=(const std::string& str) {
    m_strings.emplace_back(str);
    return *this;
  }
 
  string_list_t& operator+=(const string_list_t& list) {
    for (const auto& str : list) {
      m_strings.emplace_back(str);
    }
    return *this;
  }
 
  string_list_t operator+(const std::string& str) const {
    string_list_t result(*this);
    result += str;
    return result;
  }
 
  string_list_t operator+(const string_list_t& list) const {
    string_list_t result(*this);
    result += list;
    return result;
  }
 
  size_t size() const {
    return m_strings.size();
  }
 
  iterator begin() {
    return m_strings.begin();
  }
 
  const_iterator begin() const {
    return m_strings.begin();
  }
 
  const_iterator cbegin() const {
    return m_strings.cbegin();
  }
 
  iterator end() {
    return m_strings.end();
  }
 
  const_iterator end() const {
    return m_strings.end();
  }
 
  const_iterator cend() const {
    return m_strings.cend();
  }
 
private:
  static std::string escape_arg(const std::string& arg);
 
  static std::string unescape_arg(const std::string& arg);
 
  std::vector<std::string> m_strings;
};
}  // namespace bcache
 
#endif  // BUILDCACHE_STRING_LIST_HPP_