couchbase 4.2.1 → 4.2.2

package/deps/couchbase-cxx-client/third_party/docopt/docopt_util.h

@@ -0,0 +1,122 @@
+//
+//  docopt_util.h
+//  docopt
+//
+//  Created by Jared Grubb on 2013-11-04.
+//  Copyright (c) 2013 Jared Grubb. All rights reserved.
+//
+
+#ifndef docopt_docopt_util_h
+#define docopt_docopt_util_h
+
+#if DOCTOPT_USE_BOOST_REGEX
+#include <boost/regex.hpp>
+namespace std {
+    using boost::regex;
+    using boost::sregex_token_iterator;
+}
+#else
+#include <regex>
+#endif
+
+#if 0
+#pragma mark -
+#pragma mark General utility
+#endif
+
+namespace {
+	bool starts_with(std::string const& str, std::string const& prefix)
+	{
+		if (str.length() < prefix.length())
+			return false;
+		return std::equal(prefix.begin(), prefix.end(),
+				  str.begin());
+	}
+
+	std::string trim(std::string&& str,
+			 const std::string& whitespace = " \t\n")
+	{
+		const auto strEnd = str.find_last_not_of(whitespace);
+		if (strEnd==std::string::npos)
+			return {}; // no content
+		str.erase(strEnd+1);
+
+		const auto strBegin = str.find_first_not_of(whitespace);
+		str.erase(0, strBegin);
+
+		return std::move(str);
+	}
+
+	std::vector<std::string> split(std::string const& str, size_t pos = 0)
+	{
+		const char* const anySpace = " \t\r\n\v\f";
+
+		std::vector<std::string> ret;
+		while (pos != std::string::npos) {
+			auto start = str.find_first_not_of(anySpace, pos);
+			if (start == std::string::npos) break;
+
+			auto end = str.find_first_of(anySpace, start);
+			auto size = end==std::string::npos ? end : end-start;
+			ret.emplace_back(str.substr(start, size));
+
+			pos = end;
+		}
+
+		return ret;
+	}
+
+	std::tuple<std::string, std::string, std::string> partition(std::string str, std::string const& point)
+	{
+		std::tuple<std::string, std::string, std::string> ret;
+
+		auto i = str.find(point);
+
+		if (i == std::string::npos) {
+			// no match: string goes in 0th spot only
+		} else {
+			std::get<2>(ret) = str.substr(i + point.size());
+			std::get<1>(ret) = point;
+			str.resize(i);
+		}
+		std::get<0>(ret) = std::move(str);
+
+		return ret;
+	}
+
+	template <typename I>
+	std::string join(I iter, I end, std::string const& delim) {
+		if (iter==end)
+			return {};
+
+		std::string ret = *iter;
+		for(++iter; iter!=end; ++iter) {
+			ret.append(delim);
+			ret.append(*iter);
+		}
+		return ret;
+	}
+
+	std::vector<std::string> regex_split(std::string const& text, std::regex const& re)
+	{
+		std::vector<std::string> ret;
+		for (auto it = std::sregex_token_iterator(text.begin(), text.end(), re, -1);
+			it != std::sregex_token_iterator();
+			++it) {
+			ret.emplace_back(*it);
+		}
+		return ret;
+	}
+}
+
+namespace docopt {
+	template <class T>
+	inline void hash_combine(std::size_t& seed, T const& v)
+	{
+		// stolen from boost::hash_combine
+		std::hash<T> hasher;
+		seed ^= hasher(v) + 0x9e3779b9 + (seed<<6) + (seed>>2);
+	}
+}
+
+#endif

package/deps/couchbase-cxx-client/third_party/docopt/docopt_value.h

