How do I use a templated class within a new template? - c++

Question

Not sure why, but the code in xcode just started working. I am very happy.
Thank you all for your time.
//here is JUCE's code
//==============================================================================
/** This template-overloaded class can be used to convert between var and custom types.
#tags{Core}
*/
template <class Type> struct VariantConverter
{
static Type fromVar (const var& v) { return static_cast<Type> (v); }
static var toVar (const Type& t) { return t; }
};
//here is my addition
template <> struct VariantConverter<Point<int>>
{
static Point<int> fromVar (const var& v)
{
return Point<int>
(
{ v[0].operator int(), v[1].operator int() }
);
}
static var toVar (const Point<int>& p)
{
return Array<var>({ p.getX(), p.getY() });
}
};
Hi, I am not sure how I can achieve the above code. A class like typedef to replace the
Point<int>
would be great. I am appending a JUCE file.
Xcode gives me two errors
/Tools/JUCE/modules/juce_core/containers/juce_Variant.h:41:18: Expected unqualified-id
and
/Tools/JUCE/modules/juce_core/containers/juce_Variant.h:343:46: Expected '>'
Thank you

Answer 1

As there are only static methods you don't need an Object of that type. You should be able to call it like:
typedef Point<int> MyPoint;
MyPoint point(1,2); // call constructor of a Point<int>
var x = VariantConverter::toVar(point); //call static methods of struct
MyPoint point2 = VariantConverter::fromVar(x);

Answer 2

template <>
struct VariantConverter<Point<int>>
{ /* ... */ };
What you have here is a template specialisation. If you want to specialise, you first need a base template before you can compile.
template <typename>
struct VariantConverter;
Sometimes it is useful if only the specialisations exist, then you would just declare the base as above, fare mor common, though, is having a default implementation:
template <typename T>
struct VariantConverter
{
static T fromVar(var const& v);
};
Solely, what shall var be in above example? T as well? Another template parameter of VariantConverter struct? Third option is the one I show: function template parameter:
template <typename T>
struct VariantConverter
{
template <typename var>
static T fromVar(var const& v);
};
You now can provide a default implementation suitable for the majority of types – if there is a reasonable one (otherwise, it might be more appropriate not to implement the default and just have the specialisations).
OK, now we can specialise:
template <>
struct VariantConverter<Point<int>>
// Point<int> now is what previously was T; could be any arbitrary type, not
// necessarily Point<int>, but std::string, double, ...
{
// still, you need to tell what var actually is
// maybe you have defined a class for already? similar to std::vector?
// assuming so this time...
static Point<int> fromVar (var const& v)
{
return Point<int>
(
// are you sure point accepts an initializer list?
// or do you intend to create first a point and then
// use move/copy constructor???
//{ v[0].operator int(), v[1].operator int() }
// rather normal constructor directly:
//v[0].operator int(), v[1].operator int()
// however, explicitly calling cast operators is ugly, rather just cast:
static_cast<int>(v[0]), static_cast<int>(<v[1])
// or C style casts, if you prefer
//(int)v[0], (int)v[1]
// I personally would rather go with the former, though, for being
// more "C++-ish"
);
}
};
Now maybe you are looking for something totally different:
template <typename T>
struct VariantConverter
{
static Point<T> fromVar(std::vector<T> const& v)
{
return Point<T>(v[0], v[1]);
}
};
Finally, as you explicitly asked for:
template <>
struct VariantConverter<Point<int>>
{
using Type = Point<int>;
static Type fromVar(/* ... */);
};
or, for second variant:
template <typename T>
struct VariantConverter
{
using Type = Point<T>;
static Type fromVar( /* ... */);
};

Answer 3

Sorry for my poor communication. English is my first language and despite being educated, I am not gifted at written communication. Here is the bigger context. I am trying to add to an existing class.
//This is the end of their code
//==============================================================================
/** This template-overloaded class can be used to convert between var and custom types.
#tags{Core}
*/
template <class Type> struct VariantConverter
{
static Type fromVar (const var& v) { return static_cast<Type> (v); }
static var toVar (const Type& t) { return t; }
};
//here is my code
template <> struct VariantConverter<Point<int>>
{
static Point<int> fromVar (const var& v)
{
return Point<int>
(
{ v[0].operator int(), v[1].operator int() }
);
}
static var toVar (const Point<int>& p)
{
return Array<var>({ p.getX(), p.getY() });
}
};