lazy.hh

/*
 * This file is open source software, licensed to you under the terms
 * of the Apache License, Version 2.0 (the "License").  See the NOTICE file
 * distributed with this work for additional information regarding copyright
 * ownership.  You may not use this file except in compliance with the License.
 *
 * You may obtain a copy of the License at
 *
 *   http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing,
 * software distributed under the License is distributed on an
 * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
 * KIND, either express or implied.  See the License for the
 * specific language governing permissions and limitations
 * under the License.
 */
/*
 * Copyright (C) 2016 Cloudius Systems, Ltd.
 */
#pragma once
 
#include <ostream>
#include <fmt/core.h>
 
 
namespace seastar {
 
template<typename Func>
class lazy_eval {
private:
    Func _func;
 
private:
    lazy_eval(Func&& f) : _func(std::forward<Func>(f)) {}
 
public:
    auto operator()() {
        return _func();
    }
 
    auto operator()() const {
        return _func();
    }
 
    template <typename F>
    friend lazy_eval<F> value_of(F&& func);
};
 
 
template <typename Func>
inline lazy_eval<Func> value_of(Func&& func) {
    return lazy_eval<Func>(std::forward<Func>(func));
}
 
template <typename T>
struct lazy_deref_wrapper {
    const T& p;
 
    constexpr lazy_deref_wrapper(const T& p) : p(p) {
    }
};
 
template <typename T>
lazy_deref_wrapper<T>
lazy_deref(const T& p) {
    return lazy_deref_wrapper<T>(p);
}
 
}
 
namespace std {
template <typename Func>
ostream& operator<<(ostream& os, const seastar::lazy_eval<Func>& lf) {
    return os << lf();
}
 
template <typename Func>
ostream& operator<<(ostream& os, seastar::lazy_eval<Func>& lf) {
    return os << lf();
}
 
template <typename Func>
ostream& operator<<(ostream& os, seastar::lazy_eval<Func>&& lf) {
    return os << lf();
}
 
template <typename T>
ostream& operator<<(ostream& os, seastar::lazy_deref_wrapper<T> ld) {
    if (ld.p) {
        return os << *ld.p;
    }
 
    return os << "null";
}
}
 
template <typename Func>
struct fmt::formatter<seastar::lazy_eval<Func>> : fmt::formatter<std::string_view> {
    template <typename FormatContext>
    auto format(const seastar::lazy_eval<Func>& lf, FormatContext& ctx) const {
        return fmt::format_to(ctx.out(), "{}", lf());
    }
};
 
template <typename T>
struct fmt::formatter<seastar::lazy_deref_wrapper<T>> : fmt::formatter<std::string_view> {
    template <typename FormatContext>
    auto format(const seastar::lazy_deref_wrapper<T>& ld, FormatContext& ctx) const {
        if (ld.p) {
            return fmt::format_to(ctx.out(), "{}", *ld.p);
        } else {
            return fmt::format_to(ctx.out(), "null");
        }
    }
};