height: 5.5
weight: 130
poops: nutty

struct Person {
    double height;
    int weight;
    std::string poops;
};

Person person;
std::tie(person.height, person.weight, person.poops) =
    cache.get_many("height", "weight", "poops");

// forward declaration
template <typename ...Ts, typename ...Keys> 
std::tuple<Ts...> read_all_(
    const Mapping& map,
    Keys... keys
);

// recursive case
template <typename T, typename ...Ts, typename Key, typename ...Keys>
std::tuple<T, Ts...> read_all_(
    const Mapping& map,
    Key key,
    Keys... rest)
{
    return std::tuple_cat(
        std::make_tuple(boost::lexical_cast<T, std::string>(map.at(key))),
        read_all(map, rest...)
    );
}

// base case
std::tuple<> read_all_(const Mapping& _) {
    return std::make_tuple();
}

// public wrapper function: 
template <typename ...Ts, typename ...Keys>
std::tuple<Ts...> get_many(Keys... keys) {
    auto map = parse_();
    return read_all_(map, keys...);
}

test_file_cache.cpp:59:23: error: no viable overloaded '='
    std::tie(person.height, person.weight, person.poops) =
    ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ ^
/Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/bin/../include/c++/v1/tuple:501:29: note:
      candidate function (the implicit move assignment operator) not viable: no
      known conversion from 'tuple<(no argument), (no argument), (no
      argument)>' to 'tuple<double &, int &, std::__1::basic_string<char>
      &>' for 1st argument
class _LIBCPP_TYPE_VIS_ONLY tuple
                            ^
/Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/bin/../include/c++/v1/tuple:501:29: note:
      candidate function (the implicit copy assignment operator) not viable: no
      known conversion from 'tuple<(no argument), (no argument), (no
      argument)>' to 'const tuple<double &, int &,
      std::__1::basic_string<char> &>' for 1st argument
/Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/bin/../include/c++/v1/tuple:693:26: note:
      candidate template ignored: disabled by 'enable_if' [with _Tuple =
      std::__1::tuple<>]
                         __tuple_assignable<_Tuple, tuple>::value
                         ^

VikingofRock fucked around with this message at 03:44 on Aug 16, 2017

// base case
template <typename ...Ts, typename ...Keys> 
typename std::enable_if<sizeof...(Ts) == 0 && sizeof...(Keys) == 0,
                        std::tuple<Ts...>>::type
read_all_(const Mapping&, Keys...) {
    return std::make_tuple();
}

// recursive case
template <typename T, typename ...Ts, typename Key, typename ...Keys>
std::tuple<T, Ts...> read_all_(
    const Mapping& map,
    Key key,
    Keys... rest)
{
    return std::tuple_cat(
        std::make_tuple(boost::lexical_cast<T>(map.at(key))),
        read_all_<Ts...>(map, rest...)
    );
}

// public wrapper function
template <typename ...Ts, typename ...Keys>
std::tuple<Ts...> get_many(Keys... keys) {
    auto map = parse_();
    return read_all_<Ts...>(map, keys...);
}

// gotta call it like this:
std::tie(person.height, person.weight, person.poops) =
    cache.get_many<double, int, std::string>("height", "weight", "poops");

VikingofRock fucked around with this message at 03:46 on Aug 16, 2017

qhat fucked around with this message at 17:16 on Aug 16, 2017

local baz = {}
baz.__index = baz

function baz:bar()
    print(self.a)
end

local foo = { a = "fart" }
setmetatable(foo, baz)
foo:bar() -- accessing a nonexistent value in a table uses its metatable's __index
-- roughly equivalent to
baz.bar(foo)

Pollyzoid fucked around with this message at 20:27 on Aug 16, 2017