/home/jenkins-slave/workspace/Boost.AFIO Build Documentation/boost-local/libs/afio/include/boost/afio/v2/afio.hpp

Go to the documentation of this file.

/* async_file_io
Provides a threadpool and asynchronous file i/o infrastructure based on Boost.ASIO, Boost.Iostreams and filesystem
(C) 2013-2015 Niall Douglas http://www.nedprod.com/
File Created: Mar 2013


Boost Software License - Version 1.0 - August 17th, 2003

Permission is hereby granted, free of charge, to any person or organization
obtaining a copy of the software and accompanying documentation covered by
this license (the "Software") to use, reproduce, display, distribute,
execute, and transmit the Software, and to prepare derivative works of the
Software, and to permit third-parties to whom the Software is furnished to
do so, all subject to the following:

The copyright notices in the Software and this entire statement, including
the above license grant, this restriction and the following disclaimer,
must be included in all copies of the Software, in whole or in part, and
all derivative works of the Software, unless such copies or derivative
works are solely in the form of machine-executable object code generated by
a source language processor.

THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE, TITLE AND NON-INFRINGEMENT. IN NO EVENT
SHALL THE COPYRIGHT HOLDERS OR ANYONE DISTRIBUTING THE SOFTWARE BE LIABLE
FOR ANY DAMAGES OR OTHER LIABILITY, WHETHER IN CONTRACT, TORT OR OTHERWISE,
ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
DEALINGS IN THE SOFTWARE.
*/

#ifndef BOOST_AFIO_HEADER_INCLUDED

#ifdef DOXYGEN_SHOULD_SKIP_THIS
#define BOOST_AFIO_HEADERS_ONLY 0
#define BOOST_AFIO_USE_BOOST_THREAD 0
#define BOOST_AFIO_USE_BOOST_FILESYSTEM 1
#define ASIO_STANDALONE 0
#endif

#include "config.hpp"

// clang-format off
#ifdef DOXYGEN_SHOULD_SKIP_THIS
#undef BOOST_AFIO_V2_NAMESPACE
#undef BOOST_AFIO_V2_NAMESPACE_BEGIN
#undef BOOST_AFIO_V2_NAMESPACE_END
#undef BOOST_AFIO_HEADERS_ONLY_MEMFUNC_SPEC
#undef BOOST_AFIO_HEADERS_ONLY_VIRTUAL_SPEC

#define BOOST_AFIO_V2_NAMESPACE boost::afio
#define BOOST_AFIO_V2_NAMESPACE_BEGIN namespace boost { namespace afio {
#define BOOST_AFIO_V2_NAMESPACE_END } }
#define BOOST_AFIO_HEADERS_ONLY_MEMFUNC_SPEC
#define BOOST_AFIO_HEADERS_ONLY_VIRTUAL_SPEC virtual
#endif
// clang-format on

#ifndef BOOST_AFIO_AFIO_H
#define BOOST_AFIO_AFIO_H

#include "detail/Undoer.hpp"
#include "detail/ErrorHandling.hpp"
#include "detail/Utility.hpp"
#include <algorithm> // Boost.ASIO needs std::min and std::max
#include <exception>
#include <iostream>
#include <type_traits>

#ifndef BOOST_AFIO_VALIDATE_INPUTS
#ifndef NDEBUG
#define BOOST_AFIO_VALIDATE_INPUTS 1
#else
#define BOOST_AFIO_VALIDATE_INPUTS 0
#endif
#endif

#ifdef BOOST_MSVC
#pragma warning(push)
#pragma warning(disable: 4251) // type needs to have dll-interface to be used by clients of class
#endif

BOOST_AFIO_V2_NAMESPACE_BEGIN

// This isn't consistent on MSVC so hard code it
typedef unsigned long long off_t;

namespace detail
{
    template<class R> class enqueued_task_impl
    {
    protected:
        struct Private
        {
            std::function<R()> task;
            promise<R> r;
            shared_future<R> f;
            bool autoset;
            atomic<int> done;
            Private(std::function<R()> _task) : task(std::move(_task)), f(r.get_future().share()), autoset(true), done(0) { }
        };
        std::shared_ptr<Private> p;
        void validate() const { assert(p); /*if(!p) abort();*/ }
    public:
        enqueued_task_impl(std::function<R()> _task=std::function<R()>()) : p(std::make_shared<Private>(std::move(_task))) { }
        bool valid() const noexcept{ return p.get()!=nullptr; }
        void swap(enqueued_task_impl &o) noexcept{ p.swap(o.p); }
        void reset() { p.reset(); }
        void set_task(std::function<R()> _task) { p->task=std::move(_task); }
        const shared_future<R> &get_future() const { validate(); return p->f; }
        template<class T> void set_future_value(T v)
        {
            int _=0;
            validate();
            if(!p->done.compare_exchange_strong(_, 1))
                return;
            p->r.set_value(std::move(v));
        }
        void set_future_value()
        {
            int _=0;
            validate();
            if(!p->done.compare_exchange_strong(_, 1))
                return;
            p->r.set_value();
        }
        void set_future_exception(exception_ptr e)
        {
            int _=0;
            validate();
            if(!p->done.compare_exchange_strong(_, 1))
                return;
            p->r.set_exception(e);
        }
        void disable_auto_set_future(bool v=true) { validate(); p->autoset=!v; }
    };
}

template<class R> class enqueued_task;
// Can't have args in callable type as that segfaults VS2010
template<class R> class enqueued_task<R()> : public detail::enqueued_task_impl<R>
{
    typedef detail::enqueued_task_impl<R> Base;
public:
    enqueued_task(std::function<R()> _task=std::function<R()>()) : Base(std::move(_task)) { }
    void operator()()
    {
        auto _p(Base::p);
        Base::validate();
        if(!_p->task) abort();
        try
        {
            auto v(_p->task());
            if(_p->autoset && !_p->done) Base::set_future_value(v);
        }
        catch(...)
        {
            if(_p->done)
            {
              BOOST_AFIO_LOG_FATAL_EXIT(detail::output_exception_info << " thrown up to enqueued_task<> after stl_future set." << std::endl);
              BOOST_AFIO_THROW_FATAL(std::runtime_error("Exception thrown up to enqueued_task<> after stl_future set."));
            }
            if(_p->autoset && !_p->done) 
            {
                auto e(current_exception());
                Base::set_future_exception(e);
            }
        }
        // Free any bound parameters in task to save memory
        _p->task=std::function<R()>();
    }
};
template<> class enqueued_task<void()> : public detail::enqueued_task_impl<void>
{
    typedef detail::enqueued_task_impl<void> Base;
public:
    enqueued_task(std::function<void()> _task=std::function<void()>()) : Base(std::move(_task)) { }
    void operator()()
    {
        auto _p(Base::p);
        Base::validate();
        if(!_p->task) abort();
        try
        {
            _p->task();
            if(_p->autoset && !_p->done) Base::set_future_value();
        }
        catch(...)
        {
            if(_p->done)
            {
              BOOST_AFIO_LOG_FATAL_EXIT(detail::output_exception_info << " thrown up to enqueued_task<> after stl_future set." << std::endl);
              BOOST_AFIO_THROW_FATAL(std::runtime_error("Exception thrown up to enqueued_task<> after stl_future set."));
            }
            if(_p->autoset && !_p->done)
            {
                auto e(current_exception());
                Base::set_future_exception(e);
            }
        }
        // Free any bound parameters in task to save memory
        _p->task=std::function<void()>();
    }
};
class thread_source : public std::enable_shared_from_this<thread_source>
{
protected:
    asio::io_service &service;
    thread_source(asio::io_service &_service) : service(_service) { }
    BOOST_AFIO_HEADERS_ONLY_VIRTUAL_SPEC ~thread_source() { }
    thread_source &operator=(const thread_source &) = delete;
public:
    asio::io_service &io_service() { return service; }
    template<class R> void enqueue(enqueued_task<R> task)
    {
        service.post(task);
    }
    template<class F> shared_future<typename std::result_of<F()>::type> enqueue(F f)
    {
        typedef typename std::result_of<F()>::type R;
        enqueued_task<R()> out(std::move(f));
        auto ret(out.get_future());
        service.post(out);
        return ret;
    }
};

class std_thread_pool : public thread_source {
    class worker
    {
        std_thread_pool *pool;
    public:
        explicit worker(std_thread_pool *p) : pool(p) { }
        void operator()()
        {
            detail::set_threadname("boost::afio::std_thread_pool worker");
            try
            {
                pool->service.run();
            }
            catch(...)
            {
              BOOST_AFIO_LOG_FATAL_EXIT("WARNING: ASIO exits via " << detail::output_exception_info << " which shouldn't happen." << std::endl);
            }
        }
    };
    friend class worker;

    asio::io_service service;
    std::unique_ptr<asio::io_service::work> working;
    std::vector< std::unique_ptr<thread> > workers;
public:
    explicit std_thread_pool(size_t no) : thread_source(service), working(detail::make_unique<asio::io_service::work>(service))
    {
        add_workers(no);
    }
    void add_workers(size_t no)
    {
        workers.reserve(workers.size()+no);
        for(size_t n=0; n<no; n++)
            workers.push_back(detail::make_unique<thread>(worker(this)));
    }
    void destroy()
    {
        if(!service.stopped())
        {
            // Tell the threads there is no more work to do
            working.reset();
            for(auto &i: workers) { i->join(); }
            workers.clear();
            // For some reason ASIO occasionally thinks there is still more work to do
            if(!service.stopped())
                service.run();
            service.stop();
            service.reset();
        }
    }
    ~std_thread_pool() final
    {
        destroy();
    }
};
BOOST_AFIO_HEADERS_ONLY_FUNC_SPEC std::shared_ptr<std_thread_pool> process_threadpool();


class dispatcher;
using dispatcher_ptr = std::shared_ptr<dispatcher>;
template<class T=void> class future;
struct path_req;
template<class T> struct io_req;
struct enumerate_req;
struct lock_req;
namespace detail {
    struct async_io_handle_posix;
    struct async_io_handle_windows;
    struct dispatcher_p;
    class async_file_io_dispatcher_compat;
    class async_file_io_dispatcher_windows;
    class async_file_io_dispatcher_linux;
    class async_file_io_dispatcher_qnx;
    struct immediate_async_ops;
    template<bool for_writing> class io_req_impl;
}

enum class path_normalise
{
  dos,         
  guid_volume, 
  guid_all     
};

class path : protected filesystem::path
{
  void int_regularise()
  {
#ifdef _MSC_VER
#pragma warning(push)
#pragma warning(disable: 6326) // comparison of constants
#endif
    if(preferred_separator!='/')
      make_preferred();
#ifdef _MSC_VER
#pragma warning(pop)
#endif
#ifdef WIN32
    // Need to strip off any win32 prefixing, and instead prefix any drive letters
    bool isExtendedPath=false, isDevicePath=false;
    if(native().size()>=4)
    {
#ifndef NDEBUG
      if(native()[0]=='\\' && native()[1]=='?' && native()[2]=='?' && native()[3]=='\\')
      {
        assert(!(native()[0]=='\\' && native()[1]=='?' && native()[2]=='?' && native()[3]=='\\'));
      }
#endif
      isExtendedPath=(native()[0]=='\\' && native()[1]=='\\' && native()[2]=='?' && native()[3]=='\\');
      isDevicePath=(native()[0]=='\\' && native()[1]=='\\' && native()[2]=='.' && native()[3]=='\\');
    }
    bool hasDriveLetter=(isalpha(native()[((int) isExtendedPath+(int) isDevicePath)*4+0]) && native()[((int) isExtendedPath+(int) isDevicePath)*4+1]==':');
    if(hasDriveLetter && (isExtendedPath || isDevicePath))
    {
      filesystem::path::string_type &me=const_cast<filesystem::path::string_type &>(native());
      me[1]=me[2]='?';
    }
    else if(hasDriveLetter)
    {
      filesystem::path::string_type &me=const_cast<filesystem::path::string_type &>(native());
      me=L"\\??\\"+me;
    }
    else if(isExtendedPath || isDevicePath)
    {
      filesystem::path::string_type &me=const_cast<filesystem::path::string_type &>(native());
      me=me.substr(isDevicePath ? 3 : 4);
    }
#endif
  }
  friend struct detail::async_io_handle_windows;
  struct direct { };
  path(filesystem::path &&p, direct) : filesystem::path(std::move(p)) { }
public:
  typedef filesystem::path::value_type value_type;
  typedef filesystem::path::string_type string_type;
  using filesystem::path::preferred_separator;
  struct make_absolute;

  path() {}
  path(const path &p) : filesystem::path(p) { }
  path(const filesystem::path &p) : filesystem::path(p) { int_regularise(); }
  path(const char *p) : filesystem::path(p) { int_regularise(); }
#ifdef WIN32

  path(const wchar_t *p) : filesystem::path(p) { int_regularise(); }
  path(const std::string &p) : filesystem::path(p) { int_regularise(); }
#endif

  path(const string_type &p) : filesystem::path(p) { int_regularise(); }
  path(path &&p) noexcept : filesystem::path(std::move(p)) { }
  path(filesystem::path &&p) : filesystem::path(std::move(p)) { int_regularise(); }
#ifdef WIN32

  path(std::string &&p) : filesystem::path(std::move(p)) { int_regularise(); }
#endif

  path(string_type &&p) : filesystem::path(std::move(p)) { int_regularise(); }
  //template<class Source> path(const Source &source) : filesystem::path(source) { int_regularise(); }
  template <class InputIterator> path(InputIterator begin, InputIterator end) : filesystem::path(begin, end) { int_regularise(); }
  path& operator=(const path& p) { filesystem::path::operator=(filesystem::path(p)); return *this; }
  path& operator=(path&& p) noexcept { filesystem::path::operator=(static_cast<filesystem::path &&>(p)); return *this; }
  //template <class Source> path& operator=(Source const& source) { filesystem::path::operator=(source); int_regularise(); return *this; }

  template <class Source>
    path& assign(Source const& source) { filesystem::path::assign(source); return *this; }
  template <class InputIterator>
    path& assign(InputIterator begin, InputIterator end) { filesystem::path::assign(begin, end); return *this; }
  path& operator/=(const path& p) { filesystem::path::operator/=(filesystem::path(p)); return *this; }
  template <class Source>
    path& operator/=(Source const& source) { filesystem::path::operator/=(source); return *this; }
  template <class Source>
    path& append(Source const& source) { filesystem::path::append(source); return *this; }
  template <class InputIterator>
    path& append(InputIterator begin, InputIterator end) { filesystem::path::append(begin, end); return *this; }

  path& operator+=(const path& x) { filesystem::path::operator+=(filesystem::path(x)); return *this; }
  path& operator+=(const string_type& x) { filesystem::path::operator+=(x); return *this; }
  path& operator+=(const value_type* x) { filesystem::path::operator+=(x); return *this; }
  path& operator+=(value_type x) { filesystem::path::operator+=(x); return *this; }
  template <class Source>
    path& operator+=(Source const& x) { filesystem::path::operator+=(x); return *this; }
  template <class Source>
    path& concat(Source const& x) { filesystem::path::concat(x); return *this; }
  template <class InputIterator>
    path& concat(InputIterator begin, InputIterator end) { filesystem::path::concat(begin, end); return *this; }
  
  using filesystem::path::clear;
  path& make_preferred() { filesystem::path::make_preferred(); return *this; }
  path& remove_filename() { filesystem::path::remove_filename(); return *this; }
  path& replace_extension(const path& new_extension = path()) { filesystem::path::replace_extension(filesystem::path(new_extension)); return *this; }
  using filesystem::path::swap;

  using filesystem::path::native;
  using filesystem::path::c_str;
  using filesystem::path::string;
  using filesystem::path::wstring;
  using filesystem::path::generic_string;
  using filesystem::path::compare;

  path  root_name() const { return path(filesystem::path::root_name(), direct()); }
  path  root_directory() const { return path(filesystem::path::root_directory(), direct()); }
  path  root_path() const { return path(filesystem::path::root_path(), direct()); }
  path  relative_path() const { return path(filesystem::path::relative_path(), direct()); }
  path  parent_path() const { return path(filesystem::path::parent_path(), direct()); }
#ifdef BOOST_AFIO_USE_LEGACY_FILESYSTEM_SEMANTICS
  path  filename() const { return path(filesystem::path::leaf(), direct()); }
#else
  path  filename() const { return path(filesystem::path::filename(), direct()); }
#endif
  path  stem() const { return path(filesystem::path::stem(), direct()); }
  path  extension() const { return path(filesystem::path::extension(), direct()); }

  using filesystem::path::empty;
  using filesystem::path::has_root_name;
  using filesystem::path::has_root_directory;
  using filesystem::path::has_root_path;
  using filesystem::path::has_relative_path;
  using filesystem::path::has_parent_path;
  using filesystem::path::has_filename;
  using filesystem::path::has_stem;
  using filesystem::path::has_extension;
  using filesystem::path::is_absolute;
  using filesystem::path::is_relative;

  // TODO FIXME: Need our own iterator here
  typedef filesystem::path::iterator iterator;
  typedef filesystem::path::const_iterator const_iterator;

  iterator begin() const { return filesystem::path::begin(); }
  iterator end() const { return filesystem::path::end(); }
  
  filesystem::path filesystem_path() const
  {
#ifdef WIN32
    bool isSymlinkedDosPath=(native()[0]=='\\' && native()[1]=='?' && native()[2]=='?' && native()[3]=='\\');
    if(isSymlinkedDosPath)
    {
      filesystem::path::string_type p(native());
      p[1]='\\';
      return p;
    }
    else
      return filesystem::path(L"\\\\.")/filesystem::path(*this);
#else
    return *this;
#endif
  }
  friend inline bool operator<(const path& lhs, const path& rhs);
  friend inline bool operator<=(const path& lhs, const path& rhs);
  friend inline bool operator>(const path& lhs, const path& rhs);
  friend inline bool operator>=(const path& lhs, const path& rhs);
  friend inline bool operator==(const path& lhs, const path& rhs);
  friend inline bool operator!=(const path& lhs, const path& rhs);
  friend inline path operator/(const path& lhs, const path& rhs);
  friend inline std::ostream &operator<<(std::ostream &s, const path &p);
  friend struct path_hash;
#ifdef WIN32
#ifdef _MSC_VER
  friend BOOST_AFIO_HEADERS_ONLY_FUNC_SPEC filesystem::path normalise_path(path p, path_normalise type);
#else
  friend filesystem::path normalise_path(path p, path_normalise type);
#endif
#else
  friend inline filesystem::path normalise_path(path p, path_normalise type);
#endif
};
inline bool operator<(const path& lhs, const path& rhs) { return filesystem::path(lhs)<filesystem::path(rhs); }
inline bool operator<=(const path& lhs, const path& rhs) { return filesystem::path(lhs)<=filesystem::path(rhs); }
inline bool operator>(const path& lhs, const path& rhs) { return filesystem::path(lhs)>filesystem::path(rhs); }
inline bool operator>=(const path& lhs, const path& rhs) { return filesystem::path(lhs)>=filesystem::path(rhs); }
inline bool operator==(const path& lhs, const path& rhs) { return filesystem::path(lhs)==filesystem::path(rhs); }
inline bool operator!=(const path& lhs, const path& rhs) { return filesystem::path(lhs)!=filesystem::path(rhs); }
inline path operator/(const path& lhs, const path& rhs) { return path(filesystem::path(lhs)/filesystem::path(rhs), path::direct()); }
inline std::ostream &operator<<(std::ostream &s, const path &p) { return s << filesystem::path(p); }
struct path::make_absolute : public path
{
  make_absolute(const path &p) : path(p)
  {
    if(native()[0]!=preferred_separator)
      *this=filesystem::absolute(std::move(*this));
  }
  make_absolute(path &&p) : path(std::move(p))
  {
    if(native()[0]!=preferred_separator)
      *this=filesystem::absolute(std::move(*this));
  }
  template<class T, typename=typename std::enable_if<std::is_constructible<filesystem::path, T>::value>::type> make_absolute(T &&p) : path(filesystem::absolute(std::forward<T>(p))) { }
};
struct path_hash
{
  std::hash<path::string_type> hasher;
public:
    size_t operator()(const path &p) const
    {
      return hasher(p.native());
    }
};

#ifdef WIN32
BOOST_AFIO_HEADERS_ONLY_FUNC_SPEC filesystem::path normalise_path(path p, path_normalise type=path_normalise::dos);
#else
inline filesystem::path normalise_path(path p, path_normalise type=path_normalise::dos) { return p; }
#endif


#define BOOST_AFIO_DECLARE_CLASS_ENUM_AS_BITFIELD(type) \
inline constexpr type operator&(type a, type b) \
{ \
    return static_cast<type>(static_cast<size_t>(a) & static_cast<size_t>(b)); \
} \
inline constexpr type operator|(type a, type b) \
{ \
    return static_cast<type>(static_cast<size_t>(a) | static_cast<size_t>(b)); \
} \
inline constexpr type operator~(type a) \
{ \
    return static_cast<type>(~static_cast<size_t>(a)); \
} \
inline constexpr bool operator!(type a) \
{ \
    return 0==static_cast<size_t>(a); \
}



