From f3ba8819a495fa2fdc4cf87087928723d75fca22 Mon Sep 17 00:00:00 2001
From: Jack Andersen <jackoalan@gmail.com>
Date: Tue, 14 Jul 2015 12:57:42 -1000
Subject: [PATCH] fixed incomplete-type warnings involving recursively-derived
 DNA types

---
 PKGBUILD               |   2 +-
 include/Athena/DNA.hpp | 141 ++++++++++++++++++++++++-----------------
 2 files changed, 85 insertions(+), 58 deletions(-)

diff --git a/PKGBUILD b/PKGBUILD
index af1f657..e82fc07 100644
--- a/PKGBUILD
+++ b/PKGBUILD
@@ -1,7 +1,7 @@
 # PKGBUILD for libAthena
 _pkgname=libathena
 pkgname=$_pkgname-git
-pkgver=2.0.0.7.g87306a1
+pkgver=2.0.0.8.g24fedff
 pkgrel=1
 pkgdesc="Basic cross platform IO library"
 arch=('i686' 'x86_64')
diff --git a/include/Athena/DNA.hpp b/include/Athena/DNA.hpp
index 21ca776..7910c78 100644
--- a/include/Athena/DNA.hpp
+++ b/include/Athena/DNA.hpp
@@ -18,6 +18,20 @@ namespace Athena
 namespace io
 {
 
+/* forward-declaration dance for recursively-derived types */
+
+template <size_t sizeVar, Endian VE>
+struct Buffer;
+
+template <atInt32 sizeVar, Endian VE>
+struct String;
+
+template <atInt32 sizeVar, Endian VE>
+struct WString;
+
+template <atInt32 sizeVar, Endian VE>
+struct UTF8;
+
 /**
  * @brief Base DNA class used against 'atdna'
  *
@@ -38,70 +52,17 @@ struct DNA
     template <typename T, size_t cntVar, Endian VE = DNAE>
     using Vector = std::vector<T>;
 
-    struct Delete {};
-
     template <size_t sizeVar>
-    struct Buffer : public DNA, public std::unique_ptr<atUint8[]>
-    {
-        Delete expl;
-        inline void read(IStreamReader& reader)
-        {
-            reset(new atUint8[sizeVar]);
-            reader.readUBytesToBuf(get(), sizeVar);
-        }
-        inline void write(IStreamWriter& writer) const
-        {
-            writer.writeUBytes(get(), sizeVar);
-        }
-    };
+    using Buffer = struct Buffer<sizeVar, DNAE>;
 
     template <atInt32 sizeVar = -1>
-    struct String : public DNA, public std::string
-    {
-        Delete expl;
-        inline void read(IStreamReader& reader)
-        {*this = reader.readString(sizeVar);}
-        inline void write(IStreamWriter& writer) const
-        {writer.writeString(*this, sizeVar);}
-        inline std::string& operator=(const std::string& __str)
-        {return this->assign(__str);}
-        inline std::string& operator=(std::string&& __str)
-        {this->swap(__str); return *this;}
-    };
+    using String = struct String<sizeVar, DNAE>;
 
     template <atInt32 sizeVar = -1, Endian VE = DNAE>
-    struct WString : public DNA, public std::wstring
-    {
-        Delete expl;
-        inline void read(IStreamReader& reader)
-        {
-            reader.setEndian(VE);
-            *this = reader.readWString(sizeVar);
-        }
-        inline void write(IStreamWriter& writer) const
-        {
-            writer.setEndian(VE);
-            writer.writeWString(*this, sizeVar);
-        }
-        inline std::wstring& operator=(const std::wstring& __str)
-        {return this->assign(__str);}
-        inline std::wstring& operator=(std::wstring&& __str)
-        {this->swap(__str); return *this;}
-    };
+    using WString = struct WString<sizeVar, VE>;
 
     template <atInt32 sizeVar = -1>
-    struct UTF8 : public DNA, public std::string
-    {
-        Delete expl;
-        inline void read(IStreamReader& reader)
-        {*this = reader.readUnicode(sizeVar);}
-        inline void write(IStreamWriter& writer) const
-        {writer.writeUnicode(*this, sizeVar);}
-        inline std::string& operator=(const std::string& __str)
-        {return this->assign(__str);}
-        inline std::string& operator=(std::string&& __str)
-        {this->swap(__str); return *this;}
-    };
+    using UTF8 = struct UTF8<sizeVar, DNAE>;
 
     template <off_t offset, SeekOrigin direction>
     struct Seek {};
@@ -109,6 +70,72 @@ struct DNA
     template <size_t align>
     struct Align {};
 
+    struct Delete {};
+};
+
+/* Concrete DNA types */
+
+template <size_t sizeVar, Endian VE>
+struct Buffer : public DNA<VE>, public std::unique_ptr<atUint8[]>
+{
+    typename DNA<VE>::Delete expl;
+    inline void read(IStreamReader& reader)
+    {
+        reset(new atUint8[sizeVar]);
+        reader.readUBytesToBuf(get(), sizeVar);
+    }
+    inline void write(IStreamWriter& writer) const
+    {
+        writer.writeUBytes(get(), sizeVar);
+    }
+};
+
+template <atInt32 sizeVar, Endian VE>
+struct String : public DNA<VE>, public std::string
+{
+    typename DNA<VE>::Delete expl;
+    inline void read(IStreamReader& reader)
+    {*this = reader.readString(sizeVar);}
+    inline void write(IStreamWriter& writer) const
+    {writer.writeString(*this, sizeVar);}
+    inline std::string& operator=(const std::string& __str)
+    {return this->assign(__str);}
+    inline std::string& operator=(std::string&& __str)
+    {this->swap(__str); return *this;}
+};
+
+template <atInt32 sizeVar, Endian VE>
+struct WString : public DNA<VE>, public std::wstring
+{
+    typename DNA<VE>::Delete expl;
+    inline void read(IStreamReader& reader)
+    {
+        reader.setEndian(VE);
+        *this = reader.readWString(sizeVar);
+    }
+    inline void write(IStreamWriter& writer) const
+    {
+        writer.setEndian(VE);
+        writer.writeWString(*this, sizeVar);
+    }
+    inline std::wstring& operator=(const std::wstring& __str)
+    {return this->assign(__str);}
+    inline std::wstring& operator=(std::wstring&& __str)
+    {this->swap(__str); return *this;}
+};
+
+template <atInt32 sizeVar, Endian VE>
+struct UTF8 : public DNA<VE>, public std::string
+{
+    typename DNA<VE>::Delete expl;
+    inline void read(IStreamReader& reader)
+    {*this = reader.readUnicode(sizeVar);}
+    inline void write(IStreamWriter& writer) const
+    {writer.writeUnicode(*this, sizeVar);}
+    inline std::string& operator=(const std::string& __str)
+    {return this->assign(__str);}
+    inline std::string& operator=(std::string&& __str)
+    {this->swap(__str); return *this;}
 };
 
 /** Macro to automatically declare read/write methods in subclasses */