Vutils

include/Vutils.h

@@ -2751,60 +2751,63 @@ class PEFileTW : public PEFileTX<T>
  * Variant
  */
 
-class VariantA
+template <class T>
+class VariantT
 {
 public:
-  VariantA();
-  VariantA(VariantA& right);
-  virtual ~VariantA();
+  VariantT();
+  VariantT(VariantT& right);
+  virtual ~VariantT();
+
+  VariantT& operator=(VariantT& right);
+
+  T& data()
+  {
+    return *m_data;
+  }
 
   template<typename T>
-  friend VariantA& operator<<(VariantA& stream, T v)
+  friend VariantT& operator<<(VariantT& stream, T v)
   {
-    *stream.m_data << v;
+    stream.data() << v;
     return stream;
   }
 
-  VariantA& operator=(VariantA& right);
+  int to_int() const;
+  unsigned int to_uint() const;
+  __int64 to_int64() const;
+  unsigned __int64 to_uint64() const;
+  bool to_bool() const;
+  float to_float() const;
+  double to_double() const;
+  std::unique_ptr<byte[]> to_bytes() const;
 
-  std::stringstream& vuapi data();
-  std::string vuapi to_string() const;
-  int vuapi to_integer() const;
-  long vuapi to_long() const;
-  bool vuapi to_boolean() const;
-  float vuapi to_float() const;
-  double vuapi to_double() const;
+protected:
+  std::unique_ptr<T> m_data;
+};
 
-private:
-  std::unique_ptr<std::stringstream> m_data;
+#define VariantTA VariantT<std::stringstream>
+
+class VariantA : public VariantTA
+{
+public:
+  VariantA();
+  VariantA(VariantA& right);
+  virtual ~VariantA();
+
+  std::string to_string() const;
 };
 
-class VariantW
+#define VariantTW VariantT<std::wstringstream>
+
+class VariantW : public VariantTW
 {
 public:
   VariantW();
   VariantW(VariantW& right);
   virtual ~VariantW();
 
-  VariantW& operator=(VariantW& right);
-
-  template<typename T>
-  friend VariantW& operator<<(VariantW& stream, T v)
-  {
-    *stream.m_data << v;
-    return stream;
-  }
-
-  std::wstringstream& vuapi data();
-  std::wstring vuapi to_string() const;
-  int vuapi to_integer() const;
-  long vuapi to_long() const;
-  bool vuapi to_boolean() const;
-  float vuapi to_float() const;
-  double vuapi to_double() const;
-
-private:
-  std::unique_ptr<std::wstringstream> m_data;
+  std::wstring to_string() const;
 };
 
 /**

src/details/strfmt.cpp

@@ -654,133 +654,165 @@ void vuapi url_decode_W(const std::wstring& text, std::wstring& result)
 }
 
 /**
- * VariantA
+ * VariantX
  */
 
-VariantA::VariantA()
+template <class T>
+VariantT<T>::VariantT()
 {
-  m_data.reset(new std::stringstream);
+  m_data.reset(new T);
 }
 
-VariantA::VariantA(VariantA& right)
+template <class T>
+VariantT<T>::VariantT(VariantT& right)
 {
   *this = right;
 }
 
-VariantA::~VariantA()
+template <class T>
+VariantT<T>::~VariantT()
 {
 }
 
-VariantA& VariantA::operator=(VariantA& right)
+template <class T>
+VariantT<T>& VariantT<T>::operator=(VariantT<T>& right)
 {
   if (this != &right)
   {
-    auto ptr = new std::stringstream();
+    auto ptr = new T();
     *ptr << right.m_data->str();
     this->m_data.reset(ptr);
   }
 
   return *this;
 }
 
-std::stringstream& VariantA::data()
+template <class T>
+int VariantT<T>::to_int() const
 {
-  return *m_data;
+  int result = 0;
+  *m_data >> result;
+  return result;
 }
 