enum class file_flags : size_t
{
    none=0,             
    read=1,             
    write=2,            
    read_write=3,       
    append=4,           
    truncate=8,         
    create=16,          
    create_only_if_not_exist=32, 
    create_compressed=64, 

    will_be_sequentially_accessed=128, 
    will_be_randomly_accessed=256, 
    no_sparse=512,      

    hold_parent_open=(1<<10),        
    unique_directory_handle=(1<<11), 
    no_race_protection=(1<<12),      
    temporary_file=(1<<13),          
    delete_on_close=(1<<14),         

    os_direct=(1<<16),      
    os_lockable=(1<<17),    // Deliberately undocumented

    always_sync=(1<<24),    
    sync_on_close=(1<<25),  

    int_hold_parent_open_nested=(1<<27), 
    int_file_share_delete=(1<<28), 
    int_opening_link=(1<<29), 
    int_opening_dir=(1<<30) 
};
BOOST_AFIO_DECLARE_CLASS_ENUM_AS_BITFIELD(file_flags)


enum class async_op_flags : size_t
{
    none=0,                 
    immediate=1             
};
BOOST_AFIO_DECLARE_CLASS_ENUM_AS_BITFIELD(async_op_flags)

namespace detail {
    enum class OpType
    {
        Unknown,
        UserCompletion,
        dir,
        rmdir,
        file,
        rmfile,
        symlink,
        rmsymlink,
        sync,
        close,
        read,
        write,
        truncate,
        barrier,
        enumerate,
        adopt,
        zero,
        extents,
        statfs,
        lock,

        Last
    };
    static const char *optypes[]={
        "unknown",
        "UserCompletion",
        "dir",
        "rmdir",
        "file",
        "rmfile",
        "symlink",
        "rmsymlink",
        "sync",
        "close",
        "read",
        "write",
        "truncate",
        "barrier",
        "enumerate",
        "adopt",
        "zero",
        "extents",
        "statfs",
        "lock"
    };
    static_assert(static_cast<size_t>(OpType::Last)==sizeof(optypes)/sizeof(*optypes), "You forgot to fix up the strings matching OpType");

    enum class unit_testing_flags : size_t
    {
        none=0,                  
        no_symbol_lookup=(1<<0)  
    };
    BOOST_AFIO_DECLARE_CLASS_ENUM_AS_BITFIELD(unit_testing_flags)
}

class handle;
using handle_ptr = std::shared_ptr<handle>;

enum class metadata_flags : size_t
{
    None=0,
    dev=1<<0,
    ino=1<<1,
    type=1<<2,
    perms=1<<3,
    nlink=1<<4,
    uid=1<<5,
    gid=1<<6,
    rdev=1<<7,
    atim=1<<8,
    mtim=1<<9,
    ctim=1<<10,
    size=1<<11,
    allocated=1<<12,
    blocks=1<<13,
    blksize=1<<14,
    flags=1<<15,
    gen=1<<16,
    birthtim=1<<17,
    sparse=1<<24,
    compressed=1<<25,
    reparse_point=1<<26,
    All=(size_t)-1       
};
BOOST_AFIO_DECLARE_CLASS_ENUM_AS_BITFIELD(metadata_flags)
struct stat_t
{
#ifndef WIN32
    uint64_t        st_dev;                       
#endif
    uint64_t        st_ino;                       
    filesystem::file_type st_type;                
#ifndef WIN32
#ifndef DOXYGEN_SHOULD_SKIP_THIS
    uint16_t        st_perms;
#else
    filesystem::perms st_perms;                   
#endif
#endif
    int16_t         st_nlink;                     
#ifndef WIN32
    int16_t         st_uid;                       
    int16_t         st_gid;                       
    dev_t           st_rdev;                      
#endif
    chrono::system_clock::time_point st_atim;     
    chrono::system_clock::time_point st_mtim;     
    chrono::system_clock::time_point st_ctim;     
    off_t           st_size;                      
    off_t           st_allocated;                 
    off_t           st_blocks;                    
    uint16_t        st_blksize;                   
    uint32_t        st_flags;                     
    uint32_t        st_gen;                       
    chrono::system_clock::time_point st_birthtim; 
    unsigned        st_sparse : 1;                
    unsigned        st_compressed : 1;            
    unsigned        st_reparse_point : 1;         

    stat_t() { }
    stat_t(std::nullptr_t) :
#ifndef WIN32
        st_dev(0),
#endif
        st_ino(0),
#ifdef BOOST_AFIO_USE_LEGACY_FILESYSTEM_SEMANTICS
        st_type(filesystem::file_type::type_unknown),
#else
        st_type(filesystem::file_type::unknown),
#endif
#ifndef WIN32
        st_perms(0),
#endif
        st_nlink(0),
#ifndef WIN32
        st_uid(0), st_gid(0), st_rdev(0),
#endif
        st_size(0), st_allocated(0), st_blocks(0), st_blksize(0), st_flags(0), st_gen(0), st_sparse(0), st_compressed(0), st_reparse_point(0) { }
};

enum class fs_metadata_flags : size_t
{
    None=0,
    flags=1<<1,
    bsize=1<<2,
    iosize=1<<3,
    blocks=1<<4,
    bfree=1<<5,
    bavail=1<<6,
    files=1<<7,
    ffree=1<<8,
    namemax=1<<9,
    owner=1<<10,
    fsid=1<<11,
    fstypename=1<<12,
    mntfromname=1<<13,
    mntonname=1<<14,
    All=(size_t)-1       
};
BOOST_AFIO_DECLARE_CLASS_ENUM_AS_BITFIELD(fs_metadata_flags)
struct statfs_t
{
     struct f_flags_t
     {
        uint32_t rdonly : 1;          
        uint32_t noexec : 1;          
        uint32_t nosuid : 1;          
        uint32_t acls : 1;            
        uint32_t xattr : 1;           
        uint32_t compression : 1;     
        uint32_t extents : 1;         
        uint32_t filecompression : 1; 
     } f_flags;                           
     uint64_t f_bsize;                    
     uint64_t f_iosize;                   
     uint64_t f_blocks;                   
     uint64_t f_bfree;                    
     uint64_t f_bavail;                   
     uint64_t f_files;                    
     uint64_t f_ffree;                    
     uint32_t f_namemax;                  
#ifndef WIN32
     int16_t  f_owner;                    
#endif
     uint64_t f_fsid[2];                  
     std::string f_fstypename;            
     std::string f_mntfromname;           
     path f_mntonname;        
     statfs_t()
     {
       size_t frontbytes=((char *) &f_fstypename)-((char *) this);
       memset(this, 0xff, frontbytes);
       memset(this, 0, sizeof(f_flags));
     }
};

class BOOST_AFIO_DECL directory_entry
{
    friend class detail::async_file_io_dispatcher_compat;
    friend class detail::async_file_io_dispatcher_windows;
    friend class detail::async_file_io_dispatcher_linux;
    friend class detail::async_file_io_dispatcher_qnx;

    path::string_type leafname;
    stat_t stat;
    metadata_flags have_metadata;
    BOOST_AFIO_HEADERS_ONLY_MEMFUNC_SPEC void _int_fetch(metadata_flags wanted, handle_ptr dirh);
public:
    directory_entry() : stat(nullptr), have_metadata(metadata_flags::None) { }
    directory_entry(path::string_type _leafname, stat_t __stat, metadata_flags _have_metadata) : leafname(_leafname), stat(__stat), have_metadata(_have_metadata) { }
    directory_entry(const directory_entry &) = default;
    directory_entry &operator=(const directory_entry &) = default;
    directory_entry(directory_entry &&o) noexcept : leafname(std::move(o.leafname)), stat(std::move(o.stat)), have_metadata(std::move(o.have_metadata)) { }
    directory_entry &operator=(directory_entry &&o) noexcept
    {
        leafname=std::move(o.leafname);
        stat=std::move(o.stat);
        have_metadata=std::move(o.have_metadata);
        return *this;
    }