@@ -0,0 +1,341 @@
+//
+//  value.h
+//  docopt
+//
+//  Created by Jared Grubb on 2013-10-14.
+//  Copyright (c) 2013 Jared Grubb. All rights reserved.
+//
+
+#ifndef docopt__value_h_
+#define docopt__value_h_
+
+#include <string>
+#include <vector>
+#include <functional> // std::hash
+#include <iosfwd>
+#include <stdexcept>
+
+namespace docopt {
+
+	enum class Kind {
+		Empty,
+		Bool,
+		Long,
+		String,
+		StringList
+	};
+
+	/// A generic type to hold the various types that can be produced by docopt.
+	///
+	/// This type can be one of: {bool, long, string, vector<string>}, or empty.
+	struct value {
+		/// An empty value
+		value() {}
+
+		value(std::string);
+		value(std::vector<std::string>);
+		
+		explicit value(bool);
+		explicit value(long);
+		explicit value(int v) : value(static_cast<long>(v)) {}
+
+		~value();
+		value(value const&);
+		value(value&&) noexcept;
+		value& operator=(value const&);
+		value& operator=(value&&) noexcept;
+
+		Kind kind() const { return kind_; }
+		
+		// Test if this object has any contents at all
+		explicit operator bool() const { return kind_ != Kind::Empty; }
+		
+		// Test the type contained by this value object
+		bool isBool()       const { return kind_==Kind::Bool; }
+		bool isString()     const { return kind_==Kind::String; }
+		bool isLong()       const { return kind_==Kind::Long; }
+		bool isStringList() const { return kind_==Kind::StringList; }
+
+		// Throws std::invalid_argument if the type does not match
+		bool asBool() const;
+		long asLong() const;
+		std::string const& asString() const;
+		std::vector<std::string> const& asStringList() const;
+
+		size_t hash() const noexcept;
+		
+		friend bool operator==(value const&, value const&);
+		friend bool operator!=(value const&, value const&);
+
+	private:
+		union Variant {
+			Variant() {}
+			~Variant() {  /* do nothing; will be destroyed by ~value */ }
+			
+			bool boolValue;
+			long longValue;
+			std::string strValue;
+			std::vector<std::string> strList;
+		};
+		
+		static const char* kindAsString(Kind kind) {
+			switch (kind) {
+				case Kind::Empty: return "empty";
+				case Kind::Bool: return "bool";
+				case Kind::Long: return "long";
+				case Kind::String: return "string";
+				case Kind::StringList: return "string-list";
+			}
+			return "unknown";
+		}
+
+		void throwIfNotKind(Kind expected) const {
+			if (kind_ == expected)
+				return;
+
+			std::string error = "Illegal cast to ";
+			error += kindAsString(expected);
+			error += "; type is actually ";
+			error += kindAsString(kind_);
+			throw std::runtime_error(std::move(error));
+		}
+
+		Kind kind_ = Kind::Empty;
+		Variant variant_ {};
+	};
+
+	/// Write out the contents to the ostream
+	DOCOPT_API std::ostream& operator<<(std::ostream&, value const&);
+}
+
+namespace std {
+	template <>
+	struct hash<docopt::value> {
+		size_t operator()(docopt::value const& val) const noexcept {
+			return val.hash();
+		}
+	};
+}
+
+namespace docopt {
+	inline
+	value::value(bool v)
+	: kind_(Kind::Bool)
+	{
+		variant_.boolValue = v;
+	}
+
+	inline
+	value::value(long v)
+	: kind_(Kind::Long)
+	{
+		variant_.longValue = v;
+	}
+
+	inline
+	value::value(std::string v)
+	: kind_(Kind::String)
+	{
+		new (&variant_.strValue) std::string(std::move(v));
+	}
+
+	inline
+	value::value(std::vector<std::string> v)
+	: kind_(Kind::StringList)
+	{
+		new (&variant_.strList) std::vector<std::string>(std::move(v));
+	}
+
+	inline
+	value::value(value const& other)
+	: kind_(other.kind_)
+	{
+		switch (kind_) {
+			case Kind::String:
+				new (&variant_.strValue) std::string(other.variant_.strValue);
+				break;
+
+			case Kind::StringList:
+				new (&variant_.strList) std::vector<std::string>(other.variant_.strList);
+				break;
+
+			case Kind::Bool:
+				variant_.boolValue = other.variant_.boolValue;
+				break;
+
+			case Kind::Long:
+				variant_.longValue = other.variant_.longValue;
+				break;
+
+			case Kind::Empty:
+			default:
+				break;
+		}
+	}
+
+	inline
+	value::value(value&& other) noexcept
+	: kind_(other.kind_)
+	{
+		switch (kind_) {
+			case Kind::String:
+				new (&variant_.strValue) std::string(std::move(other.variant_.strValue));
+				break;
+
+			case Kind::StringList:
+				new (&variant_.strList) std::vector<std::string>(std::move(other.variant_.strList));
+				break;
+
+			case Kind::Bool:
+				variant_.boolValue = other.variant_.boolValue;
+				break;
+
+			case Kind::Long:
+				variant_.longValue = other.variant_.longValue;
+				break;
+
+			case Kind::Empty:
+			default:
+				break;
+		}
+	}
+
+	inline
+	value::~value()
+	{
+		switch (kind_) {
+			case Kind::String:
+				variant_.strValue.~basic_string();
+				break;
+
+			case Kind::StringList:
+				variant_.strList.~vector();
+				break;
+
+			case Kind::Empty:
+			case Kind::Bool:
+			case Kind::Long:
+			default:
+				// trivial dtor
+				break;
+		}
+	}
+
+	inline
+	value& value::operator=(value const& other) {
+		// make a copy and move from it; way easier.
+		return *this = value{other};
+	}
+
+	inline
+	value& value::operator=(value&& other) noexcept {
+		// move of all the types involved is noexcept, so we dont have to worry about 
+		// these two statements throwing, which gives us a consistency guarantee.
+		this->~value();
+		new (this) value(std::move(other));
+
+		return *this;
+	}
+
+	template <class T>
+	void hash_combine(std::size_t& seed, const T& v);
+
+	inline
+	size_t value::hash() const noexcept
+	{
+		switch (kind_) {
+			case Kind::String:
+				return std::hash<std::string>()(variant_.strValue);
+
+			case Kind::StringList: {
+				size_t seed = std::hash<size_t>()(variant_.strList.size());
+				for(auto const& str : variant_.strList) {
+					hash_combine(seed, str);
+				}
+				return seed;
+			}
+
+			case Kind::Bool:
+				return std::hash<bool>()(variant_.boolValue);
+
+			case Kind::Long:
+				return std::hash<long>()(variant_.longValue);
+
+			case Kind::Empty:
+			default:
+				return std::hash<void*>()(nullptr);
+		}
+	}
+
+	inline
+	bool value::asBool() const
+	{
+		throwIfNotKind(Kind::Bool);
+		return variant_.boolValue;
+	}
+
+	inline
+	long value::asLong() const
+	{
+		// Attempt to convert a string to a long
+		if (kind_ == Kind::String) {
+			const std::string& str = variant_.strValue;
+			std::size_t pos;
+			const long ret = stol(str, &pos); // Throws if it can't convert
+			if (pos != str.length()) {
+				// The string ended in non-digits.
+				throw std::runtime_error( str + " contains non-numeric characters.");
+			}
+			return ret;
+		}
+		throwIfNotKind(Kind::Long);
+		return variant_.longValue;
+	}
+
+	inline
+	std::string const& value::asString() const
+	{
+		throwIfNotKind(Kind::String);
+		return variant_.strValue;
+	}
+
+	inline
+	std::vector<std::string> const& value::asStringList() const
+	{
+		throwIfNotKind(Kind::StringList);
+		return variant_.strList;
+	}
+
+	inline
+	bool operator==(value const& v1, value const& v2)
+	{
+		if (v1.kind_ != v2.kind_)
+			return false;
+		
+		switch (v1.kind_) {
+			case Kind::String:
+				return v1.variant_.strValue==v2.variant_.strValue;
+
+			case Kind::StringList:
+				return v1.variant_.strList==v2.variant_.strList;
+
+			case Kind::Bool:
+				return v1.variant_.boolValue==v2.variant_.boolValue;
+
+			case Kind::Long:
+				return v1.variant_.longValue==v2.variant_.longValue;
+
+			case Kind::Empty:
+			default:
+				return true;
+		}
+	}
+
+	inline
+	bool operator!=(value const& v1, value const& v2)
+	{
+		return !(v1 == v2);
+	}
+}
+
+#endif /* defined(docopt__value_h_) */

