tomoto 0.6.0 → 0.6.2

data/vendor/variant/README.md

@@ -1,102 +0,0 @@
-# Mapbox Variant
-
-An alternative to `boost::variant` for C++11 and C++14
-
-[![Build Status](https://secure.travis-ci.org/mapbox/variant.svg)](https://travis-ci.org/mapbox/variant)
-[![Build status](https://ci.appveyor.com/api/projects/status/v9tatx21j1k0fcgy)](https://ci.appveyor.com/project/Mapbox/variant)
-[![Coverage Status](https://coveralls.io/repos/mapbox/variant/badge.svg?branch=master&service=github)](https://coveralls.io/r/mapbox/variant?branch=master)
-
-
-## Why use Mapbox Variant?
-
-Mapbox variant has the same speedy performance of `boost::variant` but is
-faster to compile, results in smaller binaries, and has no dependencies.
-
-For example on OS X 10.9 with clang++ and libc++:
-
-Test | Mapbox Variant | Boost Variant
----- | -------------- | -------------
-Size of pre-compiled header (release / debug) | 2.8/2.8 MB         | 12/15 MB
-Size of simple program linking variant (release / debug)     | 8/24 K             | 12/40 K
-Time to compile header     | 185 ms             |  675 ms
-
-(Numbers from an older version of Mapbox variant.)
-
-
-## Goals
-
-Mapbox `variant` has been a very valuable, lightweight alternative for apps
-that can use c++11 or c++14 but that do not want a boost dependency.
-Mapbox `variant` has also been useful in apps that do depend on boost, like
-mapnik, to help (slightly) with compile times and to majorly lessen dependence
-on boost in core headers. The original goal and near term goal is to maintain
-external API compatibility with `boost::variant` such that Mapbox `variant`
-can be a "drop in". At the same time the goal is to stay minimal: Only
-implement the features that are actually needed in existing software. So being
-an "incomplete" implementation is just fine.
-
-Currently Mapbox variant doesn't try to be API compatible with the upcoming
-variant standard, because the standard is not finished and it would be too much
-work. But we'll revisit this decision in the future if needed.
-
-If Mapbox variant is not for you, have a look at [these other
-implementations](doc/other_implementations.md).
-
-Want to know more about the upcoming standard? Have a look at our
-[overview](doc/standards_effort.md).
-
-
-## Depends
-
- - Compiler supporting `-std=c++11` or `-std=c++14`
-
-Tested with:
-
- - g++-4.7
- - g++-4.8
- - g++-4.9
- - g++-5.2
- - clang++-3.5
- - clang++-3.6
- - clang++-3.7
- - clang++-3.8
- - clang++-3.9
- - Visual Studio 2015
-
-## Usage
-
-There is nothing to build, just include `variant.hpp` in your project. Include `variant_io.hpp` if you need
-the `operator<<` overload for variant.
-
-
-## Unit Tests
-
-On Unix systems compile and run the unit tests with `make test`.
-
-On Windows run `scripts/build-local.bat`.
-
-
-## Limitations
-
-* The `variant` can not hold references (something like `variant<int&>` is
-  not possible). You might want to try `std::reference_wrapper` instead.
-
-
-## Deprecations
-
-* The included implementation of `optional` is deprecated and will be removed
-  in a future version. See https://github.com/mapbox/variant/issues/64.
-* Old versions of the code needed visitors to derive from `static_visitor`.
-  This is not needed any more and marked as deprecated. The `static_visitor`
-  class will be removed in future versions.
-
-
-## Benchmarks
-
-    make bench
-
-
-## Check object sizes
-
-    make sizes /path/to/boost/variant.hpp
-

data/vendor/variant/include/mapbox/optional.hpp

@@ -1,74 +0,0 @@
-#ifndef MAPBOX_UTIL_OPTIONAL_HPP
-#define MAPBOX_UTIL_OPTIONAL_HPP
-
-#pragma message("This implementation of optional is deprecated. See https://github.com/mapbox/variant/issues/64.")
-
-#include <type_traits>
-#include <utility>
-
-#include <mapbox/variant.hpp>
-
-namespace mapbox {
-namespace util {
-
-template <typename T>
-class optional
-{
-    static_assert(!std::is_reference<T>::value, "optional doesn't support references");
-
-    struct none_type
-    {
-    };
-
-    variant<none_type, T> variant_;
-
-public:
-    optional() = default;
-
-    optional(optional const& rhs)
-    {
-        if (this != &rhs)
-        { // protect against invalid self-assignment
-            variant_ = rhs.variant_;
-        }
-    }
-
-    optional(T const& v) { variant_ = v; }
-
-    explicit operator bool() const noexcept { return variant_.template is<T>(); }
-
-    T const& get() const { return variant_.template get<T>(); }
-    T& get() { return variant_.template get<T>(); }
-
-    T const& operator*() const { return this->get(); }
-    T operator*() { return this->get(); }
-
-    optional& operator=(T const& v)
-    {
-        variant_ = v;
-        return *this;
-    }
-
-    optional& operator=(optional const& rhs)
-    {
-        if (this != &rhs)
-        {
-            variant_ = rhs.variant_;
-        }
-        return *this;
-    }
-
-    template <typename... Args>
-    void emplace(Args&&... args)
-    {
-        variant_ = T{std::forward<Args>(args)...};
-    }
-
-    void reset() { variant_ = none_type{}; }
-
-}; // class optional
-
-} // namespace util
-} // namespace mapbox
-
-#endif // MAPBOX_UTIL_OPTIONAL_HPP

data/vendor/variant/include/mapbox/recursive_wrapper.hpp

@@ -1,122 +0,0 @@
-#ifndef MAPBOX_UTIL_RECURSIVE_WRAPPER_HPP
-#define MAPBOX_UTIL_RECURSIVE_WRAPPER_HPP
-
-// Based on variant/recursive_wrapper.hpp from boost.
-//
-// Original license:
-//
-// Copyright (c) 2002-2003
-// Eric Friedman, Itay Maman
-//
-// Distributed under the Boost Software License, Version 1.0. (See
-// accompanying file LICENSE_1_0.txt or copy at
-// http://www.boost.org/LICENSE_1_0.txt)
-
-#include <cassert>
-#include <utility>
-
-namespace mapbox {
-namespace util {
-
-template <typename T>
-class recursive_wrapper
-{
-
-    T* p_;
-
-    void assign(T const& rhs)
-    {
-        this->get() = rhs;
-    }
-
-public:
-    using type = T;
-
-    /**
-     * Default constructor default initializes the internally stored value.
-     * For POD types this means nothing is done and the storage is
-     * uninitialized.
-     *
-     * @throws std::bad_alloc if there is insufficient memory for an object
-     *         of type T.
-     * @throws any exception thrown by the default constructur of T.
-     */
-    recursive_wrapper()
-        : p_(new T){}
-
-    ~recursive_wrapper() noexcept { delete p_; }
-
-    recursive_wrapper(recursive_wrapper const& operand)
-        : p_(new T(operand.get())) {}
-
-    recursive_wrapper(T const& operand)
-        : p_(new T(operand)) {}
-
-    recursive_wrapper(recursive_wrapper&& operand)
-        : p_(new T(std::move(operand.get()))) {}
-
-    recursive_wrapper(T&& operand)
-        : p_(new T(std::move(operand))) {}
-
-    inline recursive_wrapper& operator=(recursive_wrapper const& rhs)
-    {
-        assign(rhs.get());
-        return *this;
-    }
-
-    inline recursive_wrapper& operator=(T const& rhs)
-    {
-        assign(rhs);
-        return *this;
-    }
-
-    inline void swap(recursive_wrapper& operand) noexcept
-    {
-        T* temp = operand.p_;
-        operand.p_ = p_;
-        p_ = temp;
-    }
-
-    recursive_wrapper& operator=(recursive_wrapper&& rhs) noexcept
-    {
-        swap(rhs);
-        return *this;
-    }
-
-    recursive_wrapper& operator=(T&& rhs)
-    {
-        get() = std::move(rhs);
-        return *this;
-    }
-
-    T& get()
-    {
-        assert(p_);
-        return *get_pointer();
-    }
-
-    T const& get() const
-    {
-        assert(p_);
-        return *get_pointer();
-    }
-
-    T* get_pointer() { return p_; }
-
-    const T* get_pointer() const { return p_; }
-
-    operator T const&() const { return this->get(); }
-
-    operator T&() { return this->get(); }
-
-}; // class recursive_wrapper
-
-template <typename T>
-inline void swap(recursive_wrapper<T>& lhs, recursive_wrapper<T>& rhs) noexcept
-{
-    lhs.swap(rhs);
-}
-} // namespace util
-} // namespace mapbox
-
-#endif // MAPBOX_UTIL_RECURSIVE_WRAPPER_HPP