Aegisub/libaegisub/common/cajun/elements.cpp
Thomas Goyne 4c88449e4c Make UnknownElement moveable and not copyable
And remove the unused comparison functionality.
2014-06-29 10:45:26 -07:00

112 lines
3.1 KiB
C++

/**********************************************
License: BSD
Project Webpage: http://cajun-jsonapi.sourceforge.net/
Author: Terry Caton
***********************************************/
#include "libaegisub/cajun/elements.h"
#include "libaegisub/cajun/visitor.h"
#include <utility>
namespace {
using namespace json;
class CastVisitorBase : public Visitor {
void Visit(Array&) override { }
void Visit(Object&) override { }
void Visit(Integer&) override { }
void Visit(Double&) override { }
void Visit(String&) override { }
void Visit(Boolean&) override { }
void Visit(Null&) override { is_null = true; }
public:
bool is_null = false;
};
template<typename T>
struct CastVisitor final : public CastVisitorBase {
T *element = nullptr;
void Visit(T& ele) override { element = &ele; }
};
}
namespace json {
class UnknownElement::Imp {
public:
virtual ~Imp() {}
virtual void Accept(ConstVisitor& visitor) const = 0;
virtual void Accept(Visitor& visitor) = 0;
};
}
namespace {
template <typename ElementTypeT>
class Imp_T final : public UnknownElement::Imp {
ElementTypeT m_Element;
public:
Imp_T(ElementTypeT element) : m_Element(std::move(element)) { }
void Accept(ConstVisitor& visitor) const { visitor.Visit(m_Element); }
void Accept(Visitor& visitor) { visitor.Visit(m_Element); }
};
}
namespace json {
UnknownElement::UnknownElement() : m_pImp(new Imp_T<Null>(Null())) {}
UnknownElement::UnknownElement(UnknownElement&& unknown) : m_pImp(std::move(unknown.m_pImp)) {}
UnknownElement::UnknownElement(int number) : m_pImp(new Imp_T<Integer>(number)) {}
UnknownElement::UnknownElement(const char *string) : m_pImp(new Imp_T<String>(string)) {}
UnknownElement::~UnknownElement() { }
#define DEFINE_UE_TYPE(Type) \
UnknownElement::UnknownElement(Type val) : m_pImp(new Imp_T<Type>(std::move(val))) { } \
UnknownElement::operator Type const&() const { return CastTo<Type>(); } \
UnknownElement::operator Type&() { return CastTo<Type>(); }
DEFINE_UE_TYPE(Object)
DEFINE_UE_TYPE(Array)
DEFINE_UE_TYPE(Integer)
DEFINE_UE_TYPE(Double)
DEFINE_UE_TYPE(Boolean)
DEFINE_UE_TYPE(String)
DEFINE_UE_TYPE(Null)
UnknownElement& UnknownElement::operator=(UnknownElement&& unknown) {
m_pImp = std::move(unknown.m_pImp);
return *this;
}
template <typename ElementTypeT>
ElementTypeT const& UnknownElement::CastTo() const {
CastVisitor<ElementTypeT> castVisitor;
const_cast<UnknownElement *>(this)->Accept(castVisitor);
if (!castVisitor.element)
throw Exception("Bad cast");
return *castVisitor.element;
}
template <typename ElementTypeT>
ElementTypeT& UnknownElement::CastTo() {
CastVisitor<ElementTypeT> castVisitor;
Accept(castVisitor);
// If this element is uninitialized, implicitly convert it to the desired type
if (castVisitor.is_null) {
*this = ElementTypeT();
return *this;
}
// Otherwise throw an exception
if (!castVisitor.element)
throw Exception("Bad cast");
return *castVisitor.element;
}
void UnknownElement::Accept(ConstVisitor& visitor) const { m_pImp->Accept(visitor); }
void UnknownElement::Accept(Visitor& visitor) { m_pImp->Accept(visitor); }
}