Ytdyklly

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.)

So it looks like you want a type where you can add an object of any type. But you want the ability to pull that object out as any other type (with potentially a testing function that allows you to test the type).

class LokiValue

{

    std::any value;



    public:

        template<typename T>

        void put(T const& input) {

            // Put stuff in value of type T

            value = input;

        }



        template<typename S, typename T = S>

        T get() {

            // Get stuff in value that is of type S

            // but return a value of type T

            // by default S and T are the same type.

            if (!value.has_value()) {

               throw MyException("Message 1");

            }

            // This will throw if:

            //    * S is not the type stored.

            //    * If S is not convertible to T

            return boost::lexical_cast<T>(std::any_cast<S>(value));

        }



        template<typename S, typename T>

        bool check() {

            // Check stuff in value is of type S and can be converted

            // into an object of type T

            if (!value.has_value()) {

               return false;

            }

            try {

                boost::lexical_cast<T>(std::any_cast<S>(value));

            }

            catch(...) {

                return false;

            }

            return true;

        }

};

Now this does not solve your problem directly as:

l2.get<double, Time>(); // This will still throw as Time is not convertable

                        // to a double yet. But we can simply change the

                        // the output format of time so it is compatable with

                        // the double stream input.

So what do we have to change to make them compatible?

class Time {

    // STUFF

    friend std::ostream &operator<<(std::ostream &os, const Time &time) noexcept {

        return os << time.m_a << '.' << time.m_b;

         //                      ^^^  Just change this to a dot

         //                           The output of Time is compatible with

         //                           the input of double,

    }

};

So now we have:

int main() {

    LokiValue l2;

    l2.put(Time(1, 2));       // I was lazy and did not add a constructor.

                              // I'll leave that to you.



    l2.get<double, Time>();

}