-std::string VariantA::to_string() const
+template <class T>
+unsigned int VariantT<T>::to_uint() const
 {
-  return m_data->str();
+  unsigned int result = 0;
+  *m_data >> result;
+  return result;
 }
 
-bool VariantA::to_boolean() const
+template <class T>
+__int64 VariantT<T>::to_int64() const
 {
-  return to_integer() != 0;
+  long long int result = 0;
+  *m_data >> result;
+  return result;
 }
 
-int VariantA::to_integer() const
+template <class T>
+unsigned __int64 VariantT<T>::to_uint64() const
 {
-  return atoi(m_data->str().c_str());
+  unsigned __int64 result = 0;
+  *m_data >> result;
+  return result;
 }
 
-long VariantA::to_long() const
+template <class T>
+bool VariantT<T>::to_bool() const
 {
-  return atol(m_data->str().c_str());
+  return to_int() != 0;
 }
 
-float VariantA::to_float() const
+template <class T>
+float VariantT<T>::to_float() const
 {
-  return float(to_double());
+  float result = 0.F;
+  *m_data >> result;
+  return result;
 }
 
-double VariantA::to_double() const
+template <class T>
+double VariantT<T>::to_double() const
 {
-  return atof(m_data->str().c_str());
+  double result = 0.;
+  *m_data >> result;
+  return result;
 }
 
-/**
- * VariantW
- */
-
-VariantW::VariantW()
+template <class T>
+std::unique_ptr<byte[]> VariantT<T>::to_bytes() const
 {
-  m_data.reset(new std::wstringstream);
-}
+  std::vector<byte> bytes;
 
-VariantW::VariantW(VariantW& right)
-{
-  *this = right;
+  if (typeid(typename T) == typeid(std::stringstream))
+  {
+    to_hex_bytes_A((const char*)m_data->str().c_str(), bytes);
+  }
+  else if (typeid(typename T) == typeid(std::wstringstream))
+  {
+    to_hex_bytes_W((const wchar_t*)m_data->str().c_str(), bytes);
+  }
+  else
+  {
+    assert(0 && "invalid template class");
+  }
+
+  if (bytes.empty())
+  {
+    return nullptr;
+  }
+
+  std::unique_ptr<byte[]> result(new byte[bytes.size()]);
+  std::move(bytes.cbegin(), bytes.cend(), result.get());
+  return result;
 }
 
-VariantW::~VariantW()
+/**
+ * VariantA
+ */
+
+template VariantTA;
+
+VariantA::VariantA() : VariantT()
 {
 }
 
-VariantW& VariantW::operator=(VariantW& right)
+VariantA::VariantA(VariantA& right) : VariantT(right)
 {
-  if (this != &right)
-  {
-    auto ptr = new std::wstringstream();
-    *ptr << right.m_data->str();
-    this->m_data.reset(ptr);
-  }
-
-  return *this;
 }
 
-std::wstringstream& VariantW::data()
+VariantA::~VariantA()
 {
-  return *m_data;
 }
 
-std::wstring VariantW::to_string() const
+std::string VariantA::to_string() const
 {
   return m_data->str();
 }
 
-bool VariantW::to_boolean() const
-{
-  return to_integer() != 0;
-}
+/**
+ * VariantW
+ */
+
+template class VariantTW;
 
-int VariantW::to_integer() const
+VariantW::VariantW() : VariantT()
 {
-  return atoi(to_string_A(m_data->str()).c_str());
 }
 
-long VariantW::to_long() const
+VariantW::VariantW(VariantW& right) : VariantT(right)
 {
-  return atol(to_string_A(m_data->str()).c_str());
 }
 
-float VariantW::to_float() const
+VariantW::~VariantW()
 {
-  return float(to_double());
 }
 
-double VariantW::to_double() const
+std::wstring VariantW::to_string() const
 {
-  return atof(to_string_A(m_data->str()).c_str());
+  return m_data->str();
 }
 
 #ifdef _MSC_VER