    bool operator==(const directory_entry& rhs) const noexcept { return leafname == rhs.leafname; }
    bool operator!=(const directory_entry& rhs) const noexcept { return leafname != rhs.leafname; }
    bool operator< (const directory_entry& rhs) const noexcept { return leafname < rhs.leafname; }
    bool operator<=(const directory_entry& rhs) const noexcept { return leafname <= rhs.leafname; }
    bool operator> (const directory_entry& rhs) const noexcept { return leafname > rhs.leafname; }
    bool operator>=(const directory_entry& rhs) const noexcept { return leafname >= rhs.leafname; }
    path::string_type name() const noexcept { return leafname; }
    metadata_flags metadata_ready() const noexcept { return have_metadata; }
    metadata_flags fetch_metadata(handle_ptr dirh, metadata_flags wanted)
    {
        metadata_flags tofetch;
        wanted=wanted&metadata_supported();
        tofetch=wanted&~have_metadata;
        if(!!tofetch) _int_fetch(tofetch, dirh);
        return have_metadata;
    }
    stat_t fetch_lstat(handle_ptr dirh, metadata_flags wanted=directory_entry::metadata_fastpath())
    {
        fetch_metadata(dirh, wanted);
        return stat;
    }
#ifndef DOXYGEN_SHOULD_SKIP_THIS
#define BOOST_AFIO_DIRECTORY_ENTRY_ACCESS_METHOD(field) \
decltype(stat_t().st_##field) st_##field() const { if(!(have_metadata&metadata_flags::field)) { BOOST_AFIO_THROW(std::runtime_error("Field st_" #field " not present.")); } return stat.st_##field; } \
decltype(stat_t().st_##field) st_##field(handle_ptr dirh) { if(!(have_metadata&metadata_flags::field)) { _int_fetch(metadata_flags::field, dirh); } return stat.st_##field; }
#else
#define BOOST_AFIO_DIRECTORY_ENTRY_ACCESS_METHOD(field) \
fieldtype st_##field(handle_ptr dirh=handle_ptr()) { if(!(have_metadata&metadata_flags::field)) { _int_fetch(metadata_flags::field, dirh); } return stat.st_##field; }
#endif
#ifndef WIN32

    BOOST_AFIO_DIRECTORY_ENTRY_ACCESS_METHOD(dev)
#endif

    BOOST_AFIO_DIRECTORY_ENTRY_ACCESS_METHOD(ino)
    BOOST_AFIO_DIRECTORY_ENTRY_ACCESS_METHOD(type)
#ifndef WIN32

    BOOST_AFIO_DIRECTORY_ENTRY_ACCESS_METHOD(perms)
#endif

    BOOST_AFIO_DIRECTORY_ENTRY_ACCESS_METHOD(nlink)
#ifndef WIN32

    BOOST_AFIO_DIRECTORY_ENTRY_ACCESS_METHOD(uid)
    BOOST_AFIO_DIRECTORY_ENTRY_ACCESS_METHOD(gid)
    BOOST_AFIO_DIRECTORY_ENTRY_ACCESS_METHOD(rdev)
#endif

    BOOST_AFIO_DIRECTORY_ENTRY_ACCESS_METHOD(atim)
    BOOST_AFIO_DIRECTORY_ENTRY_ACCESS_METHOD(mtim)
    BOOST_AFIO_DIRECTORY_ENTRY_ACCESS_METHOD(ctim)
    BOOST_AFIO_DIRECTORY_ENTRY_ACCESS_METHOD(size)
    BOOST_AFIO_DIRECTORY_ENTRY_ACCESS_METHOD(allocated)
    BOOST_AFIO_DIRECTORY_ENTRY_ACCESS_METHOD(blocks)
    BOOST_AFIO_DIRECTORY_ENTRY_ACCESS_METHOD(blksize)
    BOOST_AFIO_DIRECTORY_ENTRY_ACCESS_METHOD(flags)
    BOOST_AFIO_DIRECTORY_ENTRY_ACCESS_METHOD(gen)
    BOOST_AFIO_DIRECTORY_ENTRY_ACCESS_METHOD(birthtim)

    static BOOST_AFIO_HEADERS_ONLY_MEMFUNC_SPEC metadata_flags metadata_supported() noexcept;
    static BOOST_AFIO_HEADERS_ONLY_MEMFUNC_SPEC metadata_flags metadata_fastpath() noexcept;
    static BOOST_AFIO_HEADERS_ONLY_MEMFUNC_SPEC size_t compatibility_maximum() noexcept;
};

struct directory_entry_hash
{
public:
#ifdef _MSC_VER
#pragma warning(push)
#pragma warning(disable: 4310) // cast truncates constant value
#endif
    size_t operator()(const directory_entry &p) const
    {
        size_t seed = (size_t) 0x9ddfea08eb382d69ULL;
        detail::hash_combine(seed, p.st_ino());
        if(!!(directory_entry::metadata_supported() & metadata_flags::birthtim))
            detail::hash_combine(seed, p.st_birthtim().time_since_epoch().count());
        return seed;
    }
#ifdef _MSC_VER
#pragma warning(pop)
#endif
};

class handle : public std::enable_shared_from_this<handle>
{
    friend class dispatcher;
    friend struct detail::async_io_handle_posix;
    friend struct detail::async_io_handle_windows;
    friend class detail::async_file_io_dispatcher_compat;
    friend class detail::async_file_io_dispatcher_windows;
    friend class detail::async_file_io_dispatcher_linux;
    friend class detail::async_file_io_dispatcher_qnx;

    dispatcher *_parent;
    chrono::system_clock::time_point _opened;
    file_flags _flags;
protected:
    handle_ptr dirh;
    atomic<off_t> bytesread, byteswritten, byteswrittenatlastfsync;
    handle(dispatcher *parent, file_flags flags) : _parent(parent), _opened(chrono::system_clock::now()), _flags(flags), bytesread(0), byteswritten(0), byteswrittenatlastfsync(0) { }
    BOOST_AFIO_HEADERS_ONLY_VIRTUAL_SPEC void close() BOOST_AFIO_HEADERS_ONLY_VIRTUAL_UNDEFINED_SPEC
public:
    BOOST_AFIO_HEADERS_ONLY_VIRTUAL_SPEC ~handle() { }
    dispatcher *parent() const { return _parent; }
    handle_ptr container() const { return dirh; }
    enum class open_states
    {
      closed, 
      open,   
      opendir 
    };
    BOOST_AFIO_HEADERS_ONLY_VIRTUAL_SPEC open_states is_open() const BOOST_AFIO_HEADERS_ONLY_VIRTUAL_UNDEFINED_SPEC
    BOOST_AFIO_HEADERS_ONLY_VIRTUAL_SPEC void *native_handle() const BOOST_AFIO_HEADERS_ONLY_VIRTUAL_UNDEFINED_SPEC
    const chrono::system_clock::time_point &opened() const { return _opened; }
    BOOST_AFIO_HEADERS_ONLY_VIRTUAL_SPEC BOOST_AFIO_V2_NAMESPACE::path path(bool refresh=false) BOOST_AFIO_HEADERS_ONLY_VIRTUAL_UNDEFINED_SPEC
    BOOST_AFIO_HEADERS_ONLY_VIRTUAL_SPEC BOOST_AFIO_V2_NAMESPACE::path path() const BOOST_AFIO_HEADERS_ONLY_VIRTUAL_UNDEFINED_SPEC
    file_flags flags() const { return _flags; }
    bool opened_as_file() const { return !(_flags&file_flags::int_opening_dir) && !(_flags&file_flags::int_opening_link); }
    bool opened_as_dir() const { return !!(_flags&file_flags::int_opening_dir); }
    bool opened_as_symlink() const { return !!(_flags&file_flags::int_opening_link); }
    bool available_to_directory_cache() const { return opened_as_dir() && !(_flags&file_flags::unique_directory_handle) && !!(_flags&file_flags::read) && !(_flags&file_flags::write); }
    off_t read_count() const { return bytesread; }
    off_t write_count() const { return byteswritten; }
    off_t write_count_since_fsync() const { return byteswritten-byteswrittenatlastfsync; }
    BOOST_AFIO_HEADERS_ONLY_VIRTUAL_SPEC directory_entry direntry(metadata_flags wanted=directory_entry::metadata_fastpath()) BOOST_AFIO_HEADERS_ONLY_VIRTUAL_UNDEFINED_SPEC
    stat_t lstat(metadata_flags wanted=directory_entry::metadata_fastpath())
    {
        directory_entry de(direntry(wanted));
        return de.fetch_lstat(handle_ptr() /* actually unneeded */, wanted);
    }
    BOOST_AFIO_HEADERS_ONLY_VIRTUAL_SPEC BOOST_AFIO_V2_NAMESPACE::path target() BOOST_AFIO_HEADERS_ONLY_VIRTUAL_UNDEFINED_SPEC
    struct BOOST_AFIO_DECL mapped_file
    {
      friend class handle;
      handle_ptr h;   
      void *addr;     
      size_t length;  
      off_t offset;   
      mapped_file(const mapped_file &) = delete;
      mapped_file(mapped_file &&) = delete;
      mapped_file &operator=(const mapped_file &) = delete;
      mapped_file &operator=(mapped_file &&) = delete;
      mapped_file(handle_ptr _h, void *_addr, size_t _length, off_t _offset) : h(std::move(_h)), addr(_addr), length(_length), offset(_offset) { }
      ~mapped_file();
    };
    using mapped_file_ptr = std::unique_ptr<mapped_file>;
    BOOST_AFIO_HEADERS_ONLY_VIRTUAL_SPEC mapped_file_ptr map_file(size_t length = (size_t)-1, off_t offset = 0, bool read_only = false) { return nullptr; }
    BOOST_AFIO_HEADERS_ONLY_VIRTUAL_SPEC void link(const path_req &req) BOOST_AFIO_HEADERS_ONLY_VIRTUAL_UNDEFINED_SPEC
    BOOST_AFIO_HEADERS_ONLY_VIRTUAL_SPEC void unlink() BOOST_AFIO_HEADERS_ONLY_VIRTUAL_UNDEFINED_SPEC
    BOOST_AFIO_HEADERS_ONLY_VIRTUAL_SPEC void atomic_relink(const path_req &req) BOOST_AFIO_HEADERS_ONLY_VIRTUAL_UNDEFINED_SPEC

#if 0
    // Undocumented deliberately
    enum class change_flags : size_t
    {
      created=(1<<0),    // NOTE_EXTEND,                       IN_CREATE, 
      renamed=(1<<1),    // NOTE_RENAME,       IN_MOVED_FROM/IN_MOVED_TO, 
      deleted=(1<<2),    // NOTE_DELETE,                       IN_DELETE, 
      attributes=(1<<3), // NOTE_ATTRIB,                       IN_ATTRIB, 
      opened=(1<<4),     //           ?,                         IN_OPEN, 
      closed=(1<<5),     //           ?, IN_CLOSE_WRITE/IN_CLOSE_NOWRITE, 
      read=(1<<6),       //           ?,                       IN_ACCESS, 
      written=(1<<7),    //  NOTE_WRITE,                       IN_MODIFY, 
      extended=(1<<8),   // NOTE_EXTEND,                               ?, 
      
      region_locked=(1<<16),
      region_timedout=(1<<17),
      region_unlocked=(1<<18)
    };
    // Undocumented deliberately
    struct change_listener : public std::enable_shared_from_this<change_listener>
    {
      virtual ~change_listener() { }
      virtual void operator()(handle *h, change_flags changed, void *additional)=0;
    };
    // Undocumented deliberately
    BOOST_AFIO_HEADERS_ONLY_VIRTUAL_SPEC void listen(const std::vector<std::pair<change_flags>, std::shared_ptr<change_listener>> &listeners) BOOST_AFIO_HEADERS_ONLY_VIRTUAL_UNDEFINED_SPEC
    // Undocumented deliberately
    BOOST_AFIO_HEADERS_ONLY_VIRTUAL_SPEC void unlisten(const std::vector<std::pair<change_flags>, std::shared_ptr<change_listener>> &listeners) BOOST_AFIO_HEADERS_ONLY_VIRTUAL_UNDEFINED_SPEC
#endif
};

BOOST_AFIO_HEADERS_ONLY_FUNC_SPEC dispatcher_ptr current_dispatcher(option<dispatcher_ptr> new_dispatcher = empty);

class current_dispatcher_guard
{
  dispatcher_ptr _old;
public:
  current_dispatcher_guard(dispatcher_ptr _new) : _old(current_dispatcher(_new)) { }
  ~current_dispatcher_guard() { current_dispatcher(_old); }
  void release() { current_dispatcher(_old); _old.reset(); }
  void dismiss() { _old.reset(); }
  void reset(dispatcher_ptr p) { _old=p; }
};

template<class T> struct is_future : std::false_type { };
template<class T> struct is_future<future<T>> : std::true_type {};

// Temporary friends for future<>
namespace detail
{
  struct barrier_count_completed_state;
  template<bool rethrow, class Iterator> inline stl_future<std::vector<handle_ptr>> when_all_ops(Iterator first, Iterator last);
  template<bool rethrow, class Iterator> inline stl_future<handle_ptr> when_any_ops(Iterator first, Iterator last);

  // Shim code for lightweight future continuations
  template<class R, bool return_is_lightweight_future=is_lightweight_future<R>::value, bool return_is_afio_future=is_future<R>::value> struct continuation_return_type { using future_type = future<R>; using promise_type = void; };
  template<class R, bool _> struct continuation_return_type<R, true, _> { using future_type = R; using promise_type = typename future_type::promise_type; };
  template<class R, bool _> struct continuation_return_type<R, _, true> { using future_type = R; using promise_type = void; };
  template<class future_type, class promise_type> struct do_continuation;
}

template<> class future<void>
{
    // Temporary friends until lightweight future promise comes in
    friend struct detail::barrier_count_completed_state;
    template<bool rethrow, class Iterator> friend inline stl_future<std::vector<handle_ptr>> detail::when_all_ops(Iterator first, Iterator last);
    template<bool rethrow, class Iterator> friend inline stl_future<handle_ptr> detail::when_any_ops(Iterator first, Iterator last);

    dispatcher *_parent;              
    size_t _id;                                          
    shared_future<handle_ptr> _h;  
public:
    future(future<void> &&o, stl_future<void> &&result) : future<void>(std::move(o)) { }
    // NOTE TO SELF: MAKE THE CONSTRUCTORS AND MEMBER FUNCTIONS constexpr WHEN I MERGE LIGHTWEIGHT FUTURE-PROMISES

    using value_type = void;
    using error_type = error_code;
    using exception_type = exception_ptr;

    future() : _parent(nullptr), _id(0) { }
    future(const future &o) = default;
    future(future &&o) = default;
    future(dispatcher *parent, size_t id, shared_future<handle_ptr> handle, bool check_handle=true, bool validate=true) : _parent(parent), _id(id), _h(std::move(handle)) { if(validate) _validate(check_handle); }
    future(handle_ptr _handle, bool check_handle=true, bool validate=true) : _parent(_handle->parent()), _id((size_t)-1) { promise<handle_ptr> p; p.set_value(std::move(_handle)); _h=p.get_future(); if(validate) _validate(check_handle); }
    future(dispatcher *parent, size_t id) : _parent(parent), _id(id) { }
    future &operator=(const future &o) { _parent = o._parent; _id = o._id; _h = o._h; return *this; }
    future &operator=(future &&o) noexcept { _parent = std::move(o._parent); _id = std::move(o._id); _h = std::move(o._h); return *this; }

    bool valid() const noexcept { return _parent && _id; }
    explicit operator bool() const noexcept { return has_value(); }
    bool is_ready() const noexcept
    {
      return valid() || _h.wait_for(chrono::seconds(0)) == future_status::ready;
    }
    bool has_value() const noexcept { return is_ready() && !has_exception(); }
    bool has_error() const noexcept
    {
      if (!is_ready())
        return false;
      error_type ec = get_error();
      return ec && ec.category() != monad_category();
    }
    bool has_exception(bool only_exception = false) const noexcept
    {
      if (!is_ready())
        return false;
      return !!get_exception();
    }

    dispatcher *parent() const noexcept { return _parent; }
    size_t id() const noexcept { return _id; }
    handle_ptr get_handle(bool return_null_if_errored=false) const
    {
        if(!_parent && !_id)
            return handle_ptr();
        // std::shared_future in older libstdc++ does not have a const get().
        if(!return_null_if_errored)
            return const_cast<future *>(this)->_h.get();
        auto e=get_exception_ptr(_h);
        return e ? handle_ptr() : const_cast<future *>(this)->_h.get();
    }
    handle_ptr get_handle(error_type &ec) const
    {
      if (!_parent && !_id)
        return handle_ptr();
      ec = get_error();
      return ec ? handle_ptr() : const_cast<future *>(this)->_h.get();
    }
    const handle &operator *() const { return *get_handle(); }
    handle &operator *() { return *get_handle(); }
    const handle *operator->() const { return get_handle().get(); }
    handle *operator->() { return get_handle().get(); }
    void get()
    {
      if (!valid())
        throw future_error(future_errc::no_state);
      _h.get();
    }
    error_type get_error() const
    {
      if (!valid())
        throw future_error(future_errc::no_state);
      auto e = get_exception_ptr(_h);
      if (e)
      {
        try
        {
          rethrow_exception(e);
        }
        catch (const system_error &_e)
        {
          return _e.code();
        }
        catch (...)
        {
          return error_type((int)monad_errc::exception_present, monad_category());
        }
      }
      return error_type();
    }
    exception_type get_exception() const
    {
      if (!valid())
        throw future_error(future_errc::no_state);
      return get_exception_ptr(_h);
    }
    void wait() const
    {
      if (!valid())
        throw future_error(future_errc::no_state);
      _h.wait();
    }
    template<class Rep, class Period> future_status wait_for(const chrono::duration<Rep, Period> &duration) const
    {
      if (!valid())
        throw future_error(future_errc::no_state);
      return _h.wait_for(duration);
    }
    template<class Clock, class Duration> future_status wait_until(const chrono::time_point<Clock, Duration> &deadline) const
    {
      if (!valid())
        throw future_error(future_errc::no_state);
      return _h.wait_until(deadline);
    }
    template<class U> auto then(U &&f) -> typename detail::continuation_return_type<decltype(f(*this))>::future_type
    {
      using future_type = typename detail::continuation_return_type<decltype(f(*this))>::future_type;
      using promise_type = typename detail::continuation_return_type<decltype(f(*this))>::promise_type;
      return detail::do_continuation<future_type, promise_type>()(parent(), this, std::forward<U>(f));
    }
    bool validate(bool check_handle=true) const
    {
        if(!valid()) return false;
        // If h is valid and ready and contains an exception, throw it now
        if(_h.valid() && BOOST_AFIO_V2_NAMESPACE::is_ready(_h))
        {
            if(check_handle)
                if(!const_cast<shared_future<handle_ptr> &>(_h).get().get())
                    return false;
        }
        return true;
    }
protected:
    void _validate(bool check_handle=true) const
    {
#if BOOST_AFIO_VALIDATE_INPUTS
        if(!validate(check_handle))
            BOOST_AFIO_THROW(std::invalid_argument("Inputs are invalid."));
#endif
    }
};
template<class T> class future : public future<void>
{
  stl_future<T> _result;
public:
  using value_type = T;

  future() = default;
  future(dispatcher *parent, size_t id, shared_future<handle_ptr> handle, stl_future<T> result, bool check_handle = true, bool validate = true) : future<void>(parent, id, std::move(handle), check_handle, validate), _result(std::move(result)) { }
  future(future<void> &&o, stl_future<T> &&result) : future<void>(std::move(o)), _result(std::move(result)) { }
  bool valid(bool just_handle=false) const noexcept { return future<void>::valid() && (just_handle || _result.valid()); }
  T get()
  {
    return _result.get();
  }
  template<class U> auto then(U &&f) -> typename detail::continuation_return_type<decltype(f(*this))>::future_type
  {
    using future_type = typename detail::continuation_return_type<decltype(f(*this))>::future_type;
    using promise_type = typename detail::continuation_return_type<decltype(f(*this))>::promise_type;
    return detail::do_continuation<future_type, promise_type>()(parent(), this, std::forward<U>(f));
  }
};

namespace detail
{
  // For continuations returning lightweight futures
  template<class future_type, class promise_type> struct do_continuation
  {
    template<class D, class U> future_type operator()(D *d, future<> *src, U &&f)
    {
      if (!d) d = current_dispatcher().get();
      auto p = std::make_shared<promise_type>();
      d->completion(*src, std::make_pair(async_op_flags::immediate, [f, p](size_t id, future<> _f) -> std::pair<bool, handle_ptr> {
        try
        {
          using result_type = decltype(f(_f));
          f(_f).then([p](const result_type &_f) {
            auto s(_f.get_state());
            try
            {
              p->set_state(std::move(s));
            }
            catch (...) { /* Really should filter for no_state but this is shim code */ }
          });
        }
        catch (...)
        {
          p->set_exception(current_exception());
        }
        return std::make_pair(true, _f.get_handle());
      }));
      return p->get_future();
    }
  };
  // For continuations returning shim AFIO futures or some naked type
  template<class R> struct do_continuation<future<R>, void>
  {
    template<class D, class T, class U> future<R> operator()(D *d, future<T> *src, U &&f)
    {
      if (!d) d = current_dispatcher().get();
      // TEMPORARY: For continuations taking a future<T> where T is not void
      // we have no way of passing the correct future to the continuation until
      // the lightweight future promise refactor
      //
      // So simply call the continuation now. When it calls .get() it will block.
      return f(*src);
    }
    template<class D, class U> future<> operator()(D *d, future<> *src, U &&f)
    {
      if (!d) d = current_dispatcher().get();
      return d->completion(*src, std::make_pair(async_op_flags::immediate, [f](size_t id, future<> _f) -> std::pair<bool, handle_ptr> {
        f(_f);
        return std::make_pair(true, _f.get_handle());
      }));
    }
  };
}

// This is a result_of filter to work around the weird mix of brittle decltype(), SFINAE incapable
// std::result_of and variadic template overload resolution rules in VS2013. Works on other compilers
// too of course, it simply prefilters out the call() overloads not matching the variadic overload.
namespace detail
{
#if 0
    template<class C, class... Args> struct vs2013_variadic_overload_resolution_workaround;
    // Match callable
    template<class R, class... OArgs, class... Args> struct vs2013_variadic_overload_resolution_workaround<R (*)(OArgs...), Args...>
    {
        typedef typename std::result_of<R(*)(Args...)>::type type;
    };
    // Match callable
    template<class R, class T, class... OArgs, class... Args> struct vs2013_variadic_overload_resolution_workaround<R (T::*)(OArgs...) const, Args...>
    {
        typedef typename std::result_of<R (T::*)(Args...) const>::type type;
    };
    // Match callable
    template<class R, class T, class... OArgs, class... Args> struct vs2013_variadic_overload_resolution_workaround<R (T::*const)(OArgs...) const, Args...>
    {
        typedef typename std::result_of<R (T::*const)(Args...) const>::type type;
    };
#else
    /*
    call(const std::vector<future> &ops             , const std::vector<std::function<R()>> &callables              );
    call(const std::vector<std::function<R()>> &callables                                                                );
    call(const future &req                          , std::function<R()> callback                                   );
    call(const future &req                          , C callback                                      , Args... args);
    */
    template<class C, class... Args> struct vs2013_variadic_overload_resolution_workaround
    {
        typedef typename std::result_of<C(Args...)>::type type;
    };
    // Disable C being a const std::vector<std::function<R()>> &callables
    template<class T, class... Args> struct vs2013_variadic_overload_resolution_workaround<std::vector<T>, Args...>;
#endif
    template<class Impl, class Handle> handle_ptr decode_relative_path(path_req &req, bool force_absolute=false);
}

class BOOST_AFIO_DECL dispatcher : public std::enable_shared_from_this<dispatcher>
{
    //friend BOOST_AFIO_DECL dispatcher_ptr async_file_io_dispatcher(thread_source &threadpool=process_threadpool(), file_flags flagsforce=file_flags::none, file_flags flagsmask=file_flags::none);
    template<class Impl, class Handle> friend handle_ptr detail::decode_relative_path(path_req &req, bool force_absolute);
    friend struct detail::async_io_handle_posix;
    friend struct detail::async_io_handle_windows;
    friend class detail::async_file_io_dispatcher_compat;
    friend class detail::async_file_io_dispatcher_windows;
    friend class detail::async_file_io_dispatcher_linux;
    friend class detail::async_file_io_dispatcher_qnx;

    detail::dispatcher_p *p;
    BOOST_AFIO_HEADERS_ONLY_MEMFUNC_SPEC void int_directory_cached_handle_path_changed(path oldpath, path newpath, handle_ptr h);
    BOOST_AFIO_HEADERS_ONLY_MEMFUNC_SPEC void int_add_io_handle(void *key, handle_ptr h);
    BOOST_AFIO_HEADERS_ONLY_MEMFUNC_SPEC void int_del_io_handle(void *key);
    BOOST_AFIO_HEADERS_ONLY_MEMFUNC_SPEC future<> int_op_from_scheduled_id(size_t id) const;

protected:
    BOOST_AFIO_HEADERS_ONLY_MEMFUNC_SPEC dispatcher(std::shared_ptr<thread_source> threadpool, file_flags flagsforce, file_flags flagsmask);
    std::pair<bool, handle_ptr> doadopt(size_t, future<>, handle_ptr h)
    {
        return std::make_pair(true, h);
    }
public:
    BOOST_AFIO_HEADERS_ONLY_MEMFUNC_SPEC void testing_flags(detail::unit_testing_flags flags);
    BOOST_AFIO_HEADERS_ONLY_VIRTUAL_SPEC ~dispatcher();

    BOOST_AFIO_HEADERS_ONLY_MEMFUNC_SPEC std::shared_ptr<thread_source> threadsource() const;
    BOOST_AFIO_HEADERS_ONLY_MEMFUNC_SPEC file_flags fileflags(file_flags flags) const;
    BOOST_AFIO_HEADERS_ONLY_MEMFUNC_SPEC size_t wait_queue_depth() const;
    BOOST_AFIO_HEADERS_ONLY_MEMFUNC_SPEC size_t fd_count() const;
#ifndef DOXYGEN_SHOULD_SKIP_THIS
    /* \brief Returns an op ref for a given \b currently scheduled op id, throwing an exception if id not scheduled at the point of call.
    Can be used to retrieve exception state from some op id, or one's own shared stl_future.
    
    \return An future<> with the same shared stl_future as all op refs with this id.
    \param id The unique integer id for the op.
    */
    BOOST_AFIO_HEADERS_ONLY_MEMFUNC_SPEC future<> op_from_scheduled_id(size_t id) const;

    // The type of an op filter callback handler \ingroup dispatcher__filter
    typedef void filter_t(detail::OpType, future<> &);
    // The type of a readwrite filter callback handler \ingroup dispatcher__filter
    typedef void filter_readwrite_t(detail::OpType, handle *, const detail::io_req_impl<true> &, off_t, size_t, size_t, const error_code &, size_t);
    /* \brief Clears the post op and readwrite filters. Not threadsafe.

    \ingroup dispatcher__filter
    \complexity{O(1).}
    \qexample{filter_example}
    */
    BOOST_AFIO_HEADERS_ONLY_MEMFUNC_SPEC void post_op_filter_clear();
    /* \brief Install op filters for non-buffer taking ops. Not threadsafe.

    `std::function<dispatcher::filter_t>` will be called after every op of type `detail::OpType`
    completes (`detail::OpType::Unknown` means call this filter for all ops) with the op type and op output.

    Note that filters are currently implemented as a linear scan, so a full iteration of all filters is done
    for every op completed. The filter is called straight after an op's stl_future is set and before any completions
    are issued. Any exceptions thrown by the filter are thrown away.

    \param filters A batch of pairs of op type to be filtered and bound filter handler functions of type `filter_t`
    \ingroup dispatcher__filter
    \complexity{O(N) where N is the total number of filters currently configured.}
    \qexample{filter_example}
    */
    BOOST_AFIO_HEADERS_ONLY_MEMFUNC_SPEC void post_op_filter(std::vector<std::pair<detail::OpType, std::function<dispatcher::filter_t>>> filters);
    /* \brief Install read/write op filters, useful for tight ASIO integration. Not threadsafe.

    `std::function<dispatcher::filter_buffers_t>` will be called after every op of type `detail::OpType`
    completes (`detail::OpType::Unknown` means call this filter for all ops) with the op type, file handle, op input, 
    file offset, buffers offset, buffers amount, error state and bytes transferred. Any filter other than read() and write()
    will be ignored, for those use post_op_filter().

    Note that buffer filters are currently implemented as a linear scan, so a full iteration of all buffer filters is done
    for every read/write op completed. The filter is called straight after a read or write operation has completed, and
    BEFORE any checks that it transferred the data it was supposed to. Any exceptions thrown by the filter are reported
    as if the read/write operation threw them, and filter processing stops at the filter which threw.

    \param filters A batch of pairs of op type to be filtered and bound filter handler functions of type `filter_buffers_t`
    \ingroup dispatcher__filter
    \complexity{O(N) where N is the total number of filters currently configured.}
    \qexample{filter_example}
    */
    BOOST_AFIO_HEADERS_ONLY_MEMFUNC_SPEC void post_readwrite_filter(std::vector<std::pair<detail::OpType, std::function<dispatcher::filter_readwrite_t>>> filters);

    // The type returned by a completion handler \ingroup dispatcher__completion
    typedef std::pair<bool, handle_ptr> completion_returntype;
    // The type of a completion handler \ingroup dispatcher__completion
    typedef completion_returntype completion_t(size_t, future<>);
#ifndef DOXYGEN_SHOULD_SKIP_THIS
#if defined(BOOST_AFIO_ENABLE_BENCHMARKING_COMPLETION) || BOOST_AFIO_HEADERS_ONLY==0 // Only really used for benchmarking
    BOOST_AFIO_HEADERS_ONLY_MEMFUNC_SPEC std::vector<future<>> completion(const std::vector<future<>> &ops, const std::vector<std::pair<async_op_flags, dispatcher::completion_t *>> &callbacks);
    inline future<> completion(const future<> &req, const std::pair<async_op_flags, dispatcher::completion_t *> &callback);
#endif
#endif
    /* \brief Schedule a batch of asynchronous invocations of the specified functions when their supplied operations complete.

    \deprecate{This function will be eliminated after lightweight future-promises are merged as one simply calls .then() on the future.}
    \return A batch of op handles
    \param ops A batch of precondition op handles.
    \param callbacks A batch of pairs of op flags and bound completion handler functions of type `completion_t`
    \ingroup dispatcher__completion
    \qbk{distinguish, batch bound functions}
    \complexity{Amortised O(N) to dispatch. Amortised O(N/threadpool) to complete.}
    \exceptionmodelstd
    \qexample{completion_example1}
    */
    BOOST_AFIO_HEADERS_ONLY_MEMFUNC_SPEC std::vector<future<>> completion(const std::vector<future<>> &ops, const std::vector<std::pair<async_op_flags, std::function<dispatcher::completion_t>>> &callbacks);
    /* \brief Schedule the asynchronous invocation of the specified single function when the supplied single operation completes.

    \deprecate{This function will be eliminated after lightweight future-promises are merged as one simply calls .then() on the future.}
    \return An op handle
    \param req A precondition op handle
    \param callback A pair of op flag and bound completion handler function of type `completion_t`
    \ingroup dispatcher__completion
    \qbk{distinguish, single bound function}
    \complexity{Amortised O(1) to dispatch. Amortised O(1) to complete.}
    \exceptionmodelstd
    \qexample{completion_example1}
    */
    inline future<> completion(const future<> &req, const std::pair<async_op_flags, std::function<dispatcher::completion_t>> &callback);

    /* \brief Schedule a batch of asynchronous invocations of the specified bound functions when their supplied preconditions complete.

    \deprecate{This function will be eliminated after lightweight future-promises are merged as one simply calls .then() on the future.}
    This is effectively a convenience wrapper for `completion()`. It creates an enqueued_task matching the `completion_t`
    handler specification and calls the specified arbitrary callable, always returning completion on exit.
    
    \return A pair with a batch of futures returning the result of each of the callables and a batch of op handles.
    \tparam "class R" A compiler deduced return type of the bound functions.
    \param ops A batch of precondition op handles. If default constructed, a precondition is null.
    \param callables A batch of bound functions to call, returning R.
    \ingroup dispatcher__call
    \qbk{distinguish, batch bound functions}
    \complexity{Amortised O(N) to dispatch. Amortised O(N/threadpool) to complete.}
    \exceptionmodelstd
    \qexample{call_example}
    */
    template<class R> inline std::vector<future<R>> call(const std::vector<future<>> &ops, const std::vector<std::function<R()>> &callables);
    /* \brief Schedule a batch of asynchronous invocations of the specified bound functions when their supplied preconditions complete.

    \deprecate{This function will be eliminated after lightweight future-promises are merged as one simply calls .then() on the future.}
    This is effectively a convenience wrapper for `completion()`. It creates an enqueued_task matching the `completion_t`
    handler specification and calls the specified arbitrary callable, always returning completion on exit. If you
    are seeing performance issues, using `completion()` directly will have much less overhead.
    
    \return A pair with a batch of futures returning the result of each of the callables and a batch of op handles.
    \tparam "class R" A compiler deduced return type of the bound functions.
    \param callables A batch of bound functions to call, returning R.
    \ingroup dispatcher__call
    \qbk{distinguish, batch bound functions without preconditions}
    \complexity{Amortised O(N) to dispatch. Amortised O(N/threadpool) to complete.}
    \exceptionmodelstd
    \qexample{call_example}
    */
    template<class R> std::vector<future<R>> call(const std::vector<std::function<R()>> &callables) { return call(std::vector<future<>>(), callables); }
    /* \brief Schedule an asynchronous invocation of the specified bound function when its supplied precondition completes.

    \deprecate{This function will be eliminated after lightweight future-promises are merged as one simply calls .then() on the future.}
    This is effectively a convenience wrapper for `completion()`. It creates an enqueued_task matching the `completion_t`
    handler specification and calls the specified arbitrary callable, always returning completion on exit. If you
    are seeing performance issues, using `completion()` directly will have much less overhead.
    
    \return A pair with a stl_future returning the result of the callable and an op handle.
    \tparam "class R" A compiler deduced return type of the bound functions.
    \param req A precondition op handle. If default constructed, the precondition is null.
    \param callback A bound functions to call, returning R.
    \ingroup async_file_io_dispatcher__call
    \qbk{distinguish, single bound function}
    \complexity{Amortised O(1) to dispatch. Amortised O(1) to complete.}
    \exceptionmodelstd
    \qexample{call_example}
    */
    template<class R> inline future<R> call(const future<> &req, std::function<R()> callback);

    
    
         
    /* \brief Schedule an asynchronous invocation of the specified unbound callable when its supplied precondition completes.
    Note that this function essentially calls `std::bind()` on the callable and the args and passes it to the other call() overload taking a `std::function<>`.
    You should therefore use `std::ref()` etc. as appropriate.

    This is effectively a convenience wrapper for `completion()`. It creates an enqueued_task matching the `completion_t`
    handler specification and calls the specified arbitrary callable, always returning completion on exit. If you
    are seeing performance issues, using `completion()` directly will have much less overhead.
    
    \return A pair with a stl_future returning the result of the callable and an op handle.
    \tparam "class C" Any callable type.
    \tparam Args Any sequence of argument types.
    \param req A precondition op handle. If default constructed, the precondition is null.
    \param callback An unbound callable to call.
    \param args An arbitrary sequence of arguments to bind to the callable.
    \ingroup dispatcher__call
    \qbk{distinguish, single unbound callable}
    \complexity{Amortised O(1) to dispatch. Amortised O(1) to complete.}
    \exceptionmodelstd
    \qexample{call_example}
    */
#ifndef DOXYGEN_SHOULD_SKIP_THIS
    template<class C, class... Args> inline future<typename detail::vs2013_variadic_overload_resolution_workaround<C, Args...>::type> call(const future<> &req, C callback, Args... args);
#else
    template<class C, class... Args> inline future<typename std::result_of<C(Args...)>::type> call(const future<> &req, C callback, Args... args);
#endif



    /* \brief Schedule a batch of third party handle adoptions.

    \docs_adopt

    \return A batch of op handles.
    \param hs A batch of handles to adopt.
    \ingroup dispatcher__filedirops
    \qbk{distinguish, batch}
    \complexity{Amortised O(N) to dispatch. Amortised O(N/threadpool) to complete.}
    \exceptionmodelstd
    \qexample{adopt_example}
    */
    BOOST_AFIO_HEADERS_ONLY_MEMFUNC_SPEC std::vector<future<>> adopt(const std::vector<handle_ptr> &hs);
#endif

    BOOST_AFIO_HEADERS_ONLY_VIRTUAL_SPEC std::vector<future<>> dir(const std::vector<path_req> &reqs) BOOST_AFIO_HEADERS_ONLY_VIRTUAL_UNDEFINED_SPEC
    BOOST_AFIO_HEADERS_ONLY_VIRTUAL_SPEC std::vector<future<>> rmdir(const std::vector<path_req> &reqs) BOOST_AFIO_HEADERS_ONLY_VIRTUAL_UNDEFINED_SPEC
    BOOST_AFIO_HEADERS_ONLY_VIRTUAL_SPEC std::vector<future<>> file(const std::vector<path_req> &reqs) BOOST_AFIO_HEADERS_ONLY_VIRTUAL_UNDEFINED_SPEC
    BOOST_AFIO_HEADERS_ONLY_VIRTUAL_SPEC std::vector<future<>> rmfile(const std::vector<path_req> &reqs) BOOST_AFIO_HEADERS_ONLY_VIRTUAL_UNDEFINED_SPEC
    BOOST_AFIO_HEADERS_ONLY_VIRTUAL_SPEC std::vector<future<>> symlink(const std::vector<path_req> &reqs, const std::vector<future<>> &targets=std::vector<future<>>()) BOOST_AFIO_HEADERS_ONLY_VIRTUAL_UNDEFINED_SPEC
    BOOST_AFIO_HEADERS_ONLY_VIRTUAL_SPEC std::vector<future<>> rmsymlink(const std::vector<path_req> &reqs) BOOST_AFIO_HEADERS_ONLY_VIRTUAL_UNDEFINED_SPEC
    BOOST_AFIO_HEADERS_ONLY_VIRTUAL_SPEC std::vector<future<>> sync(const std::vector<future<>> &ops) BOOST_AFIO_HEADERS_ONLY_VIRTUAL_UNDEFINED_SPEC
    BOOST_AFIO_HEADERS_ONLY_VIRTUAL_SPEC std::vector<future<>> zero(const std::vector<future<>> &ops, const std::vector<std::vector<std::pair<off_t, off_t>>> &ranges) BOOST_AFIO_HEADERS_ONLY_VIRTUAL_UNDEFINED_SPEC
    BOOST_AFIO_HEADERS_ONLY_VIRTUAL_SPEC std::vector<future<>> close(const std::vector<future<>> &ops) BOOST_AFIO_HEADERS_ONLY_VIRTUAL_UNDEFINED_SPEC

#ifndef DOXYGEN_SHOULD_SKIP_THIS
    BOOST_AFIO_HEADERS_ONLY_VIRTUAL_SPEC std::vector<future<>> read(const std::vector<detail::io_req_impl<false>> &ops) BOOST_AFIO_HEADERS_ONLY_VIRTUAL_UNDEFINED_SPEC
    template<class T> inline std::vector<future<>> read(const std::vector<io_req<T>> &ops);
#else
    template<class T> BOOST_AFIO_HEADERS_ONLY_VIRTUAL_SPEC std::vector<future<>> read(const std::vector<io_req<T>> &ops) BOOST_AFIO_HEADERS_ONLY_VIRTUAL_UNDEFINED_SPEC
#endif

#ifndef DOXYGEN_SHOULD_SKIP_THIS
    BOOST_AFIO_HEADERS_ONLY_VIRTUAL_SPEC std::vector<future<>> write(const std::vector<detail::io_req_impl<true>> &ops) BOOST_AFIO_HEADERS_ONLY_VIRTUAL_UNDEFINED_SPEC
    template<class T> inline std::vector<future<>> write(const std::vector<io_req<T>> &ops);
#else
    template<class T> BOOST_AFIO_HEADERS_ONLY_VIRTUAL_SPEC std::vector<future<>> write(const std::vector<io_req<const T>> &ops) BOOST_AFIO_HEADERS_ONLY_VIRTUAL_UNDEFINED_SPEC
#endif

    BOOST_AFIO_HEADERS_ONLY_VIRTUAL_SPEC std::vector<future<>> truncate(const std::vector<future<>> &ops, const std::vector<off_t> &sizes) BOOST_AFIO_HEADERS_ONLY_VIRTUAL_UNDEFINED_SPEC
    
    BOOST_AFIO_HEADERS_ONLY_VIRTUAL_SPEC std::vector<future<std::pair<std::vector<directory_entry>, bool>>> enumerate(const std::vector<enumerate_req> &reqs) BOOST_AFIO_HEADERS_ONLY_VIRTUAL_UNDEFINED_SPEC
    BOOST_AFIO_HEADERS_ONLY_VIRTUAL_SPEC std::vector<future<std::vector<std::pair<off_t, off_t>>>> extents(const std::vector<future<>> &ops) BOOST_AFIO_HEADERS_ONLY_VIRTUAL_UNDEFINED_SPEC
    BOOST_AFIO_HEADERS_ONLY_VIRTUAL_SPEC std::vector<future<statfs_t>> statfs(const std::vector<future<>> &ops, const std::vector<fs_metadata_flags> &reqs) BOOST_AFIO_HEADERS_ONLY_VIRTUAL_UNDEFINED_SPEC

#ifndef DOXYGEN_SHOULD_SKIP_THIS
    inline future<> adopt(handle_ptr h);
    inline future<> dir(const path_req &req);
    inline future<> rmdir(const path_req &req);
    inline future<> file(const path_req &req);
    inline future<> rmfile(const path_req &req);
    inline future<> symlink(const path_req &req, const future<> &target=future<>());
    inline future<> rmsymlink(const path_req &req);
    inline future<> sync(const future<> &req);
    inline future<> zero(const future<> &req, const std::vector<std::pair<off_t, off_t>> &ranges);
    inline future<> close(const future<> &req);
    inline future<> read(const detail::io_req_impl<false> &req);
    inline future<> write(const detail::io_req_impl<true> &req);
    inline future<> truncate(const future<> &op, off_t newsize);
    inline future<std::pair<std::vector<directory_entry>, bool>> enumerate(const enumerate_req &req);
    inline future<std::vector<std::pair<off_t, off_t>>> extents(const future<> &op);
    inline future<statfs_t> statfs(const future<> &op, const fs_metadata_flags &req);

    // Undocumented deliberately
    BOOST_AFIO_HEADERS_ONLY_VIRTUAL_SPEC std::vector<future<>> lock(const std::vector<lock_req> &req) BOOST_AFIO_HEADERS_ONLY_VIRTUAL_UNDEFINED_SPEC

    
    BOOST_AFIO_HEADERS_ONLY_MEMFUNC_SPEC std::vector<future<>> barrier(const std::vector<future<>> &ops);
#endif

    inline future<> depends(future<> precondition, future<> op);

    BOOST_AFIO_HEADERS_ONLY_MEMFUNC_SPEC void complete_async_op(size_t id, handle_ptr h, exception_ptr e=exception_ptr());
    void complete_async_op(size_t id, exception_ptr e) { complete_async_op(id, handle_ptr(), e); }
protected:
    template<class F> BOOST_AFIO_HEADERS_ONLY_MEMFUNC_SPEC handle_ptr int_get_handle_to_containing_dir(F *parent, size_t id, path_req req, completion_returntype(F::*dofile)(size_t, future<>, path_req));
    BOOST_AFIO_HEADERS_ONLY_MEMFUNC_SPEC completion_returntype invoke_user_completion_fast(size_t id, future<> h, completion_t *callback);
    BOOST_AFIO_HEADERS_ONLY_MEMFUNC_SPEC completion_returntype invoke_user_completion_slow(size_t id, future<> h, std::function<completion_t> callback);

    template<class F> BOOST_AFIO_HEADERS_ONLY_MEMFUNC_SPEC std::vector<future<>> chain_async_ops(int optype, const std::vector<future<>> &preconditions, async_op_flags flags, completion_returntype(F::*f)(size_t, future<>, future<>));
    template<class F, class T> BOOST_AFIO_HEADERS_ONLY_MEMFUNC_SPEC std::vector<future<>> chain_async_ops(int optype, const std::vector<future<>> &preconditions, const std::vector<T> &container, async_op_flags flags, completion_returntype(F::*f)(size_t, future<>, T));
    template<class R, class F> BOOST_AFIO_HEADERS_ONLY_MEMFUNC_SPEC std::vector<future<R>> chain_async_ops(int optype, const std::vector<future<>> &preconditions, async_op_flags flags, completion_returntype(F::*f)(size_t, future<>, std::shared_ptr<promise<R>>));
    template<class R, class F, class T> BOOST_AFIO_HEADERS_ONLY_MEMFUNC_SPEC std::vector<future<R>> chain_async_ops(int optype, const std::vector<future<>> &preconditions, const std::vector<T> &container, async_op_flags flags, completion_returntype(F::*f)(size_t, future<>, T, std::shared_ptr<promise<R>>));
    template<class F, class T> BOOST_AFIO_HEADERS_ONLY_MEMFUNC_SPEC std::vector<future<>> chain_async_ops(int optype, const std::vector<T> &container, async_op_flags flags, completion_returntype(F::*f)(size_t, future<>, T));
    template<class R, class F, class T> BOOST_AFIO_HEADERS_ONLY_MEMFUNC_SPEC std::vector<future<R>> chain_async_ops(int optype, const std::vector<T> &container, async_op_flags flags, completion_returntype(F::*f)(size_t, future<>, T, std::shared_ptr<promise<R>>));

    template<class T> BOOST_AFIO_HEADERS_ONLY_MEMFUNC_SPEC dispatcher::completion_returntype dobarrier(size_t id, future<> h, T);
    template<class F, class... Args> BOOST_AFIO_HEADERS_ONLY_MEMFUNC_SPEC handle_ptr invoke_async_op_completions(size_t id, future<> h, completion_returntype(F::*f)(size_t, future<>, Args...), Args... args);
    template<class F, class... Args> BOOST_AFIO_HEADERS_ONLY_MEMFUNC_SPEC future<> chain_async_op(detail::immediate_async_ops &immediates, int optype, const future<> &precondition, async_op_flags flags, completion_returntype(F::*f)(size_t, future<>, Args...), Args... args);
};
#ifdef DOXYGEN_SHOULD_SKIP_THIS
BOOST_AFIO_HEADERS_ONLY_FUNC_SPEC outcome<dispatcher_ptr> make_dispatcher(std::string uri="file : / / /", file_flags flagsforce = file_flags::none, file_flags flagsmask = file_flags::none, std::shared_ptr<thread_source> threadpool = process_threadpool()) noexcept;
#else
BOOST_AFIO_HEADERS_ONLY_FUNC_SPEC outcome<dispatcher_ptr> make_dispatcher(std::string uri="file:///", file_flags flagsforce=file_flags::none, file_flags flagsmask=file_flags::none, std::shared_ptr<thread_source> threadpool = process_threadpool()) noexcept;
#endif

namespace detail
{
    struct when_all_state : std::enable_shared_from_this<when_all_state>
    {
        promise<std::vector<handle_ptr>> out;
        std::vector<shared_future<handle_ptr>> in;
    };
    template<bool rethrow> inline void when_all_ops_do(std::shared_ptr<when_all_state> state)
    {
        // If we're on Boost.Thread, coalesce all wait ops into a single
#if BOOST_AFIO_USE_BOOST_THREAD
        boost::wait_for_all(state->in.begin(), state->in.end());
#endif
        std::vector<handle_ptr> ret;
        ret.reserve(state->in.size());
        for(auto &i: state->in)
        {
            auto e(get_exception_ptr(i));
            if(e)
            {
                if(rethrow)
                {
                    state->out.set_exception(e);
                    return;
                }
                ret.push_back(handle_ptr());
            }
            else
                ret.push_back(i.get());
        }
        state->out.set_value(ret);
    }
    template<bool rethrow, class Iterator> inline stl_future<std::vector<handle_ptr>> when_all_ops(Iterator first, Iterator last)
    {
        auto state=std::make_shared<when_all_state>();
        state->in.reserve(std::distance(first, last));
        for(; first!=last; ++first)
            state->in.push_back(first->_h);
        auto ret=state->out.get_future();
        process_threadpool()->enqueue([BOOST_AFIO_LAMBDA_MOVE_CAPTURE(state)] { when_all_ops_do<rethrow>(std::move(state)); });
        return ret;
    }
    struct when_any_state : std::enable_shared_from_this<when_any_state>
    {
        atomic<size_t> count;
        promise<handle_ptr> out;
        std::vector<shared_future<handle_ptr>> in;
        when_any_state() : count(0) { }
    };
#if BOOST_AFIO_USE_BOOST_THREAD
    // Boost.Thread has wait_for_any() which lets us be more efficient here and wait directly on the futures
    template<bool rethrow> inline void when_any_ops_do(std::shared_ptr<when_any_state> state)
    {
        auto &i=*boost::wait_for_any(state->in.begin(), state->in.end());
        auto e(get_exception_ptr(i));
        if(e)
        {
            if(rethrow)
            {
                state->out.set_exception(e);
                return;
            }
            state->out.set_value(handle_ptr());
        }
        else
            state->out.set_value(i.get());
    }
    template<bool rethrow, class Iterator> inline stl_future<handle_ptr> when_any_ops(Iterator first, Iterator last)
    {
        auto state=std::make_shared<when_any_state>();
        state->in.reserve(std::distance(first, last));
        for(; first!=last; ++first)
            state->in.push_back(first->h);
        auto ret=state->out.get_future();
        process_threadpool()->enqueue([BOOST_AFIO_LAMBDA_MOVE_CAPTURE(state)]{ when_any_ops_do<rethrow>(std::move(state)); });
        return ret;
    }
#else
    // Without wait_for_any, schedule a completion onto every op and the first to fire wins
    template<bool rethrow> inline std::pair<bool, handle_ptr> when_any_ops_do(std::shared_ptr<when_any_state> state, size_t idx, size_t id, future<> h)
    {
        auto &i=state->in[idx];
        if(0==state->count.fetch_add(1, memory_order_relaxed))  // Will be zero exactly once
        {
            auto e(get_exception_ptr(i));
            if(e)
            {
                if(rethrow)
                {
                    state->out.set_exception(e);
                    return std::make_pair(true, handle_ptr());
                }
                state->out.set_value(handle_ptr());
            }
            else
                state->out.set_value(i.get());
        }
        return std::make_pair(true, handle_ptr());
    }
    template<bool rethrow, class Iterator> inline stl_future<handle_ptr> when_any_ops(Iterator first, Iterator last)
    {
        auto state=std::make_shared<when_any_state>();
        auto dispatcher=first->parent();
        std::vector<future<>> ops(first, last);
        state->in.reserve(ops.size());
        for(auto &op : ops)
            state->in.push_back(op._h);
        auto ret=state->out.get_future();
        typedef std::function<typename dispatcher::completion_t> ft;
        std::vector<std::pair<async_op_flags, ft>> completions;
        completions.reserve(ops.size());
        for(size_t n=0; n<ops.size(); n++)
          completions.push_back(std::make_pair(async_op_flags::immediate, std::bind(&when_any_ops_do<rethrow>, state, n, std::placeholders::_1, std::placeholders::_2)));
        dispatcher->completion(ops, completions);
        return ret;
    }
#endif
    template<bool is_all> struct select_when_ops_return_type
    {
        typedef stl_future<std::vector<handle_ptr>> type; // when_all_p()
    };
    template<> struct select_when_ops_return_type<false>
    {
        typedef stl_future<handle_ptr> type; // when_any()
    };
    template<bool is_all, class T> struct enable_if_async_op
    {
        //static_assert(std::is_same<T, T>::value, "Not an iterator of future<>");
    };
    template<bool is_all, class T> struct enable_if_async_op<is_all, future<T>>
    {
        typedef typename select_when_ops_return_type<is_all>::type type;
    };
}

template<class Iterator> inline typename detail::enable_if_async_op<true, typename Iterator::value_type>::type when_all_p(std::nothrow_t _, Iterator first, Iterator last)
{
    if(first==last)
        return stl_future<std::vector<handle_ptr>>();
    return detail::when_all_ops<false>(first, last);
}
template<class Iterator> inline typename detail::enable_if_async_op<false, typename Iterator::value_type>::type when_any(std::nothrow_t _, Iterator first, Iterator last)
{
    if(first==last)
        return stl_future<handle_ptr>();
    return detail::when_any_ops<false>(first, last);
}
template<class T> inline stl_future<std::vector<handle_ptr>> when_all_p(std::nothrow_t _, std::vector<future<T>> ops)
{
    if(ops.empty())
        return stl_future<std::vector<handle_ptr>>();
    return detail::when_all_ops<false>(ops.begin(), ops.end());
}
template<class T> inline stl_future<handle_ptr> when_any(std::nothrow_t _, std::vector<future<T>> ops)
{
    if(ops.empty())
        return stl_future<handle_ptr>();
    return detail::when_any_ops<false>(ops.begin(), ops.end());
}
template<class Iterator> inline typename detail::enable_if_async_op<true, typename Iterator::value_type>::type when_all_p(Iterator first, Iterator last)
{
    if(first==last)
        return stl_future<std::vector<handle_ptr>>();
    return detail::when_all_ops<true>(first, last);
}
template<class Iterator> inline typename detail::enable_if_async_op<false, typename Iterator::value_type>::type when_any(Iterator first, Iterator last)
{
    if(first==last)
        return stl_future<handle_ptr>();
    return detail::when_any_ops<true>(first, last);
}
template<class T> inline stl_future<std::vector<handle_ptr>> when_all_p(std::vector<future<T>> ops)
{
    if(ops.empty())
        return stl_future<std::vector<handle_ptr>>();
    return detail::when_all_ops<true>(ops.begin(), ops.end());
}
template<class T> inline stl_future<handle_ptr> when_any(std::vector<future<T>> ops)
{
    if(ops.empty())
        return stl_future<handle_ptr>();
    return detail::when_any_ops<true>(ops.begin(), ops.end());
}
template<class T> inline stl_future<std::vector<handle_ptr>> when_all_p(std::nothrow_t _, future<T> op)
{
    std::vector<future<T>> ops(1, op);
    return when_all_p(_, ops);
}
template<class... Types> inline stl_future<std::vector<handle_ptr>> when_all_p(future<Types> &... ops)
{
    std::vector<future<>> _ops = { std::forward<future<Types> &>(ops)... };
    return when_all_p(_ops);
}

struct path_req
{
    bool is_relative;           
    BOOST_AFIO_V2_NAMESPACE::path path;            
    file_flags flags;           
    future<> precondition;   

    struct absolute;
    struct relative;
    path_req() : is_relative(false), flags(file_flags::none) { }
    path_req(const path_req &o) = default;
    path_req(path_req &&o) noexcept : is_relative(o.is_relative), path(std::move(o.path)), flags(std::move(o.flags)), precondition(std::move(o.precondition)) { }
    inline path_req(absolute &&o);
    inline path_req(relative &&o);
    template<class T, typename=typename std::enable_if<!std::is_constructible<path_req, T>::value && !std::is_constructible<future<>, T>::value>::type> path_req(T &&_path, file_flags _flags=file_flags::none) : is_relative(false), path(BOOST_AFIO_V2_NAMESPACE::path::make_absolute(std::forward<T>(_path))), flags(_flags) { }
    template<class T, typename=typename std::enable_if<!std::is_convertible<BOOST_AFIO_V2_NAMESPACE::path, T>::value>::type> path_req(bool _is_relative, future<> _precondition, T &&_path, file_flags _flags=file_flags::none) : is_relative(_is_relative), path(_is_relative ? BOOST_AFIO_V2_NAMESPACE::path(std::forward<T>(_path)) : BOOST_AFIO_V2_NAMESPACE::path(BOOST_AFIO_V2_NAMESPACE::path::make_absolute(std::forward<T>(_path)))), flags(_flags), precondition(std::move(_precondition)) { _validate(); }
    path_req(bool _is_relative, future<> _precondition, BOOST_AFIO_V2_NAMESPACE::path _path, file_flags _flags=file_flags::none) : is_relative(_is_relative), path(std::move(_path)), flags(_flags), precondition(std::move(_precondition)) { _validate(); }
    path_req(future<> _precondition, file_flags _flags=file_flags::none) : is_relative(true), flags(_flags), precondition(std::move(_precondition)) { _validate(); }
    bool validate() const
    {
        if(!is_relative && path.empty()) return false;
        return !precondition.valid() || precondition.validate();
    }
protected:
    void _validate() const
    {
#if BOOST_AFIO_VALIDATE_INPUTS
        if(!validate())
            BOOST_AFIO_THROW(std::invalid_argument("Inputs are invalid."));
#endif
    }
};
struct path_req::relative : path_req
{
  template<class T> relative(future<> _precondition, T &&_path, file_flags _flags=file_flags::none) : path_req(true, std::move(_precondition), std::forward<T>(_path), _flags) { _validate(); }
  relative(future<> _precondition, file_flags _flags=file_flags::none) : path_req(std::move(_precondition), _flags) { _validate(); }
};
struct path_req::absolute : path_req
{
  template<class T> absolute(future<> _precondition, T &&_path, file_flags _flags=file_flags::none) : path_req(false, std::move(_precondition), std::move(BOOST_AFIO_V2_NAMESPACE::path::make_absolute(std::forward<T>(_path))), _flags) { _validate(); }
};
inline path_req::path_req(path_req::absolute &&o) : is_relative(o.is_relative), path(std::move(o.path)), flags(std::move(o.flags)), precondition(std::move(o.precondition)) { }
inline path_req::path_req(path_req::relative &&o) : is_relative(o.is_relative), path(std::move(o.path)), flags(std::move(o.flags)), precondition(std::move(o.precondition)) { }

template<class T> inline std::vector<asio::mutable_buffer> to_asio_buffers(T &v);
template<class T> inline std::vector<asio::const_buffer> to_asio_buffers(const T &v);
template<class T, size_t N> inline std::vector<asio::mutable_buffer> to_asio_buffers(T (&v)[N]);
template<class T, size_t N> inline std::vector<asio::const_buffer> to_asio_buffers(const T (&v)[N]);
inline std::vector<asio::mutable_buffer> to_asio_buffers(asio::mutable_buffer &v)
{
  return std::vector<asio::mutable_buffer>(1, v);
}
inline std::vector<asio::const_buffer> to_asio_buffers(asio::const_buffer &v)
{
  return std::vector<asio::const_buffer>(1, v);
}
template<class T> inline std::vector<asio::mutable_buffer> to_asio_buffers(T *v, size_t length)
{
  static_assert(std::is_trivial<T>::value, "to_asio_buffers<T> has not been specialised for this non-trivial type, which suggests you are trying to read or write a complex C++ type! Either add a custom specialisation, or directly instantiate an io_req with a void * and size_t length to some serialised representation.");
  return std::vector<asio::mutable_buffer>(1, asio::mutable_buffer((void *) v, length*sizeof(T)));
}
template<class T> inline std::vector<asio::const_buffer> to_asio_buffers(const T *v, size_t length)
{
  static_assert(std::is_trivial<T>::value, "to_asio_buffers<T> has not been specialised for this non-trivial type, which suggests you are trying to read or write a complex C++ type! Either add a custom specialisation, or directly instantiate an io_req with a void * and size_t length to some serialised representation.");
  return std::vector<asio::const_buffer>(1, asio::const_buffer((void *) v, length*sizeof(T)));
}
inline std::vector<asio::mutable_buffer> to_asio_buffers(void *v, size_t length)
{
  return std::vector<asio::mutable_buffer>(1, asio::mutable_buffer(v, length));
}
inline std::vector<asio::const_buffer> to_asio_buffers(const void *v, size_t length)
{
  return std::vector<asio::const_buffer>(1, asio::const_buffer(v, length));
}
namespace detail
{
    // Length deducing asio buffer conversions
    template<bool is_const, class R, class T, bool is_trivial=std::is_trivial<T>::value, bool is_container=is_container<T>::value> struct to_asio_buffers_helper
    {
      template<class U> std::vector<R> operator()(U &v) const
      {
        static_assert(!std::is_same<T, T>::value, "to_asio_buffers(T) called with type T which is neither trivial nor a container. Did you mean to call io_req with a void * and a byte length, or do you need to overload to_asio_buffers()?");
        static_assert(!std::is_same<asio::mutable_buffer, R>::value || !is_const, "This type is const, so you cannot generate an asio::mutable_buffer from it.");
        return std::vector<R>();
      }
    };
    // Trivial types get sent as is
    template<bool is_const, class R, class T> struct to_asio_buffers_helper<is_const, R, T, true, false>
    {
      template<class U> std::vector<R> operator()(U &v) const
      {
        static_assert(!std::is_same<asio::mutable_buffer, R>::value || !is_const, "This type is const, so you cannot generate an asio::mutable_buffer from it.");
        return std::vector<R>(1, R(&v, sizeof(v)));
      }
    };

    // Container types build a scatter gather list of their contents
    template<class R, class C, class T, bool is_const=std::is_const<T>::value, bool is_trivial=std::is_trivial<T>::value> struct container_to_asio_buffers_helper
    {
      template<class U> std::vector<R> operator()(U &v) const
      {
        static_assert(!std::is_same<asio::mutable_buffer, R>::value || !is_const, "This container only permits const access to its iterators, so you cannot generate an asio::mutable_buffer from it.");
        std::vector<R> ret;
        for(auto &i : v)
        {
          std::vector<R> item(to_asio_buffers(i));
          ret.reserve(ret.size()+item.size());
          ret.insert(ret.end(), std::make_move_iterator(item.begin()), std::make_move_iterator(item.end()));
        }
        return ret;
      }
    };
    // Container specialisations where we know we can skip scatter gather
    template<class R, class C, class T, class A, class _Ct, bool is_const> struct container_to_asio_buffers_helper<R, std::basic_string<C, T, A>, _Ct, is_const, true>
    {
      template<class U> std::vector<R> operator()(U &v) const
      {
        static_assert(!std::is_same<asio::mutable_buffer, R>::value || !is_const, "This container only permits const access to its iterators, so you cannot generate an asio::mutable_buffer from it.");
        return std::vector<R>(1, R(&v.front(), v.size()*sizeof(C)));
      }
    };
    template<class R, class T, class A, class _T, bool is_const> struct container_to_asio_buffers_helper<R, std::vector<T, A>, _T, is_const, true>
    {
      template<class U> std::vector<R> operator()(U &v) const
      {
        static_assert(!std::is_same<asio::mutable_buffer, R>::value || !is_const, "This container only permits const access to its iterators, so you cannot generate an asio::mutable_buffer from it.");
        return std::vector<R>(1, R(v.data(), v.size()*sizeof(T)));
      }
    };
    template<class R, class T, size_t N, class _T, bool is_const> struct container_to_asio_buffers_helper<R, std::array<T, N>, _T, is_const, true>
    {
      template<class U> std::vector<R> operator()(U &v) const
      {
        static_assert(!std::is_same<asio::mutable_buffer, R>::value || !is_const, "This container only permits const access to its iterators, so you cannot generate an asio::mutable_buffer from it.");
        std::vector<R> ret(1, R(v.data(), v.size()*sizeof(T)));
        return ret;
      }
    };
    template<bool is_const, class R, class T, bool is_trivial> struct to_asio_buffers_helper<is_const, R, T, is_trivial, true> : container_to_asio_buffers_helper<R, T, typename is_container<T>::type>
    {
    };
    // Pass through vectors and arrays of asio buffers
    template<bool is_const, class R> struct to_asio_buffers_helper<is_const, R, std::vector<asio::mutable_buffer>, false, true>
    {
      template<class U> std::vector<R> operator()(U &v) const
      {
        std::vector<R> ret(v.begin(), v.end());
        return ret;
      }
    };
    template<bool is_const> struct to_asio_buffers_helper<is_const, asio::mutable_buffer, std::vector<asio::mutable_buffer>, false, true>
    {
      template<class U> std::vector<asio::mutable_buffer> operator()(U &v) const
      {
        return v;
      }
    };
    template<bool is_const, class R> struct to_asio_buffers_helper<is_const, R, std::vector<asio::const_buffer>, false, true>
    {
      template<class U> std::vector<R> operator()(U &v) const
      {
        std::vector<R> ret(v.begin(), v.end());
        return ret;
      }
    };
    template<bool is_const> struct to_asio_buffers_helper<is_const, asio::const_buffer, std::vector<asio::const_buffer>, false, true>
    {
      template<class U> std::vector<asio::const_buffer> operator()(U &v) const
      {
        return v;
      }
    };
    template<bool is_const, size_t N, class R> struct to_asio_buffers_helper<is_const, R, std::array<asio::mutable_buffer, N>, false, true>
    {
      template<class U> std::vector<R> operator()(U &v) const
      {
        std::vector<R> ret(v.begin(), v.end());
        return ret;
      }
    };
    template<bool is_const, size_t N, class R> struct to_asio_buffers_helper<is_const, R, std::array<asio::const_buffer, N>, false, true>
    {
      template<class U> std::vector<R> operator()(U &v) const
      {
        std::vector<R> ret(v.begin(), v.end());
        return ret;
      }
    };
}
template<class T> inline std::vector<asio::mutable_buffer> to_asio_buffers(T &v)
{
  static_assert(!std::is_pointer<T>::value, "You cannot assemble scatter gather buffers from raw pointers, you need to specify a length or supply a type carrying a length");
  return detail::to_asio_buffers_helper<false, asio::mutable_buffer, T>()(v);
}
template<class T> inline std::vector<asio::const_buffer> to_asio_buffers(const T &v)
{
  static_assert(!std::is_pointer<T>::value, "You cannot assemble scatter gather buffers from raw pointers, you need to specify a length or supply a type carrying a length");
  return detail::to_asio_buffers_helper<true, asio::const_buffer, T>()(v);
}
template<class T, size_t N> inline std::vector<asio::mutable_buffer> to_asio_buffers(T (&v)[N])
{
  return to_asio_buffers(reinterpret_cast<std::array<T, N> &>(v));
}
template<class T, size_t N> inline std::vector<asio::const_buffer> to_asio_buffers(const T (&v)[N])
{
  return to_asio_buffers(reinterpret_cast<const std::array<T, N> &>(v));
}

namespace detail
{
    template<bool for_writing> class io_req_impl;
    template<> class io_req_impl<false>
    {
    public:
        future<> precondition;
        std::vector<asio::mutable_buffer> buffers;
        off_t where;
        io_req_impl() { }
        io_req_impl(const io_req_impl &o) : precondition(o.precondition), buffers(o.buffers), where(o.where) { }
        io_req_impl(io_req_impl &&o) noexcept : precondition(std::move(o.precondition)), buffers(std::move(o.buffers)), where(std::move(o.where)) { }
        io_req_impl &operator=(const io_req_impl &o) { precondition=o.precondition; buffers=o.buffers; where=o.where; return *this; }
        io_req_impl &operator=(io_req_impl &&o) noexcept { precondition=std::move(o.precondition); buffers=std::move(o.buffers); where=std::move(o.where); return *this; }
        io_req_impl(future<> _precondition, std::vector<asio::mutable_buffer> _buffers, off_t _where) : precondition(std::move(_precondition)), buffers(std::move(_buffers)), where(_where) { _validate(); }
        bool validate() const
        {
            //if(!precondition.validate()) return false;
            if(buffers.empty()) return false;
            for(auto &b: buffers)
            {
                if(!asio::buffer_cast<const void *>(b) || !asio::buffer_size(b)) return false;
                if(precondition.parent() && !!(precondition.parent()->fileflags(file_flags::none)&file_flags::os_direct))
                {
                    if(((size_t) asio::buffer_cast<const void *>(b) & 4095) || (asio::buffer_size(b) & 4095)) return false;
                }
            }
            return true;
        }
    private:
        void _validate() const
        {
#if BOOST_AFIO_VALIDATE_INPUTS
            if(!validate())
                BOOST_AFIO_THROW(std::invalid_argument("Inputs are invalid."));
#endif
        }
    };
    template<> class io_req_impl<true>
    {
    public:
        future<> precondition;
        std::vector<asio::const_buffer> buffers;
        off_t where;
        io_req_impl() { }
        io_req_impl(const io_req_impl &o) : precondition(o.precondition), buffers(o.buffers), where(o.where) { }
        io_req_impl(io_req_impl &&o) noexcept : precondition(std::move(o.precondition)), buffers(std::move(o.buffers)), where(std::move(o.where)) { }
        io_req_impl(const io_req_impl<false> &o) : precondition(o.precondition), where(o.where) { buffers.reserve(o.buffers.capacity()); for(auto &i: o.buffers){ buffers.push_back(i); } }
        io_req_impl(io_req_impl<false> &&o) noexcept : precondition(std::move(o.precondition)), where(std::move(o.where)) { buffers.reserve(o.buffers.capacity()); for(auto &&i: o.buffers){ buffers.push_back(std::move(i)); } }
        io_req_impl &operator=(const io_req_impl &o) { precondition=o.precondition; buffers=o.buffers; where=o.where; return *this; }
        io_req_impl &operator=(io_req_impl &&o) noexcept { precondition=std::move(o.precondition); buffers=std::move(o.buffers); where=std::move(o.where); return *this; }
        io_req_impl(future<> _precondition, std::vector<asio::const_buffer> _buffers, off_t _where) : precondition(std::move(_precondition)), buffers(std::move(_buffers)), where(_where) { _validate(); }
        io_req_impl(future<> _precondition, std::vector<asio::mutable_buffer> _buffers, off_t _where) : precondition(std::move(_precondition)), where(_where)
        {
            buffers.reserve(_buffers.capacity());
            for(auto &&i: _buffers)
                buffers.push_back(std::move(i));
            _validate();
        }
        bool validate() const
        {
            //if(!precondition.validate()) return false;
            if(buffers.empty()) return false;
            for(auto &b: buffers)
            {
                if(!asio::buffer_cast<const void *>(b) || !asio::buffer_size(b)) return false;
                if(precondition.parent() && !!(precondition.parent()->fileflags(file_flags::none)&file_flags::os_direct))
                {
                    if(((size_t) asio::buffer_cast<const void *>(b) & 4095) || (asio::buffer_size(b) & 4095)) return false;
                }
            }
            return true;
        }
    private:
        void _validate() const
        {
#if BOOST_AFIO_VALIDATE_INPUTS
            if(!validate())
                BOOST_AFIO_THROW(std::invalid_argument("Inputs are invalid."));
#endif
        }
    };
}

template<class T> struct io_req : public detail::io_req_impl<false>
{
#ifdef DOXYGEN_SHOULD_SKIP_THIS

    future<> precondition;
    std::vector<asio::mutable_buffer> buffers;
    off_t where;
#endif

    io_req() { }
    io_req(const io_req &o) : detail::io_req_impl<false>(o) { }
    io_req(io_req &&o) noexcept : detail::io_req_impl<false>(std::move(o)) { }
    io_req &operator=(const io_req &o) { static_cast<detail::io_req_impl<false>>(*this)=o; return *this; }
    io_req &operator=(io_req &&o) noexcept { static_cast<detail::io_req_impl<false>>(*this)=std::move(o); return *this; }
    io_req(future<> _precondition, T *v, size_t _length, off_t _where) : detail::io_req_impl<false>(std::move(_precondition), to_asio_buffers(v, _length), _where) { }
    template<class U> io_req(future<> _precondition, U &v, off_t _where) : detail::io_req_impl<false>(std::move(_precondition), to_asio_buffers(v), _where) { }
    template<class U, size_t N> io_req(future<> _precondition, U (&v)[N], off_t _where) : detail::io_req_impl<false>(std::move(_precondition), to_asio_buffers(v), _where) { }
};
template<class T> struct io_req<const T> : public detail::io_req_impl<true>
{
#ifdef DOXYGEN_SHOULD_SKIP_THIS

    future<> precondition;
    std::vector<asio::const_buffer> buffers;
    off_t where;
#endif

    io_req() { }
    io_req(const io_req &o) : detail::io_req_impl<true>(o) { }
    io_req(io_req &&o) noexcept : detail::io_req_impl<true>(std::move(o)) { }
    io_req(const io_req<T> &o) : detail::io_req_impl<true>(o) { }
    io_req(io_req<T> &&o) noexcept : detail::io_req_impl<true>(std::move(o)) { }
    io_req &operator=(const io_req &o) { static_cast<detail::io_req_impl<true>>(*this)=o; return *this; }
    io_req &operator=(io_req &&o) noexcept { static_cast<detail::io_req_impl<true>>(*this)=std::move(o); return *this; }
    io_req(future<> _precondition, const T *v, size_t _length, off_t _where) : detail::io_req_impl<true>(std::move(_precondition), to_asio_buffers(v, _length), _where) { }
    template<class U> io_req(future<> _precondition, const U &v, off_t _where) : detail::io_req_impl<true>(std::move(_precondition), to_asio_buffers(v), _where) { }
    template<class U, size_t N> io_req(future<> _precondition, const U (&v)[N], off_t _where) : detail::io_req_impl<true>(std::move(_precondition), to_asio_buffers(v), _where) { }
};
template<> struct io_req<void> : public detail::io_req_impl<false>
{
#ifdef DOXYGEN_SHOULD_SKIP_THIS

  future<> precondition;
  std::vector<asio::mutable_buffer> buffers;
  off_t where;
#endif

  io_req() { }
  io_req(const io_req &o) : detail::io_req_impl<false>(o) { }
  io_req(io_req &&o) noexcept : detail::io_req_impl<false>(std::move(o)) { }
  io_req &operator=(const io_req &o) { static_cast<detail::io_req_impl<false>>(*this)=o; return *this; }
  io_req &operator=(io_req &&o) noexcept { static_cast<detail::io_req_impl<false>>(*this)=std::move(o); return *this; }
  io_req(future<> _precondition, void *v, size_t _length, off_t _where) : detail::io_req_impl<false>(std::move(_precondition), to_asio_buffers(v, _length), _where) { }
};
template<> struct io_req<const void> : public detail::io_req_impl<true>
{
#ifdef DOXYGEN_SHOULD_SKIP_THIS

  future<> precondition;
  std::vector<asio::const_buffer> buffers;
  off_t where;
#endif

  io_req() { }
  io_req(const io_req &o) : detail::io_req_impl<true>(o) { }
  io_req(io_req &&o) noexcept : detail::io_req_impl<true>(std::move(o)) { }
  io_req(const io_req<void> &o) : detail::io_req_impl<true>(o) { }
  io_req(io_req<void> &&o) noexcept : detail::io_req_impl<true>(std::move(o)) { }
  io_req &operator=(const io_req &o) { static_cast<detail::io_req_impl<true>>(*this)=o; return *this; }
  io_req &operator=(io_req &&o) noexcept { static_cast<detail::io_req_impl<true>>(*this)=std::move(o); return *this; }
  io_req(future<> _precondition, const void *v, size_t _length, off_t _where) : detail::io_req_impl<true>(std::move(_precondition), to_asio_buffers(v, _length), _where) { }
};

namespace detail
{
  template<class T, bool is_container=detail::is_container<T>::value> struct make_io_req
  {
    typedef typename std::remove_pointer<typename std::decay<T>::type>::type _T;
    typedef io_req<_T> type;
    template<class U> type operator()(future<> _precondition, U &&v, off_t _where) const
    {
      return type(std::move(_precondition), std::forward<U>(v), _where);
    }
    template<class U> type operator()(future<> _precondition, U &&v, size_t _length, off_t _where) const
    {
      return type(std::move(_precondition), std::forward<U>(v), _length, _where);
    }
  };
  // If T is a container and that container's value_type is const, make sure we only create an asio::const_buffer
  template<class T> struct make_io_req<T, true>
  {
    typedef typename detail::is_container<T>::type container_value_type;
    static BOOST_CONSTEXPR_OR_CONST bool is_container_contents_const=std::is_const<container_value_type>::value || std::is_base_of<asio::const_buffer, container_value_type>::value;
    typedef typename std::remove_pointer<typename std::decay<T>::type>::type __T;
    typedef typename std::conditional<is_container_contents_const, typename std::add_const<__T>::type, __T>::type _T;
    typedef io_req<_T> type;
    template<class U> type operator()(future<> _precondition, U &&v, off_t _where) const
    {
      return type(std::move(_precondition), std::forward<U>(v), _where);
    }
    template<class U> type operator()(future<> _precondition, U &&v, size_t _length, off_t _where) const
    {
      return type(std::move(_precondition), std::forward<U>(v), _length, _where);
    }
  };
}
template<class T> inline auto make_io_req(future<> _precondition, T &&v, off_t _where) -> decltype(detail::make_io_req<T>()(std::move(_precondition), std::forward<T>(v), _where))
{
  return detail::make_io_req<T>()(std::move(_precondition), std::forward<T>(v), _where);
}
template<class T> inline io_req<const std::initializer_list<T>> make_io_req(future<> _precondition, const std::initializer_list<T> &v, off_t _where)
{
  return io_req<const std::initializer_list<T>>(std::move(_precondition), v, _where);
}
template<class T> inline auto make_io_req(future<> _precondition, T &&v, size_t _length, off_t _where) -> decltype(detail::make_io_req<T>()(std::move(_precondition), std::forward<T>(v), _length, _where))
{
  return detail::make_io_req<T>()(std::move(_precondition), std::forward<T>(v), _length, _where);
}


struct enumerate_req
{
    future<> precondition;    
    size_t maxitems;             
    bool restart;                
    path glob;                   
    metadata_flags metadata;     

    enum class filter
    {
      none,        
      fastdeleted  
    };
    filter filtering;            

    enumerate_req() : maxitems(0), restart(false), metadata(metadata_flags::None), filtering(filter::fastdeleted) { }
    enumerate_req(future<> _precondition, size_t _maxitems=2, bool _restart=true, path _glob=path(), metadata_flags _metadata=metadata_flags::None, filter _filtering=filter::fastdeleted) : precondition(std::move(_precondition)), maxitems(_maxitems), restart(_restart), glob(std::move(_glob)), metadata(_metadata), filtering(_filtering) { _validate(); }
    enumerate_req(future<> _precondition, path _glob, size_t _maxitems=2, bool _restart=true, metadata_flags _metadata=metadata_flags::None, filter _filtering=filter::fastdeleted) : precondition(std::move(_precondition)), maxitems(_maxitems), restart(_restart), glob(std::move(_glob)), metadata(_metadata), filtering(_filtering) { _validate(); }
    enumerate_req(future<> _precondition, metadata_flags _metadata, size_t _maxitems=2, bool _restart=true, path _glob=path(), filter _filtering=filter::fastdeleted) : precondition(std::move(_precondition)), maxitems(_maxitems), restart(_restart), glob(std::move(_glob)), metadata(_metadata), filtering(_filtering) { _validate(); }
    bool validate() const
    {
        if(!maxitems) return false;
        return !precondition.valid() || precondition.validate();
    }
private:
    void _validate() const
    {
#if BOOST_AFIO_VALIDATE_INPUTS
        if(!validate())
            BOOST_AFIO_THROW(std::invalid_argument("Inputs are invalid."));
#endif
    }
};

// Undocumented deliberately
struct lock_req
{
  future<> precondition;
  enum class Type { unknown, read_lock, write_lock, unlock } type;
  off_t offset, length;
  //chrono::time_point<chrono::steady_clock> deadline;
  lock_req() : type(Type::unknown), offset(0), length(0) { }
  lock_req(future<> _precondition, Type _type=Type::write_lock) : precondition(_precondition), type(_type), offset(0), length((off_t)-1) { _validate(); }
  lock_req(future<> _precondition, std::nullptr_t) : precondition(_precondition), type(Type::unlock), offset(0), length((off_t)-1) { _validate(); }
  lock_req(future<> _precondition, Type _type, off_t _offset, off_t _length) : precondition(_precondition), type(_type), offset(_offset), length(_length) { _validate(); }
  lock_req(future<> _precondition, off_t _offset, off_t _length, Type _type=Type::write_lock) : precondition(_precondition), type(_type), offset(_offset), length(_length) { _validate(); }
  bool validate() const
  {
      if(type==Type::unknown) return false;
      if(offset+length<offset) return false;
      return !precondition.valid() || precondition.validate();
  }
private:
  void _validate() const
  {
#if BOOST_AFIO_VALIDATE_INPUTS
      if(!validate())
          BOOST_AFIO_THROW(std::invalid_argument("Inputs are invalid."));
#endif
  }
};



namespace detail {
    template<bool iswrite, class T> struct async_file_io_dispatcher_rwconverter
    {
        typedef detail::io_req_impl<iswrite> return_type;
        const std::vector<return_type> &operator()(const std::vector<io_req<T>> &ops) const
        {
            typedef io_req<T> reqT;
            static_assert(std::is_convertible<reqT, return_type>::value, "io_req<T> is not convertible to detail::io_req_impl<constness>");
            static_assert(sizeof(return_type)==sizeof(reqT), "io_req<T> does not have the same size as detail::io_req_impl<constness>");
            return reinterpret_cast<const std::vector<return_type> &>(ops);
        }
    };
}

#if defined(BOOST_AFIO_ENABLE_BENCHMARKING_COMPLETION) // Only really used for benchmarking
inline future<> dispatcher::completion(const future<> &req, const std::pair<async_op_flags, dispatcher::completion_t *> &callback)
{
    std::vector<future<>> r;
    std::vector<std::pair<async_op_flags, dispatcher::completion_t *>> i;
    r.reserve(1); i.reserve(1);
    r.push_back(req);
    i.push_back(callback);
    auto ret(std::move(completion(r, i).front()));
    return ret;
}
#endif
inline future<> dispatcher::completion(const future<> &req, const std::pair<async_op_flags, std::function<dispatcher::completion_t>> &callback)
{
    std::vector<future<>> r;
    std::vector<std::pair<async_op_flags, std::function<dispatcher::completion_t>>> i;
    r.reserve(1); i.reserve(1);
    r.push_back(req);
    i.push_back(callback);
    auto ret(std::move(completion(r, i).front()));
    return ret;
}
namespace detail {
    template<class tasktype> std::pair<bool, handle_ptr> doCall(size_t, future<> _, std::shared_ptr<tasktype> c)
    {
        (*c)();
        return std::make_pair(true, _.get_handle(true));
    }
}
template<class R> inline std::vector<future<R>> dispatcher::call(const std::vector<future<>> &ops, const std::vector<std::function<R()>> &callables)
{
    typedef packaged_task<R()> tasktype;
    std::vector<stl_future<R>> retfutures;
    std::vector<std::pair<async_op_flags, std::function<completion_t>>> callbacks;
    retfutures.reserve(callables.size());
    callbacks.reserve(callables.size());
    
    for(auto &t: callables)
    {
        std::shared_ptr<tasktype> c(std::make_shared<tasktype>(std::function<R()>(t)));
        retfutures.push_back(c->get_future());
        callbacks.push_back(std::make_pair(async_op_flags::none, std::bind(&detail::doCall<tasktype>, std::placeholders::_1, std::placeholders::_2, std::move(c))));
    }
    auto _ret(completion(ops, callbacks));
    std::vector<future<R>> ret;
    ret.reserve(_ret.size());
    for (size_t n = 0; n < _ret.size(); n++)
      ret.push_back(future<R>(std::move(_ret[n]), std::move(retfutures[n])));
    return ret;
}
template<class R> inline future<R> dispatcher::call(const future<> &req, std::function<R()> callback)
{
    std::vector<future<>> i;
    std::vector<std::function<R()>> c;
    i.reserve(1); c.reserve(1);
    i.push_back(req);
    c.push_back(std::move(callback));
    auto ret(std::move(call(i, c).front()));
    return ret;
}

#ifndef DOXYGEN_SHOULD_SKIP_THIS
template<class C, class... Args> inline future<typename detail::vs2013_variadic_overload_resolution_workaround<C, Args...>::type> dispatcher::call(const future<> &req, C callback, Args... args)
#else
template<class C, class... Args> inline future<typename std::result_of<C(Args...)>::type> dispatcher::call(const future<> &req, C callback, Args... args)
#endif
{
    typedef typename std::result_of<C(Args...)>::type rettype;
    return call(req, std::function<rettype()>(std::bind<rettype>(callback, args...)));
}

inline future<> dispatcher::adopt(handle_ptr h)
{
    std::vector<handle_ptr> i;
    i.reserve(1);
    i.push_back(std::move(h));
    auto ret(std::move(adopt(i).front()));
    return ret;
}
inline future<> dispatcher::dir(const path_req &req)
{
    std::vector<path_req> i;
    i.reserve(1);
    i.push_back(req);
    auto ret(std::move(dir(i).front()));
    return ret;
}
inline future<> dispatcher::rmdir(const path_req &req)
{
    std::vector<path_req> i;
    i.reserve(1);
    i.push_back(req);
    auto ret(std::move(rmdir(i).front()));
    return ret;
}
inline future<> dispatcher::file(const path_req &req)
{
    std::vector<path_req> i;
    i.reserve(1);
    i.push_back(req);
    auto ret(std::move(file(i).front()));
    return ret;
}
inline future<> dispatcher::rmfile(const path_req &req)
{
    std::vector<path_req> i;
    i.reserve(1);
    i.push_back(req);
    auto ret(std::move(rmfile(i).front()));
    return ret;
}
inline future<> dispatcher::symlink(const path_req &req, const future<> &target)
{
    std::vector<path_req> i(1, req);
    std::vector<future<>> t(1, target);
    auto ret(std::move(symlink(i, t).front()));
    return ret;
}
inline future<> dispatcher::rmsymlink(const path_req &req)
{
    std::vector<path_req> i;
    i.reserve(1);
    i.push_back(req);
    auto ret(std::move(rmsymlink(i).front()));
    return ret;
}
inline future<> dispatcher::sync(const future<> &req)
{
    std::vector<future<>> i;
    i.reserve(1);
    i.push_back(req);
    auto ret(std::move(sync(i).front()));
    return ret;
}
inline future<> dispatcher::zero(const future<> &req, const std::vector<std::pair<off_t, off_t>> &ranges)
{
    std::vector<future<>> i;
    std::vector<std::vector<std::pair<off_t, off_t>>> r;
    i.reserve(1);
    i.push_back(req);
    r.reserve(1);
    r.push_back(ranges);
    auto ret(std::move(zero(i, r).front()));
    return ret;
}
inline future<> dispatcher::close(const future<> &req)
{
    std::vector<future<>> i;
    i.reserve(1);
    i.push_back(req);
    auto ret(std::move(close(i).front()));
    return ret;
}
#ifndef DOXYGEN_SHOULD_SKIP_THIS
inline future<> dispatcher::read(const detail::io_req_impl<false> &req)
{
    std::vector<detail::io_req_impl<false>> i;
    i.reserve(1);
    i.push_back(req);
    auto ret(std::move(read(i).front()));
    return ret;
}
inline future<> dispatcher::write(const detail::io_req_impl<true> &req)
{
    std::vector<detail::io_req_impl<true>> i;
    i.reserve(1);
    i.push_back(req);
    auto ret(std::move(write(i).front()));
    return ret;
}
#endif
template<class T> inline std::vector<future<>> dispatcher::read(const std::vector<io_req<T>> &ops)
{
    return read(detail::async_file_io_dispatcher_rwconverter<false, T>()(ops));
}
template<class T> inline std::vector<future<>> dispatcher::write(const std::vector<io_req<T>> &ops)
{
    return write(detail::async_file_io_dispatcher_rwconverter<true, T>()(ops));
}
inline future<> dispatcher::truncate(const future<> &op, off_t newsize)
{
    std::vector<future<>> o;
    std::vector<off_t> i;
    o.reserve(1);
    o.push_back(op);
    i.reserve(1);
    i.push_back(newsize);
    auto ret(std::move(truncate(o, i).front()));
    return ret;
}
inline future<std::pair<std::vector<directory_entry>, bool>> dispatcher::enumerate(const enumerate_req &req)
{
    std::vector<enumerate_req> i;
    i.reserve(1);
    i.push_back(req);
    auto ret(std::move(enumerate(i).front()));
    return ret;
}
inline future<std::vector<std::pair<off_t, off_t>>> dispatcher::extents(const future<> &op)
{
    std::vector<future<>> o;
    o.reserve(1);
    o.push_back(op);
    auto ret(std::move(extents(o).front()));
    return ret;
}
inline future<statfs_t> dispatcher::statfs(const future<> &op, const fs_metadata_flags &req)
{
  std::vector<future<>> o;
  std::vector<fs_metadata_flags> i;
  o.reserve(1);
  o.push_back(op);
  i.reserve(1);
  i.push_back(req);
  auto ret(std::move(statfs(o, i).front()));
  return ret;
}
inline future<> dispatcher::depends(future<> precondition, future<> op)
{
    std::pair<async_op_flags, std::function<dispatcher::completion_t>> callback(std::make_pair(async_op_flags::immediate,
    [BOOST_AFIO_LAMBDA_MOVE_CAPTURE(op)](size_t, future<>) { return std::make_pair(true, op.get_handle()); }));
    std::vector<future<>> r;
    std::vector<std::pair<async_op_flags, std::function<dispatcher::completion_t>>> i;
    r.reserve(1); i.reserve(1);
    r.push_back(precondition);
    i.push_back(std::move(callback));
    auto ret(std::move(completion(r, i).front()));
    return ret;
}

namespace detail
{
  template<class T> struct async_dir
  {
    T path;
    file_flags flags;
    async_dir(T _path, file_flags _flags) : path(std::move(_path)), flags(_flags) { }
    future<> operator()(future<> f=future<>())
    {
      dispatcher *dispatcher = f.parent();
      path_req req(!dispatcher ? (
        dispatcher = current_dispatcher().get(),
        path_req(path_req::absolute(std::move(f), std::move(path), std::move(flags)))
        ) : path_req(path_req::relative(std::move(f), std::move(path), std::move(flags))));
#if BOOST_AFIO_VALIDATE_INPUTS
      if (!req.validate())
        BOOST_AFIO_THROW(std::invalid_argument("Inputs are invalid."));
#endif
      auto ret(std::move(dispatcher->dir(std::vector<path_req>(1, std::move(req))).front()));
      return ret;
    }
  };
  template<class T> struct async_rmdir
  {
    T path;
    file_flags flags;
    async_rmdir(T _path, file_flags _flags) : path(std::move(_path)), flags(_flags) { }
    future<> operator()(future<> f = future<>())
    {
      dispatcher *dispatcher = f.parent();
      path_req req(!dispatcher ? (
        dispatcher = current_dispatcher().get(),
        path_req(path_req::absolute(std::move(f), std::move(path), std::move(flags)))
        ) : path_req(path_req::relative(std::move(f), std::move(path), std::move(flags))));
#if BOOST_AFIO_VALIDATE_INPUTS
      if (!req.validate())
        BOOST_AFIO_THROW(std::invalid_argument("Inputs are invalid."));
#endif
      auto ret(std::move(dispatcher->rmdir(std::vector<path_req>(1, std::move(req))).front()));
      return ret;
    }
  };
  template<class T> struct async_file
  {
    T path;
    file_flags flags;
    async_file(T _path, file_flags _flags) : path(std::move(_path)), flags(_flags) { }
    future<> operator()(future<> f = future<>())
    {
      dispatcher *dispatcher = f.parent();
      path_req req(!dispatcher ? (
        dispatcher = current_dispatcher().get(),
        path_req(path_req::absolute(std::move(f), std::move(path), std::move(flags)))
        ) : path_req(path_req::relative(std::move(f), std::move(path), std::move(flags))));
#if BOOST_AFIO_VALIDATE_INPUTS
      if (!req.validate())
        BOOST_AFIO_THROW(std::invalid_argument("Inputs are invalid."));
#endif
      auto ret(std::move(dispatcher->file(std::vector<path_req>(1, std::move(req))).front()));
      return ret;
    }
  };
  template<class T> struct async_rmfile
  {
    T path;
    file_flags flags;
    async_rmfile(T _path, file_flags _flags) : path(std::move(_path)), flags(_flags) { }
    future<> operator()(future<> f = future<>())
    {
      dispatcher *dispatcher = f.parent();
      path_req req(!dispatcher ? (
        dispatcher = current_dispatcher().get(),
        path_req(path_req::absolute(std::move(f), std::move(path), std::move(flags)))
        ) : path_req(path_req::relative(std::move(f), std::move(path), std::move(flags))));
#if BOOST_AFIO_VALIDATE_INPUTS
      if (!req.validate())
        BOOST_AFIO_THROW(std::invalid_argument("Inputs are invalid."));
#endif
      auto ret(std::move(dispatcher->rmfile(std::vector<path_req>(1, std::move(req))).front()));
      return ret;
    }
  };
  template<class T> struct async_symlink
  {
    T path;
    file_flags flags;
    future<> target;
    async_symlink(T _path, file_flags _flags, future<> _target) : path(std::move(_path)), flags(_flags), target(std::move(_target)) { }
    future<> operator()(future<> f = future<>())
    {
      dispatcher *dispatcher = f.parent();
      path_req req(!dispatcher ? (
        dispatcher = current_dispatcher().get(),
        path_req(path_req::absolute(std::move(f), std::move(path), std::move(flags)))
        ) : path_req(path_req::relative(std::move(f), std::move(path), std::move(flags))));
#if BOOST_AFIO_VALIDATE_INPUTS
      if (!req.validate())
        BOOST_AFIO_THROW(std::invalid_argument("Inputs are invalid."));
#endif
      auto ret(std::move(dispatcher->symlink(std::vector<path_req>(1, std::move(req)), std::vector<future<>>(1, std::move(target))).front()));
      return ret;
    }
  };
  template<class T> struct async_rmsymlink
  {
    T path;
    file_flags flags;
    async_rmsymlink(T _path, file_flags _flags) : path(std::move(_path)), flags(_flags) { }
    future<> operator()(future<> f = future<>())
    {
      dispatcher *dispatcher = f.parent();
      path_req req(!dispatcher ? (
        dispatcher = current_dispatcher().get(),
        path_req(path_req::absolute(std::move(f), std::move(path), std::move(flags)))
        ) : path_req(path_req::relative(std::move(f), std::move(path), std::move(flags))));
#if BOOST_AFIO_VALIDATE_INPUTS
      if (!req.validate())
        BOOST_AFIO_THROW(std::invalid_argument("Inputs are invalid."));
#endif
      auto ret(std::move(dispatcher->rmsymlink(std::vector<path_req>(1, std::move(req))).front()));
      return ret;
    }
  };
  struct async_sync
  {
    future<> operator()(future<> f = future<>())
    {
      dispatcher *dispatcher = f.parent();
      if (!dispatcher)
        dispatcher = current_dispatcher().get();
      auto ret(std::move(dispatcher->sync(std::vector<future<>>(1, std::move(f))).front()));
      return ret;
    }
  };
  struct async_close
  {
    future<> operator()(future<> f = future<>())
    {
      dispatcher *dispatcher = f.parent();
      if (!dispatcher)
        dispatcher = current_dispatcher().get();
      auto ret(std::move(dispatcher->close(std::vector<future<>>(1, std::move(f))).front()));
      return ret;
    }
  };
  struct async_read
  {
    io_req_impl<false> req;
    template<class U> async_read(U &&v, off_t _where) : req(BOOST_AFIO_V2_NAMESPACE::make_io_req(future<>(), std::forward<U>(v), _where)) { }
    template<class U> async_read(U &&v, size_t _length, off_t _where) : req(BOOST_AFIO_V2_NAMESPACE::make_io_req(future<>(), std::forward<U>(v), _length, _where)) { }
    future<> operator()(future<> f = future<>())
    {
      dispatcher *dispatcher = f.parent();
      if (!dispatcher)
        dispatcher = current_dispatcher().get();
      req.precondition = f;
#if BOOST_AFIO_VALIDATE_INPUTS
      if (!req.validate())
        BOOST_AFIO_THROW(std::invalid_argument("Inputs are invalid."));
#endif
      auto ret(std::move(dispatcher->read(std::vector<io_req_impl<false>>(1, std::move(req))).front()));
      return ret;
    }
  };
  struct async_write
  {
    io_req_impl<true> req;
    template<class U> async_write(U &&v, off_t _where) : req(BOOST_AFIO_V2_NAMESPACE::make_io_req(future<>(), std::forward<U>(v), _where)) { }
    template<class U> async_write(U &&v, size_t _length, off_t _where) : req(BOOST_AFIO_V2_NAMESPACE::make_io_req(future<>(), std::forward<U>(v), _length, _where)) { }
    future<> operator()(future<> f = future<>())
    {
      dispatcher *dispatcher = f.parent();
      if (!dispatcher)
        dispatcher = current_dispatcher().get();
      req.precondition = f;
#if BOOST_AFIO_VALIDATE_INPUTS
      if (!req.validate())
        BOOST_AFIO_THROW(std::invalid_argument("Inputs are invalid."));
#endif
      auto ret(std::move(dispatcher->write(std::vector<io_req_impl<true>>(1, std::move(req))).front()));
      return ret;
    }
  };
  struct async_truncate
  {
    off_t _size;
    async_truncate(off_t size) : _size(size) { }
    future<> operator()(future<> f = future<>())
    {
      dispatcher *dispatcher = f.parent();
      if (!dispatcher)
        dispatcher = current_dispatcher().get();
      auto ret(std::move(dispatcher->truncate(std::vector<future<>>(1, std::move(f)), std::vector<off_t>(1, _size)).front()));
      return ret;
    }
  };
  struct async_enumerate
  {
    size_t maxitems;
    bool restart;
    path glob;
    metadata_flags metadata;
    enumerate_req::filter filtering;
    async_enumerate(size_t _maxitems, bool _restart, path _glob, metadata_flags _metadata, enumerate_req::filter _filtering) : maxitems(_maxitems), restart(_restart), glob(_glob), metadata(_metadata), filtering(_filtering) { }
    future<std::pair<std::vector<directory_entry>, bool>> operator()(future<> f = future<>())
    {
      enumerate_req req(std::move(f), maxitems, restart, std::move(glob), metadata, filtering);
      dispatcher *dispatcher = f.parent();
      if (!dispatcher)
        dispatcher = current_dispatcher().get();
#if BOOST_AFIO_VALIDATE_INPUTS
      if (!req.validate())
        BOOST_AFIO_THROW(std::invalid_argument("Inputs are invalid."));
#endif
      auto ret(std::move(dispatcher->enumerate(std::vector<enumerate_req>(1, std::move(req))).front()));
      return ret;
    }
  };
  struct async_zero
  {
    std::vector<std::pair<off_t, off_t>> ranges;
    async_zero(std::vector<std::pair<off_t, off_t>> _ranges) : ranges(_ranges) { }
    future<> operator()(future<> f = future<>())
    {
      dispatcher *dispatcher = f.parent();
      if (!dispatcher)
        dispatcher = current_dispatcher().get();
      auto ret(std::move(dispatcher->zero(std::vector<future<>>(1, std::move(f)), std::vector<std::vector<std::pair<off_t, off_t>>>(1, std::move(ranges))).front()));
      return ret;
    }
  };
  struct async_extents
  {
    future<std::vector<std::pair<off_t, off_t>>> operator()(future<> f = future<>())
    {
      dispatcher *dispatcher = f.parent();
      if (!dispatcher)
        dispatcher = current_dispatcher().get();
      auto ret(std::move(dispatcher->extents(std::vector<future<>>(1, std::move(f))).front()));
      return ret;
    }
  };
  struct async_statfs
  {
    fs_metadata_flags req;
    async_statfs(fs_metadata_flags _req) : req(_req) { }
    future<statfs_t> operator()(future<> f = future<>())
    {
      dispatcher *dispatcher = f.parent();
      if (!dispatcher)
        dispatcher = current_dispatcher().get();
      auto ret(std::move(dispatcher->statfs(std::vector<future<>>(1, std::move(f)), std::vector<fs_metadata_flags>(1, req)).front()));
      return ret;
    }
  };
  template<class T> struct _is_not_handle : public std::true_type { };
  template<class T> struct _is_not_handle<future<T>> : public std::false_type { };
  template<> struct _is_not_handle<handle_ptr> : public std::false_type { };
  template<class T> struct is_not_handle : public _is_not_handle<typename std::decay<T>::type> { };
}

template<class T> inline future<> async_dir(future<> _precondition, T _path, file_flags _flags = file_flags::none)
{
  return detail::async_dir<T>(std::move(_path), _flags)(std::move(_precondition));
}
template<class T, typename=typename std::enable_if<detail::is_not_handle<T>::value>::type> inline future<> async_dir(T _path, file_flags _flags = file_flags::none)
{
  return detail::async_dir<T>(std::move(_path), _flags)(future<>());
}
template<class T> inline handle_ptr dir(future<> _precondition, T _path, file_flags _flags = file_flags::none)
{
  return detail::async_dir<T>(std::move(_path), _flags)(std::move(_precondition)).get_handle();
}
template<class T, typename = typename std::enable_if<detail::is_not_handle<T>::value>::type> inline handle_ptr dir(T _path, file_flags _flags = file_flags::none)
{
  return detail::async_dir<T>(std::move(_path), _flags)(future<>()).get_handle();
}
template<class T> inline handle_ptr dir(error_code &_ec, future<> _precondition, T _path, file_flags _flags = file_flags::none)
{
  return detail::async_dir<T>(std::move(_path), _flags)(std::move(_precondition)).get_handle(_ec);
}
template<class T, typename = typename std::enable_if<detail::is_not_handle<T>::value>::type> inline handle_ptr dir(error_code &_ec, T _path, file_flags _flags = file_flags::none)
{
  return detail::async_dir<T>(std::move(_path), _flags)(future<>()).get_handle(_ec);
}

template<class T=path> inline future<> async_rmdir(future<> _precondition, T _path = path(), file_flags _flags = file_flags::none)
{
  return detail::async_rmdir<T>(std::move(_path), _flags)(std::move(_precondition));
}
template<class T, typename = typename std::enable_if<detail::is_not_handle<T>::value>::type> inline future<> async_rmdir(T _path, file_flags _flags = file_flags::none)
{
  return detail::async_rmdir<T>(std::move(_path), _flags)(future<>());
}
template<class T=path> inline void rmdir(future<> _precondition, T _path = path(), file_flags _flags = file_flags::none)
{
  detail::async_rmdir<T>(std::move(_path), _flags)(std::move(_precondition)).get_handle();
}
template<class T, typename = typename std::enable_if<detail::is_not_handle<T>::value>::type> inline void rmdir(T _path, file_flags _flags = file_flags::none)
{
  detail::async_rmdir<T>(std::move(_path), _flags)(future<>()).get_handle();
}
template<class T=path> inline void rmdir(error_code &_ec, future<> _precondition, T _path = path(), file_flags _flags = file_flags::none)
{
  detail::async_rmdir<T>(std::move(_path), _flags)(std::move(_precondition)).get_handle(_ec);
}
template<class T, typename = typename std::enable_if<detail::is_not_handle<T>::value>::type> inline void rmdir(error_code &_ec, T _path, file_flags _flags = file_flags::none)
{
  detail::async_rmdir<T>(std::move(_path), _flags)(future<>()).get_handle(_ec);
}

template<class T> inline future<> async_file(future<> _precondition, T _path, file_flags _flags = file_flags::none)
{
  return detail::async_file<T>(std::move(_path), _flags)(std::move(_precondition));
}
template<class T, typename = typename std::enable_if<detail::is_not_handle<T>::value>::type> inline future<> async_file(T _path, file_flags _flags = file_flags::none)
{
  return detail::async_file<T>(std::move(_path), _flags)(future<>());
}
template<class T> inline handle_ptr file(future<> _precondition, T _path, file_flags _flags = file_flags::none)
{
  return detail::async_file<T>(std::move(_path), _flags)(std::move(_precondition)).get_handle();
}
template<class T, typename = typename std::enable_if<detail::is_not_handle<T>::value>::type> inline handle_ptr file(T _path, file_flags _flags = file_flags::none)
{
  return detail::async_file<T>(std::move(_path), _flags)(future<>()).get_handle();
}
template<class T> inline handle_ptr file(error_code &_ec, future<> _precondition, T _path, file_flags _flags = file_flags::none)
{
  return detail::async_file<T>(std::move(_path), _flags)(std::move(_precondition)).get_handle(_ec);
}
template<class T, typename = typename std::enable_if<detail::is_not_handle<T>::value>::type> inline handle_ptr file(error_code &_ec, T _path, file_flags _flags = file_flags::none)
{
  return detail::async_file<T>(std::move(_path), _flags)(future<>()).get_handle(_ec);
}

template<class T=path> inline future<> async_rmfile(future<> _precondition, T _path = path(), file_flags _flags = file_flags::none)
{
  return detail::async_rmfile<T>(std::move(_path), _flags)(std::move(_precondition));
}
template<class T, typename = typename std::enable_if<detail::is_not_handle<T>::value>::type> inline future<> async_rmfile(T _path, file_flags _flags = file_flags::none)
{
  return detail::async_rmfile<T>(std::move(_path), _flags)(future<>());
}
template<class T=path> inline void rmfile(future<> _precondition, T _path = path(), file_flags _flags = file_flags::none)
{
  detail::async_rmfile<T>(std::move(_path), _flags)(std::move(_precondition)).get_handle();
}
template<class T, typename = typename std::enable_if<detail::is_not_handle<T>::value>::type> inline void rmfile(T _path, file_flags _flags = file_flags::none)
{
  detail::async_rmfile<T>(std::move(_path), _flags)(future<>()).get_handle();
}
template<class T=path> inline void rmfile(error_code &_ec, future<> _precondition, T _path = path(), file_flags _flags = file_flags::none)
{
  detail::async_rmfile<T>(std::move(_path), _flags)(std::move(_precondition)).get_handle(_ec);
}
template<class T, typename = typename std::enable_if<detail::is_not_handle<T>::value>::type> inline void rmfile(error_code &_ec, T _path, file_flags _flags = file_flags::none)
{
  detail::async_rmfile<T>(std::move(_path), _flags)(future<>()).get_handle(_ec);
}


template<class T> inline future<> async_symlink(future<> _precondition, T _path, future<> _target=future<>(), file_flags _flags = file_flags::none)
{
  return detail::async_symlink<T>(std::move(_path), _flags, std::move(_target))(std::move(_precondition));
}
template<class T, typename = typename std::enable_if<detail::is_not_handle<T>::value>::type> inline future<> async_symlink(T _path, future<> _target=future<>(), file_flags _flags = file_flags::none)
{
  return detail::async_symlink<T>(std::move(_path), _flags, std::move(_target))(future<>());
}
template<class T> inline handle_ptr symlink(future<> _precondition, T _path, future<> _target = future<>(), file_flags _flags = file_flags::none)
{
  return detail::async_symlink<T>(std::move(_path), _flags, std::move(_target))(std::move(_precondition)).get_handle();
}
template<class T, typename = typename std::enable_if<detail::is_not_handle<T>::value>::type> inline handle_ptr symlink(T _path, future<> _target = future<>(), file_flags _flags = file_flags::none)
{
  return detail::async_symlink<T>(std::move(_path), _flags, std::move(_target))(future<>()).get_handle();
}
template<class T> inline handle_ptr symlink(error_code &_ec, future<> _precondition, T _path, future<> _target = future<>(), file_flags _flags = file_flags::none)
{
  return detail::async_symlink<T>(std::move(_path), _flags, std::move(_target))(std::move(_precondition)).get_handle(_ec);
}
template<class T, typename = typename std::enable_if<detail::is_not_handle<T>::value>::type> inline handle_ptr symlink(error_code &_ec, T _path, future<> _target = future<>(), file_flags _flags = file_flags::none)
{
  return detail::async_symlink<T>(std::move(_path), _flags, std::move(_target))(future<>()).get_handle(_ec);
}

template<class T=path> inline future<> async_rmsymlink(future<> _precondition, T _path = path(), file_flags _flags = file_flags::none)
{
  return detail::async_rmsymlink<T>(std::move(_path), _flags)(std::move(_precondition));
}
template<class T, typename = typename std::enable_if<detail::is_not_handle<T>::value>::type> inline future<> async_rmsymlink(T _path, file_flags _flags = file_flags::none)
{
  return detail::async_rmsymlink<T>(std::move(_path), _flags)(future<>());
}
template<class T=path> inline void rmsymlink(future<> _precondition, T _path = path(), file_flags _flags = file_flags::none)
{
  detail::async_rmsymlink<T>(std::move(_path), _flags)(std::move(_precondition)).get_handle();
}
template<class T, typename = typename std::enable_if<detail::is_not_handle<T>::value>::type> inline void rmsymlink(T _path, file_flags _flags = file_flags::none)
{
  detail::async_rmsymlink<T>(std::move(_path), _flags)(future<>()).get_handle();
}
template<class T=path> inline void rmsymlink(error_code &_ec, future<> _precondition, T _path = path(), file_flags _flags = file_flags::none)
{
  detail::async_rmsymlink<T>(std::move(_path), _flags)(std::move(_precondition)).get_handle(_ec);
}
template<class T, typename = typename std::enable_if<detail::is_not_handle<T>::value>::type> inline void rmsymlink(error_code &_ec, T _path, file_flags _flags = file_flags::none)
{
  detail::async_rmsymlink<T>(std::move(_path), _flags)(future<>()).get_handle(_ec);
}


inline future<> async_sync(future<> _precondition)
{
  return detail::async_sync()(std::move(_precondition));
}
inline void sync(future<> _precondition)
{
  detail::async_sync()(std::move(_precondition)).get_handle();
}
inline void sync(error_code &_ec, future<> _precondition)
{
  detail::async_sync()(std::move(_precondition)).get_handle(_ec);
}


inline future<> async_zero(future<> _precondition, std::vector<std::pair<off_t, off_t>> ranges)
{
  return detail::async_zero(std::move(ranges))(std::move(_precondition));
}
inline void zero(future<> _precondition, std::vector<std::pair<off_t, off_t>> ranges)
{
  detail::async_zero(std::move(ranges))(std::move(_precondition)).get_handle();
}
inline void zero(error_code &_ec, future<> _precondition, std::vector<std::pair<off_t, off_t>> ranges)
{
  detail::async_zero(std::move(ranges))(std::move(_precondition)).get_handle(_ec);
}


inline future<> async_close(future<> _precondition)
{
  return detail::async_close()(std::move(_precondition));
}
inline void close(future<> _precondition)
{
  detail::async_close()(std::move(_precondition)).get_handle();
}
inline void close(error_code &_ec, future<> _precondition)
{
  detail::async_close()(std::move(_precondition)).get_handle(_ec);
}


template<class T> inline future<> async_read(future<> _precondition, T &&v, off_t _where)
{
  return detail::async_read(std::forward<T>(v), _where)(std::move(_precondition));
}
template<class T> inline future<> async_read(future<> _precondition, T &&v, size_t _length, off_t _where)
{
  return detail::async_read(std::forward<T>(v), _length, _where)(std::move(_precondition));
}
template<class T> inline void read(future<> _precondition, T &&v, off_t _where)
{
  detail::async_read(std::forward<T>(v), _where)(std::move(_precondition)).get_handle();
}
template<class T> inline void read(future<> _precondition, T &&v, size_t _length, off_t _where)
{
  detail::async_read(std::forward<T>(v), _length, _where)(std::move(_precondition)).get_handle();
}
template<class T> inline void read(error_code &_ec, future<> _precondition, T &&v, off_t _where)
{
  detail::async_read(std::forward<T>(v), _where)(std::move(_precondition)).get_handle(_ec);
}
template<class T> inline void read(error_code &_ec, future<> _precondition, T &&v, size_t _length, off_t _where)
{
  detail::async_read(std::forward<T>(v), _length, _where)(std::move(_precondition)).get_handle(_ec);
}


template<class T> inline future<> async_write(future<> _precondition, T &&v, off_t _where)
{
  return detail::async_write(std::forward<T>(v), _where)(std::move(_precondition));
}
template<class T> inline future<> async_write(future<> _precondition, T &&v, size_t _length, off_t _where)
{
  return detail::async_write(std::forward<T>(v), _length, _where)(std::move(_precondition));
}
template<class T> inline void write(future<> _precondition, T &&v, off_t _where)
{
  detail::async_write(std::forward<T>(v), _where)(std::move(_precondition)).get_handle();
}
template<class T> inline void write(future<> _precondition, T &&v, size_t _length, off_t _where)
{
  detail::async_write(std::forward<T>(v), _length, _where)(std::move(_precondition)).get_handle();
}
template<class T> inline void write(error_code &_ec, future<> _precondition, T &&v, off_t _where)
{
  detail::async_write(std::forward<T>(v), _where)(std::move(_precondition)).get_handle(_ec);
}
template<class T> inline void write(error_code &_ec, future<> _precondition, T &&v, size_t _length, off_t _where)
{
  detail::async_write(std::forward<T>(v), _length, _where)(std::move(_precondition)).get_handle(_ec);
}


inline future<> async_truncate(future<> _precondition, off_t newsize)
{
  return detail::async_truncate(newsize)(std::move(_precondition));
}
inline void truncate(future<> _precondition, off_t newsize)
{
  auto h=detail::async_truncate(newsize)(std::move(_precondition)).get_handle();
}
inline void truncate(error_code &_ec, future<> _precondition, off_t newsize)
{
  auto h=detail::async_truncate(newsize)(std::move(_precondition)).get_handle(_ec);
}


inline future<std::pair<std::vector<directory_entry>, bool>> async_enumerate(future<> _precondition, size_t _maxitems = 2, bool _restart = true, path _glob = path(),
  metadata_flags _metadata = metadata_flags::None, enumerate_req::filter _filtering = enumerate_req::filter::fastdeleted)
{
  return detail::async_enumerate(_maxitems, _restart, std::move(_glob), _metadata, _filtering)(std::move(_precondition));
}
inline std::pair<std::vector<directory_entry>, bool> enumerate(future<> _precondition, size_t _maxitems = 2, bool _restart = true, path _glob = path(),
  metadata_flags _metadata = metadata_flags::None, enumerate_req::filter _filtering = enumerate_req::filter::fastdeleted)
{
  return detail::async_enumerate(_maxitems, _restart, std::move(_glob), _metadata, _filtering)(std::move(_precondition)).get();
}
inline std::pair<std::vector<directory_entry>, bool> enumerate(error_code &_ec, future<> _precondition, size_t _maxitems = 2, bool _restart = true, path _glob = path(),
  metadata_flags _metadata = metadata_flags::None, enumerate_req::filter _filtering = enumerate_req::filter::fastdeleted)
{
  auto ret= detail::async_enumerate(_maxitems, _restart, std::move(_glob), _metadata, _filtering)(std::move(_precondition));
  if(!(_ec=ret.get_error()))
    return ret.get();
  return std::pair<std::vector<directory_entry>, bool>();
}
inline future<std::pair<std::vector<directory_entry>, bool>> async_enumerate(future<> _precondition, path _glob, size_t _maxitems = 2, bool _restart = true,
  metadata_flags _metadata = metadata_flags::None, enumerate_req::filter _filtering = enumerate_req::filter::fastdeleted)
{
  return detail::async_enumerate(_maxitems, _restart, std::move(_glob), _metadata, _filtering)(std::move(_precondition));
}
inline std::pair<std::vector<directory_entry>, bool> enumerate(future<> _precondition, path _glob, size_t _maxitems = 2, bool _restart = true,
  metadata_flags _metadata = metadata_flags::None, enumerate_req::filter _filtering = enumerate_req::filter::fastdeleted)
{
  return detail::async_enumerate(_maxitems, _restart, std::move(_glob), _metadata, _filtering)(std::move(_precondition)).get();
}
inline std::pair<std::vector<directory_entry>, bool> enumerate(error_code &_ec, future<> _precondition, path _glob, size_t _maxitems = 2, bool _restart = true,
  metadata_flags _metadata = metadata_flags::None, enumerate_req::filter _filtering = enumerate_req::filter::fastdeleted)
{
  auto ret = detail::async_enumerate(_maxitems, _restart, std::move(_glob), _metadata, _filtering)(std::move(_precondition));
  if (!(_ec = ret.get_error()))
    return ret.get();
  return std::pair<std::vector<directory_entry>, bool>();
}
inline future<std::pair<std::vector<directory_entry>, bool>> async_enumerate(future<> _precondition, metadata_flags _metadata, size_t _maxitems = 2, bool _restart = true,
  path _glob = path(), enumerate_req::filter _filtering = enumerate_req::filter::fastdeleted)
{
  return detail::async_enumerate(_maxitems, _restart, _glob, _metadata, _filtering)(std::move(_precondition));
}
inline std::pair<std::vector<directory_entry>, bool> enumerate(future<> _precondition, metadata_flags _metadata, size_t _maxitems = 2,
  bool _restart = true, path _glob = path(), enumerate_req::filter _filtering = enumerate_req::filter::fastdeleted)
{
  return detail::async_enumerate(_maxitems, _restart, std::move(_glob), _metadata, _filtering)(std::move(_precondition)).get();
}
inline std::pair<std::vector<directory_entry>, bool> enumerate(error_code &_ec, future<> _precondition, metadata_flags _metadata, size_t _maxitems = 2,
  bool _restart = true, path _glob = path(), enumerate_req::filter _filtering = enumerate_req::filter::fastdeleted)
{
  auto ret = detail::async_enumerate(_maxitems, _restart, std::move(_glob), _metadata, _filtering)(std::move(_precondition));
  if (!(_ec = ret.get_error()))
    return ret.get();
  return std::pair<std::vector<directory_entry>, bool>();
}


inline future<std::vector<std::pair<off_t, off_t>>> async_extents(future<> _precondition)
{
  return detail::async_extents()(std::move(_precondition));
}
inline std::vector<std::pair<off_t, off_t>> extents(future<> _precondition)
{
  return detail::async_extents()(std::move(_precondition)).get();
}
inline std::vector<std::pair<off_t, off_t>> extents(error_code &_ec, future<> _precondition)
{
  auto ret = detail::async_extents()(std::move(_precondition));
  if (!(_ec = ret.get_error()))
    return ret.get();
  return std::vector<std::pair<off_t, off_t>>();
}


inline future<statfs_t> async_statfs(future<> _precondition, fs_metadata_flags req)
{
  return detail::async_statfs(req)(std::move(_precondition));
}
inline statfs_t statfs(future<> _precondition, fs_metadata_flags req)
{
  return detail::async_statfs(req)(std::move(_precondition)).get();
}
inline statfs_t statfs(error_code &_ec, future<> _precondition, fs_metadata_flags req)
{
  auto ret = detail::async_statfs(req)(std::move(_precondition));
  if (!(_ec = ret.get_error()))
    return ret.get();
  return statfs_t();
}

inline future<> depends(future<> precondition, future<> out)
{
  return precondition.parent()->depends(precondition, out);
}

namespace utils
{
  BOOST_AFIO_HEADERS_ONLY_FUNC_SPEC std::vector<size_t> page_sizes(bool only_actually_available = true) noexcept;

  inline size_t file_buffer_default_size() noexcept
  {
    static size_t size;
    if (!size)
    {
      std::vector<size_t> sizes(page_sizes(true));
      for (auto &i : sizes)
        if (i >= 1024 * 1024)
        {
          size = i;
          break;
        }
      if (!size)
        size = 1024 * 1024;
    }
    return size;
  }

  BOOST_AFIO_HEADERS_ONLY_FUNC_SPEC void random_fill(char *buffer, size_t bytes);

#ifdef _MSC_VER
#pragma warning(push)
#pragma warning(disable: 6293) // MSVC sanitiser warns that we wrap n in the for loop
#endif
  inline size_t to_hex_string(char *out, size_t outlen, const char *_in, size_t inlen)
  {
    unsigned const char *in = (unsigned const char *) _in;
    static BOOST_CONSTEXPR_OR_CONST char table[] = "0123456789abcdef";
    if(outlen<inlen*2)
      BOOST_AFIO_THROW(std::invalid_argument("Output buffer too small."));
    for (size_t n = inlen - 2; n <= inlen - 2; n-=2)
    {
      out[n * 2 + 3] = table[(in[n+1] >> 4) & 0xf];
      out[n * 2 + 2] = table[in[n+1] & 0xf];
      out[n * 2 + 1] = table[(in[n] >> 4) & 0xf];
      out[n * 2 + 0] = table[in[n] & 0xf];
    }
    if(inlen&1)
    {
      out[1] = table[(in[0] >> 4) & 0xf];
      out[0] = table[in[0] & 0xf];
    }
    return inlen*2;
  }
#ifdef _MSC_VER
#pragma warning(pop)
#endif

  inline std::string to_hex_string(std::string in)
  {
    std::string out(in.size() * 2, ' ');
    to_hex_string(const_cast<char *>(out.data()), out.size(), in.data(), in.size());
    return out;
  }

  inline size_t from_hex_string(char *out, size_t outlen, const char *in, size_t inlen)
  {
    if (inlen % 2)
      BOOST_AFIO_THROW(std::invalid_argument("Input buffer not multiple of two."));
    if (outlen<inlen / 2)
      BOOST_AFIO_THROW(std::invalid_argument("Output buffer too small."));
    bool is_invalid=false;
    auto fromhex = [&is_invalid](char c) -> unsigned char
    {
#if 1
      // ASCII starting from 48 is 0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~
      //                           48               65                              97
      static BOOST_CONSTEXPR_OR_CONST unsigned char table[] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9,                                                    // +10 = 58
        255, 255, 255, 255, 255, 255, 255,                                                                                                      // +7  = 65
        10, 11, 12, 13, 14, 15,                                                                                                                 // +6  = 71
        255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,       // +26 = 97
        10, 11, 12, 13, 14, 15
      };
      unsigned char r=255;
      if(c>=48 && c<=102)
        r=table[c-48];
      if(r==255)
        is_invalid=true;
      return r;
#else
      if(c>='0' && c<='9')
        return c-'0';
      if(c>='a' && c<='f')
        return c-'a'+10;
      if(c>='A' && c<='F')
        return c-'A'+10;
      BOOST_AFIO_THROW(std::invalid_argument("Input is not hexadecimal."));
#endif
    };
    for (size_t n = 0; n<inlen/2; n+=4)
    {
      unsigned char c[8];
      c[0]= fromhex(in[n * 2]);
      c[1]= fromhex(in[n * 2 + 1]);
      c[2]= fromhex(in[n * 2 + 2]);
      c[3]= fromhex(in[n * 2 + 3]);
      out[n]=(c[1]<<4)|c[0];
      c[4]= fromhex(in[n * 2 + 4]);
      c[5]= fromhex(in[n * 2 + 5]);
      out[n+1]=(c[3]<<4)|c[2];
      c[6]= fromhex(in[n * 2 + 6]);
      c[7]= fromhex(in[n * 2 + 7]);
      out[n+2]=(c[5]<<4)|c[4];
      out[n+3]=(c[7]<<4)|c[6];
    }
    for (size_t n = inlen/2-(inlen/2)%4; n<inlen/2; n++)
    {
      unsigned char c1 = fromhex(in[n * 2]), c2 = fromhex(in[n * 2 + 1]);
      out[n]=(c2<<4)|c1;
    }
    if(is_invalid)
      BOOST_AFIO_THROW(std::invalid_argument("Input is not hexadecimal."));
    return inlen/2;
  }

  inline std::string random_string(size_t randomlen)
  {
    size_t outlen = randomlen*2;
    std::string ret(outlen, 0);
    random_fill(const_cast<char *>(ret.data()), randomlen);
    to_hex_string(const_cast<char *>(ret.data()), outlen, ret.data(), randomlen);
    return ret;
  }

#ifndef BOOST_AFIO_SECDEC_INTRINSICS
# if defined(__GCC__) || defined(__clang__)
#  define BOOST_AFIO_SECDEC_INTRINSICS 1
# elif defined(_MSC_VER) && (defined(_M_X64) || _M_IX86_FP==1)
#  define BOOST_AFIO_SECDEC_INTRINSICS 1
# endif
#endif
#ifndef BOOST_AFIO_SECDEC_INTRINSICS
# define BOOST_AFIO_SECDEC_INTRINSICS 0
#endif

  template<size_t blocksize> class secded_ecc
  {
  public:
    typedef unsigned int result_type; 
  private:
    static BOOST_CONSTEXPR_OR_CONST size_t bits_per_byte=8;
    typedef unsigned char unit_type;  // The batch unit of processing
    result_type bitsvalid;
    // Many CPUs (x86) are slow doing variable bit shifts, so keep a table
    result_type ecc_twospowers[sizeof(result_type)*bits_per_byte];
    unsigned short ecc_table[blocksize*bits_per_byte];
    static bool _is_single_bit_set(result_type x)
    {
#ifndef _MSC_VER
#if defined(__i386__) || defined(__x86_64__)
#ifndef __SSE4_2__
      // Do a once off runtime check
      static int have_popcnt=[]{
        size_t cx, dx;
#if defined(__x86_64__)
        asm("cpuid": "=c" (cx), "=d" (dx) : "a" (1), "b" (0), "c" (0), "d" (0));
#else
        asm("pushl %%ebx\n\tcpuid\n\tpopl %%ebx\n\t": "=c" (cx), "=d" (dx) : "a" (1), "c" (0), "d" (0));
#endif
        return (dx&(1<<26))!=0/*SSE2*/ && (cx&(1<<23))!=0/*POPCNT*/;
      }();
      if(have_popcnt)
#endif
      {
        unsigned count;
        asm("popcnt %1,%0" : "=r"(count) : "rm"(x) : "cc");
        return count==1;
      }
#endif
      return __builtin_popcount(x)==1;
#else
      x -= (x >> 1) & 0x55555555;
      x = (x & 0x33333333) + ((x >> 2) & 0x33333333);
      x = (x + (x >> 4)) & 0x0f0f0f0f;
      unsigned int count=(x * 0x01010101)>>24;
      return count==1;
#if 0
      x -= (x >> 1) & 0x5555555555555555ULL;
      x = (x & 0x3333333333333333ULL) + ((x >> 2) & 0x3333333333333333ULL);
      x = (x + (x >> 4)) & 0x0f0f0f0f0f0f0f0fULL;
      unsigned long long count=(x * 0x0101010101010101ULL)>>56;
      return count==1;
#endif
#endif
    }
  public:
    BOOST_CXX14_CONSTEXPR secded_ecc()
    {
      for(size_t n=0; n<sizeof(result_type)*bits_per_byte; n++)
        ecc_twospowers[n]=((result_type)1<<n);
      result_type length=blocksize*bits_per_byte;
      // This is (data bits + parity bits + 1) <= 2^(parity bits)
      for(result_type p=1; p<sizeof(result_type)*bits_per_byte; p++)
        if((length+p+1)<=ecc_twospowers[p])
        {
          bitsvalid=p;
          break;
        }
      if((bits_per_byte-1+bitsvalid)/bits_per_byte>sizeof(result_type))
        BOOST_AFIO_THROW(std::runtime_error("ECC would exceed the size of result_type!"));
      for(result_type i=0; i<blocksize*bits_per_byte; i++)
      {
        // Make a code bit
        result_type b=i+1;
#if BOOST_AFIO_SECDEC_INTRINSICS && 0 // let constexpr do its thing
#ifdef _MSC_VER
        unsigned long _topbit;
        _BitScanReverse(&_topbit, b);
        result_type topbit=_topbit;
#else
        result_type topbit=bits_per_byte*sizeof(result_type)-__builtin_clz(b);
#endif
        b+=topbit;
        if(b>=ecc_twospowers[topbit]) b++;
        //while(b>ecc_twospowers(_topbit+1)) _topbit++;
        //b+=_topbit;
        //if(b>=ecc_twospowers(_topbit)) b++;
#else
        for(size_t p=0; ecc_twospowers[p]<(b+1); p++)
          b++;
#endif
        ecc_table[i]=(unsigned short) b;
        if(b>(unsigned short)-1)
          BOOST_AFIO_THROW(std::runtime_error("Precalculated table has exceeded its bounds"));
      }
    }
    constexpr result_type result_bits_valid() const noexcept
    {
      return bitsvalid;
    }
    result_type operator()(result_type ecc, const char *buffer) const noexcept
    {
      if(blocksize<sizeof(unit_type)*8)
        return (*this)(ecc, buffer, blocksize);
      // Process in lumps of eight
      const unit_type *_buffer=(const unit_type *) buffer;
//#pragma omp parallel for reduction(^:ecc)
      for(size_t i=0; i<blocksize; i+=sizeof(unit_type)*8)
      {
        union { unsigned long long v; unit_type c[8]; };
        result_type prefetch[8];
        v=*(unsigned long long *)(&_buffer[0+i/sizeof(unit_type)]); // min 1 cycle
#define BOOST_AFIO_ROUND(n) \
          prefetch[0]=ecc_table[(i+0)*8+n]; \
          prefetch[1]=ecc_table[(i+1)*8+n]; \
          prefetch[2]=ecc_table[(i+2)*8+n]; \
          prefetch[3]=ecc_table[(i+3)*8+n]; \
          prefetch[4]=ecc_table[(i+4)*8+n]; \
          prefetch[5]=ecc_table[(i+5)*8+n]; \
          prefetch[6]=ecc_table[(i+6)*8+n]; \
          prefetch[7]=ecc_table[(i+7)*8+n]; \
          if(c[0]&((unit_type)1<<n))\
            ecc^=prefetch[0];\
          if(c[1]&((unit_type)1<<n))\
            ecc^=prefetch[1];\
          if(c[2]&((unit_type)1<<n))\
            ecc^=prefetch[2];\
          if(c[3]&((unit_type)1<<n))\
            ecc^=prefetch[3];\
          if(c[4]&((unit_type)1<<n))\
            ecc^=prefetch[4];\
          if(c[5]&((unit_type)1<<n))\
            ecc^=prefetch[5];\
          if(c[6]&((unit_type)1<<n))\
            ecc^=prefetch[6];\
          if(c[7]&((unit_type)1<<n))\
            ecc^=prefetch[7];
        BOOST_AFIO_ROUND(0)                                                    // prefetch = min 8, bit test and xor = min 16, total = 24
        BOOST_AFIO_ROUND(1)
        BOOST_AFIO_ROUND(2)
        BOOST_AFIO_ROUND(3)
        BOOST_AFIO_ROUND(4)
        BOOST_AFIO_ROUND(5)
        BOOST_AFIO_ROUND(6)
        BOOST_AFIO_ROUND(7)
  #undef BOOST_AFIO_ROUND                                                      // total should be 1+(8*24/3)=65
      }
      return ecc;
    }
    result_type operator()(const char *buffer) const noexcept { return (*this)(0, buffer); }
    result_type operator()(result_type ecc, const char *buffer, size_t length) const noexcept
    {
      const unit_type *_buffer=(const unit_type *) buffer;
//#pragma omp parallel for reduction(^:ecc)
      for(size_t i=0; i<length; i+=sizeof(unit_type))
      {
        unit_type c=_buffer[i/sizeof(unit_type)];                 // min 1 cycle
        if(!c)                                                    // min 1 cycle
          continue;
        char bitset[bits_per_byte*sizeof(unit_type)];
        result_type prefetch[bits_per_byte*sizeof(unit_type)];
        // Most compilers will roll this out
        for(size_t n=0; n<bits_per_byte*sizeof(unit_type); n++)   // min 16 cycles
        {
          bitset[n]=!!(c&((unit_type)1<<n));
          prefetch[n]=ecc_table[i*bits_per_byte+n];               // min 8 cycles
        }
        result_type localecc=0;
        for(size_t n=0; n<bits_per_byte*sizeof(unit_type); n++)
        {
          if(bitset[n])                                           // min 8 cycles
            localecc^=prefetch[n];                                // min 8 cycles
        }
        ecc^=localecc;                                            // min 1 cycle. Total cycles = min 43 cycles/byte
      }
      return ecc;
    }
    result_type operator()(const char *buffer, size_t length) const noexcept { return (*this)(0, buffer, length); }
    result_type find_bad_bit(result_type good_ecc, result_type bad_ecc) const noexcept
    {
      result_type length=blocksize*bits_per_byte, eccdiff=good_ecc^bad_ecc;
      if(_is_single_bit_set(eccdiff))
        return (result_type)-1;
      for(result_type i=0, b=1; i<length; i++, b++)
      {
        // Skip parity bits
        while(_is_single_bit_set(b))
          b++;
        if(b==eccdiff)
          return i;
      }
      return (result_type)-1;
    }
    enum verify_status
    {
      corrupt=0,  
      okay=1,     
      healed=2    
    };
    verify_status verify(char *buffer, result_type good_ecc) const noexcept
    {
      result_type this_ecc=(*this)(0, buffer);
      if(this_ecc==good_ecc)
        return verify_status::okay; // no errors
      result_type badbit=find_bad_bit(good_ecc, this_ecc);
      if((result_type)-1==badbit)
        return verify_status::corrupt; // parity corrupt?
      buffer[badbit/bits_per_byte]^=(unsigned char) ecc_twospowers[badbit%bits_per_byte];
      this_ecc=(*this)(0, buffer);
      if(this_ecc==good_ecc)
        return healed; // error healed
      // Put the bit back
      buffer[badbit/bits_per_byte]^=(unsigned char) ecc_twospowers[badbit%bits_per_byte];
      return verify_status::corrupt; // more than one bit was corrupt
    }
  };
 
  namespace detail
  {
    struct large_page_allocation
    {
      void *p;
      size_t page_size_used;
      size_t actual_size;
      large_page_allocation() : p(nullptr), page_size_used(0), actual_size(0) { }
      large_page_allocation(void *_p, size_t pagesize, size_t actual) : p(_p), page_size_used(pagesize), actual_size(actual) { }
    };
    inline large_page_allocation calculate_large_page_allocation(size_t bytes)
    {
      large_page_allocation ret;
      auto pagesizes(page_sizes());
      do
      {
        ret.page_size_used=pagesizes.back();
        pagesizes.pop_back();
      } while(!pagesizes.empty() && !(bytes/ret.page_size_used));
      ret.actual_size=(bytes+ret.page_size_used-1)&~(ret.page_size_used-1);
      return ret;    
    }
    BOOST_AFIO_HEADERS_ONLY_FUNC_SPEC large_page_allocation allocate_large_pages(size_t bytes);
    BOOST_AFIO_HEADERS_ONLY_FUNC_SPEC void deallocate_large_pages(void *p, size_t bytes);
  }
  template <typename T>
  class page_allocator
  {
  public:
      typedef T         value_type;
      typedef T*        pointer;
      typedef const T*  const_pointer;
      typedef T& reference;
      typedef const T&  const_reference;
      typedef size_t    size_type;
      typedef ptrdiff_t difference_type;
      typedef std::true_type propagate_on_container_move_assignment;
      typedef std::true_type is_always_equal;

      template <class U>
      struct rebind { typedef page_allocator<U> other; };

      page_allocator() noexcept
      {}

      template <class U>
      page_allocator(const page_allocator<U>&) noexcept
      {}

      size_type
      max_size() const noexcept
      { return size_type(~0) / sizeof(T); }

      pointer
      address(reference x) const noexcept
      { return std::addressof(x); }

      const_pointer
      address(const_reference x) const noexcept
      { return std::addressof(x); }

      pointer
      allocate(size_type n, const void *hint = 0)
      {
          if(n>max_size())
              throw std::bad_alloc();
          auto mem(detail::allocate_large_pages(n * sizeof(T)));
          if (mem.p == nullptr)
              throw std::bad_alloc();
          return reinterpret_cast<pointer>(mem.p);
      }

      void
      deallocate(pointer p, size_type n)
      {
          if(n>max_size())
              throw std::bad_alloc();
          detail::deallocate_large_pages(p, n * sizeof(T));
      }

      template <class U, class ...Args>
      void
      construct(U* p, Args&&... args)
      { ::new(reinterpret_cast<void*>(p)) U(std::forward<Args>(args)...); }

      template <class U> void
      destroy(U* p)
      { p->~U(); }
  };
  template <>
  class page_allocator<void>
  {
  public:
      typedef void         value_type;
      typedef void*        pointer;
      typedef const void*  const_pointer;
      typedef std::true_type propagate_on_container_move_assignment;
      typedef std::true_type is_always_equal;

      template <class U>
      struct rebind { typedef page_allocator<U> other; };
  };
  template<class T, class U> inline bool operator==(const page_allocator<T> &, const page_allocator<U> &) noexcept { return true; }
}


BOOST_AFIO_V2_NAMESPACE_END

// Specialise std::hash<> for directory_entry
#ifndef BOOST_AFIO_DISABLE_STD_HASH_SPECIALIZATION
#include <functional>
namespace std
{
    template<> struct hash<BOOST_AFIO_V2_NAMESPACE::path>
    {
    public:
        size_t operator()(const BOOST_AFIO_V2_NAMESPACE::path &p) const
        {
            return BOOST_AFIO_V2_NAMESPACE::path_hash()(p);
        }
    };
    template<> struct hash<BOOST_AFIO_V2_NAMESPACE::directory_entry>
    {
    public:
        size_t operator()(const BOOST_AFIO_V2_NAMESPACE::directory_entry &p) const
        {
            return BOOST_AFIO_V2_NAMESPACE::directory_entry_hash()(p);
        }
    };

}//namesapce std
#endif

#ifdef BOOST_MSVC
#pragma warning(pop)
#endif

#if BOOST_AFIO_HEADERS_ONLY == 1 && !defined(DOXYGEN_SHOULD_SKIP_THIS)
#undef BOOST_AFIO_VALIDATE_INPUTS // Let BOOST_AFIO_NEVER_VALIDATE_INPUTS take over
#define BOOST_AFIO_HEADER_INCLUDED 1
#include "detail/impl/afio.ipp"
#undef BOOST_AFIO_HEADER_INCLUDED
#endif

#endif
#endif