Tag: Meta

My intention is to implement a single value container which stores all possible types, like QVariant or others does. I tried to take advantage of std::any which gives a type safe container for the same purpose. Additionally I would like to store some meta data (timestamps mostly) which refer to target value.

I came up so far with two solutions which does not work properly. The class template version Value works but the interface does not fit properly in my opinion. See the first get function for an example. One need to know which type is returned on invocation. auto could help, but not in all situations.

The second solution has a pretty nice interface, like QVariant. See the access function get which returns LateValue. After calling this function one can dig deeper for the stored type and so on. Problem here is whenever I put this stuff into a library the template methods (getter and constructor) do not get instantiated. One can do this manually with the getter method but not with the constructor, it is simply not possible.

#include <any> #include <memory> #include <iostream>  class Time {     int m_a, m_b; public:     Time(int a, int b) : m_a(a), m_b(b) {}     int a() const { return m_a; }     int b() const { return m_b; }      friend std::ostream &operator<<(std::ostream &os, const Time &time) noexcept {         os << time.a() << ' ' << time.b();         return os;     } };  template<typename T> class Value {     struct Impl {         std::any value;     };     std::unique_ptr<Impl> m_p; public:     explicit Value(const T &value) : m_p(std::make_unique<Impl>()) {         m_p->value = std::make_any<T>(value);     }     T get() const {         return std::any_cast<T>(m_p->value);     } };  class LateValue {     struct Impl {         std::any value;     };     std::unique_ptr<Impl> m_p; public:     template<typename T>     LateValue(const T &value) : m_p(std::make_unique<Impl>()) {         m_p->value = std::make_any<T>(value);     }     template<typename T>     T get() const {         return std::any_cast<T>(m_p->value);     } }; 

Here is a simple test program. Note that the above code goes into the same file.

template<typename T> Value<T> get() {     return Value<T>(1.2f); }  LateValue get() {     return LateValue(1.2f); }  int main() {     Value<int>   v0(1);     Value<float> v1(1.234f);     Value<Time>  v2(Time(1, 2));      LateValue l0(1);     LateValue l1(1.234f);     LateValue l2(Time(1, 2));      std::cout << v0.get() << ' '               << v1.get() << ' '               << v2.get() << '\n'               << l0.get<int>() << ' '               << l1.get<float>() << ' '               << l2.get<Time>() << '\n';      auto value = get<float>();     std::cout << " value is " << value.get() << '\n';      // l2.get<double>(); <--- exception: bad_any_cast (ok to me)      return 0; } 

The output is simply as in code, because it is working (single file!):

1 1.234 1 2 1 1.234 1 2  value is 1.2 

So the question is: How to improve the implementation to have a nice interface with simplicity of template parameter? (I try to overcome the necessity to implement a get method for every supported type.)

To clearify: I want a single value container which holds any type which I can access later. I do not want to cast the contained type in any way (ok to me in comments). The Implementations Value and LateValue do literally the same but provide different interfaces. Value needs to know the contained type on definition (see first get function), LateValue needs the type on access. The latter interface is what I need but the provided implementation does not work when using from a library.