package/deps/couchbase-cxx-client/third_party/docopt/examples/naval_fate.cpp

@@ -0,0 +1,36 @@
+#include "docopt.h"
+
+#include <iostream>
+
+static const char USAGE[] =
+R"(Naval Fate.
+
+    Usage:
+      naval_fate ship new <name>...
+      naval_fate ship <name> move <x> <y> [--speed=<kn>]
+      naval_fate ship shoot <x> <y>
+      naval_fate mine (set|remove) <x> <y> [--moored | --drifting]
+      naval_fate (-h | --help)
+      naval_fate --version
+
+    Options:
+      -h --help     Show this screen.
+      --version     Show version.
+      --speed=<kn>  Speed in knots [default: 10].
+      --moored      Moored (anchored) mine.
+      --drifting    Drifting mine.
+)";
+
+int main(int argc, const char** argv)
+{
+    std::map<std::string, docopt::value> args = docopt::docopt(USAGE, 
+                                                  { argv + 1, argv + argc },
+                                                  true,               // show help if requested
+                                                  "Naval Fate 2.0");  // version string
+
+    for(auto const& arg : args) {
+        std::cout << arg.first << ": " << arg.second << std::endl;
+    }
+
+    return 0;
+}

package/deps/couchbase-cxx-client/third_party/docopt/main.cpp

