seminar 2023-03-10

// fibonacci

#include <iostream>

using std::cout;

template<int n>
int fib() {
    if constexpr (n <= 1) {
        return n;
    } else {
        return fib<n - 1>() + fib<n - 2>();
    }
}

// template<> int fib<0> () { return 0; }
// template<> int fib<1> () { return 1; }

int main() {
    cout << fib<10>() << "\n";
}

// type traits

#include <iostream>
#include <string>

template <bool> bool value = false;
template <> bool value<true> = true;

template <typename T, bool is_number = std::is_fundamental_v<T>>
struct TTypeTraits {
    using TArgument = T&;
};

template <typename T>
struct TTypeTraits<T, true> {
    using TArgument = T;
};

template <typename T>
void Print(typename TTypeTraits<const T>::TArgument arg) {
    std::cout << std::to_string(arg) << "\n";
}

struct TFlags {
    enum EValue {
        GOOD = 1 << 0,
        BAD  = 1 << 1,
        OK   = 1 << 2,
        UNKNOWN = 1 << 3
    };

    template <typename... Args>
    void AddFlags(Args... args) {
        ((value |= args), ...);
    }
    template <typename... Args>
    bool HasFlags(Args... args) {
        EValue flags = (args | ...);
        return value == flags;
    }
    template <typename... Args>
    void ClearFlags(Args... args) {
        ((value &= ~args), ...);
    }

    EValue value;
};

int main() {
    Print<float>(42.);

    TFlags flags;
    flags.AddFlags(TFlags::BAD, TFlags::OK);
    flags.HasFlags(TFlags::GOOD);
}