result_list runner::test_range(files_iterator begin, files_iterator end, std::reference_wrapper<report_type> report) const
{
    config defaults;
    result_list results;

    for (runner::files_iterator i = begin; i != end; i++)
    {
        runner::path_type const & file = *i;
        if (file.extension() == ".xml")
        {
            try
            {
                result_list r = test_one(file, defaults, report);
                std::move(r.begin(), r.end(), std::back_inserter(results));
            }
            catch (std::exception const& ex)
            {
                result r;
                r.state = STATE_ERROR;
                r.name = file.string();
                r.error_message = ex.what();
                results.emplace_back(r);
                mapnik::util::apply_visitor(report_visitor(r), report.get());
            }
        }
    }

    return results;
}

 static std::shared_ptr<Data> get(std::reference_wrapper<T> obj, bool t_return_value)
 {
   auto p = &obj.get();
   return std::make_shared<Data>(
         detail::Get_Type_Info<T>::get(),
         chaiscript::detail::Any(std::move(obj)),
         true,
         p,
         t_return_value
       );
 }

void jsonStoreInterpolations(std::reference_wrapper<RevisionThree> json, const InterpolationList &interpolations)
{
    namespace Base64VLQ = SourceMap::intern::Base64VLQ;
    if (interpolations.empty()) return; // nothing to store

    QString encoded;
    for(const auto& p : interpolations) {
        Base64VLQ::encode(encoded, static_cast<int>(p.first));
        Base64VLQ::encode(encoded, p.second);
    }
    json.get().insert(INTERPOLATIONS_KEY, encoded);
}

 void consume(std::reference_wrapper<T>& x) {
   return consume(x.get());
 }

 void operator()(msgpack::object::with_zone& o, const std::reference_wrapper<T>& v) const {
     msgpack::adaptor::object_with_zone<typename std::remove_const<T>::type>()(o, v.get());
 }

 ranges::reference_wrapper<T> operator()(std::reference_wrapper<T> ref) const
 {
     return ranges::ref(ref.get());
 }

 output_stream(std::reference_wrapper<std::ostream> os)
   : write_f(make_std_ostream_write_function(os.get()))
 {}

		optional(const std::reference_wrapper<Tc>& t) : optional(std::addressof(t.get())) {

		}

 reference_wrapper<T> operator()(std::reference_wrapper<T> t) const
 {
     return {t.get()};
 }

 static inline bool cmp(const T& lhs, const std::reference_wrapper<U>& rhs) {
     return vg_cmp<T>::_(lhs, rhs.get());
 }

 auto operator()(std::reference_wrapper<T> rw){
   return (*this)(rw.get());
 }

 void operator() ()
 {
     results.get().call = true;
 }

 /**
  * Write implementation delegated to the underlying sink
  * 
  * @param buffer source buffer
  * @param length number of bytes to process
  * @return number of bytes processed
  */
 std::streamsize write(const char* buffer, std::streamsize length) {
     return sink.get().write(buffer, length);
 }

 /**
  * Read implementation delegated to the underlying source
  * 
  * @param buffer output buffer
  * @param length number of bytes to process
  * @return number of bytes processed
  */
 std::streamsize read(char* buffer, std::streamsize length) {
     return src.get().read(buffer, length);
 }

 /**
  * Underlying source accessor
  * 
  * @return underlying source reference
  */
 Source& get_source() {
     return src.get();
 }

 /**
  * Flushes destination sink
  * 
  * @return number of bytes flushed
  */
 std::streamsize flush() {
     return sink.get().flush();
 }

 void wait() {
     m_task.get().wait();
 }

 /**
  * Underlying sink accessor
  * 
  * @return underlying sink reference
  */
 Sink& get_sink() {
     return sink.get();
 }

 void cancel() {
     m_task.get().cancel();
 }

 bool completed() {
     return m_task.get().completed();
 }