@@ -0,0 +1,16 @@
+//
+//  main.cpp
+//  docopt
+//
+//  Created by Jared Grubb on 2013-10-03.
+//  Copyright (c) 2013 Jared Grubb. All rights reserved.
+//
+
+#include "docopt.h"
+
+int main(int argc, const char * argv[])
+{
+	
+	return 0;
+}
+

package/deps/couchbase-cxx-client/third_party/docopt/run_testcase.cpp

@@ -0,0 +1,40 @@
+//
+//  docopt_tests.cpp
+//  docopt
+//
+//  Created by Jared Grubb on 2013-11-03.
+//  Copyright (c) 2013 Jared Grubb. All rights reserved.
+//
+
+#include "docopt.h"
+
+#include <iostream>
+
+int main(int argc, const char** argv)
+{
+	if (argc < 2) {
+		std::cerr << "Usage: docopt_tests USAGE [arg]..." << std::endl;
+		exit(-5);
+	}
+	
+	std::string usage = argv[1];
+	std::vector<std::string> args {argv+2, argv+argc};
+	
+	auto result = docopt::docopt(usage, args);
+
+	// print it out in JSON form
+	std::cout << "{ ";
+	bool first = true;
+	for(auto const& arg : result) {
+		if (first) {
+			first = false;
+		} else {
+			std::cout << "," << std::endl;
+		}
+		
+		std::cout << '"' << arg.first << '"' << ": " << arg.second;
+	}
+	std::cout << " }" << std::endl;
+
+	return 0;
+}

package/deps/couchbase-cxx-client/third_party/docopt/run_tests.py

@@ -0,0 +1,72 @@
+#!/usr/bin/env python3
+
+import re
+import sys
+import json
+import subprocess
+
+executable = "${TESTPROG}"
+
+def parse_test(raw):
+	raw = re.compile('#.*$', re.M).sub('', raw).strip()
+	if raw.startswith('"""'):
+		raw = raw[3:]
+
+	for fixture in raw.split('r"""'):
+		name = ''
+		doc, _, body = fixture.partition('"""')
+		cases = []
+		for case in body.split('$')[1:]:
+			argv, _, expect = case.strip().partition('\n')
+			expect = json.loads(expect)
+			prog, _, argv = argv.strip().partition(' ')
+			cases.append((prog, argv, expect))
+
+		yield name, doc, cases
+
+failures = 0
+passes = 0
+
+tests = open('${TESTCASES}','r').read()
+for _, doc, cases in parse_test(tests):
+	if not cases: continue
+
+	for prog, argv, expect in cases:
+		args = [ x for x in argv.split() if x ]
+
+		expect_error = not isinstance(expect, dict)
+
+		error = None
+		out = None
+		try:
+			out = subprocess.check_output([executable, doc]+args, stderr=subprocess.STDOUT)
+			if expect_error:
+				error = " ** an error was expected but it appeared to succeed!"
+			else:
+				json_out = json.loads(out)
+				if expect != json_out:
+					error = " ** JSON does not match expected: %r" % expect
+		except subprocess.CalledProcessError as e:
+			if not expect_error:
+				error = "\n ** this should have succeeded! exit code = %s" % e.returncode
+
+		if not error:
+			passes += 1
+			continue
+
+		failures += 1
+
+		print("="*40)
+		print(doc)
+		print(':'*20)
+		print(prog, argv)
+		print('-'*20)
+		if out:
+			print(out)
+		print(error)
+
+if failures:
+	print("%d failures" % failures)
+	sys.exit(1)
+else:
+	print("PASS (%d)" % passes)