member.cpp

Go to the documentation of this file.

/*
 * SPDX-FileCopyrightText: © 2026 Larry Chips <larry@larrychips.net>
 * SPDX-Licence-Identifier: MIT
 */
#include "samples_output.hpp"
#include "samples_types_printer.hpp"
 
#include <ugmisc/member.hpp>
 
#include <cassert>
#include <functional>
 
 
struct Things;
 
 
#ifdef UGMISC_HAVE_CONCEPTS
template<typename OStream>
inline auto& operator<<(OStream& out, Things* things)
requires std::same_as<OStream, std::ostream> || std::same_as<OStream, std::wostream>
{
    return out << "<Things>";
}
#else
template<typename OStream>
inline auto& thingsOutput(OStream& out, Things* things) {
    return out << "<Things>";
}
 
inline std::ostream& operator<<(std::ostream& out, Things* things) {
    return thingsOutput(out, things);
}
 
inline std::wostream& operator<<(std::wostream& out, Things* things) {
    return thingsOutput(out, things);
}
#endif
 
 
/*
 * These declarations can appear at namespace scope or in a class or a class
 * template.  They can't appear inside a function unfortunately, due to having
 * member class templates.
 *
 * Resulting declarations are:
 *
 *  struct Womble; // Finds members called "womble".
 *  struct Use;    // Finds members called "use".
 *  struct Name;   // Finds members called "name".
 */
UGMISC_DECL_MEMBER_ACCESS(Womble, womble);
UGMISC_DECL_MEMBER_ACCESS(Use, use);
UGMISC_DECL_MEMBER_ACCESS(Name, name);
 
 
/*
 * Use various womble types through its WombleTraits in the same way allocators
 * are used through std::allocator_traits.
 */
template<typename T>
struct WombleTraits {
private:
    static inline const char* defaultWomble(T&);
    static inline const char* defaultUse(T&, Things*);
    static inline const char* defaultName(T&);
 
public:
    // Womble is a verb (to womble, he wombles, wombling free).
    static auto womble(T& w) {
        // Call w.womble() if possible, or defaultWomble(w) otherwise.
        return ugmisc::member_caller<Womble>::fallback(
                [&]() {
                    return defaultWomble(w);
                }
                )(w)();
    }
 
    /*
     * Make good use of the things that the womble finds.
     *
     * We could do this in a very similar way to womble() but this way shows it
     * doesn't all have to be crammed into one horrible expression.
     */
    static auto use(T& w, Things* found) {
        // Call w.use(found) if possible,
        // or defaultUse(w, found) if possible,
        // or defaultUse(w) otherwise.
        auto getDefault = [&](auto...args) {
            return defaultUse(w, args...);
        };
        auto caller = ugmisc::member_caller<Use>::fallback(getDefault)(w);
        return caller(found);
    }
 
    static auto name(T& w) {
        using namespace ugmisc;
 
        // Try w.name() then w.name then defaultName().
        auto getDefaultName = [&]() { return defaultName(w); };
        auto getNameValue = [&]() {
            return member_value<Name>{}(w)(getDefaultName);
        };
        auto getNameFunction = member_caller<Name>::fallback(getNameValue)(w);
        return getNameFunction();
    }
};
 
 
template<typename T>
const char* WombleTraits<T>::defaultWomble(T&) {
    SampleOutput out;
    out << "WombleTraits::defaultWomble(" << getTypeName<T>() << "&)";
    return "WombleTraits::defaultWomble()";
}
 
template<typename T>
const char* WombleTraits<T>::defaultUse(T&, Things*) {
    SampleOutput out;
    out << "WombleTraits::defaultUse(" << getTypeName<T>() << "&, Things*)";
    return "WombleTraits::defaultUse()";
}
 
template<typename T>
const char* WombleTraits<T>::defaultName(T&) {
    SampleOutput out;
    out << "WombleTraits::defaultName(" << getTypeName<T>() << "&)";
    return "WombleTraits::defaultName()";
}
 
 
 
struct CompleteWomble {
    static constexpr const char *sTypeName = "CompleteWomble";
 
    const char * use(Things* found) {
        SampleOutput out;
        out << "CompleteWomble::use(" << found << ")";
        return "CompleteWomble::use()";
    }
 
    const char *name() {
        SampleOutput out;
        out << "CompleteWomble::name()";
        return "CompleteWomble";
    }
 
    const char *womble() {
        SampleOutput out;
        out << "CompleteWomble::womble()";
        return "CompleteWomble::womble()";
    }
};
 
 
struct EmptyWomble {
    static constexpr const char *sTypeName = "EmptyWomble";
};
 
 
int main(int, char**) {
    SampleOutput out;
    auto always = out.always();
    auto expect = out.expect();
 
    Things* things;
 
    CompleteWomble complete;
    EmptyWomble empty;
 
    using CompleteTraits = WombleTraits<CompleteWomble>;
    using EmptyTraits = WombleTraits<EmptyWomble>;
 
    always << "CompleteTraits::name(complete)\n ";
    CompleteTraits::name(complete);
    out << "\n";
    expect << "CompleteWomble::name()"
        "\n";
 
    always << "CompleteTraits::womble(complete)\n ";
    CompleteTraits::womble(complete);
    out << "\n";
    expect << "CompleteWomble::womble()"
        "\n";
 
    always << "CompleteTraits::use(complete, things)\n ";
    CompleteTraits::use(complete, things);
    out << "\n";
    expect << "CompleteWomble::use(" << things << ")"
        "\n";
 
    always << "EmptyTraits::name(empty)\n ";
    EmptyTraits::name(empty);
    out << "\n";
    expect << "WombleTraits::defaultName(" << getTypeName<EmptyWomble>() << "&)"
        "\n";
 
    always << "EmptyTraits::womble(empty)\n ";
    EmptyTraits::womble(empty);
    out << "\n";
    expect << "WombleTraits::defaultWomble(" << getTypeName<EmptyWomble>() << "&)"
        "\n";
 
    always << "EmptyTraits::use(empty, things)\n ";
    EmptyTraits::use(empty, things);
    out << "\n";
    expect << "WombleTraits::defaultUse(" << getTypeName<EmptyWomble>() << "&, Things*)"
        "\n";
 
 
    return 0;
}