Tag class clean-up

Tag.h

@@ -1,3 +1,6 @@
+#ifndef TAG_H__
+#define TAG_H__
+
 /*
 * Copyright (c) 2013-2016, The PurpleI2P Project
 *
@@ -6,92 +9,80 @@
 * See full license text in LICENSE file at top of project tree
 */
 
-#ifndef TAG_H__
+#include <boost/static_assert.hpp>
-#define TAG_H__
+#include <string.h>
-
-#include <string.h> /* memcpy */
-
 #include "Base.h"
 
 namespace i2p {
 namespace data {
-	template<int sz>
-	class Tag
-	{
-		public:
-
-    Tag (const uint8_t * buf) { memcpy (m_Buf, buf, sz); };
-			Tag (const Tag<sz>& ) = default;
-#ifndef _WIN32 // FIXME!!! msvs 2013 can't compile it
-			Tag (Tag<sz>&& ) = default;
-#endif
-			Tag () = default;
 
-			Tag<sz>& operator= (const Tag<sz>& ) = default;
+template<size_t sz>
-#ifndef _WIN32
+class Tag
-			Tag<sz>& operator= (Tag<sz>&& ) = default;
+{
-#endif
+	BOOST_STATIC_ASSERT_MSG(sz % 8 == 0, "Tag size must be multiple of 8 bytes");
 
-			uint8_t * operator()() { return m_Buf; };
+public:
-			const uint8_t * operator()() const { return m_Buf; };
 
-			operator uint8_t * () { return m_Buf; };
+	Tag () = default;
-			operator const uint8_t * () const { return m_Buf; };
+	Tag (const uint8_t * buf) { memcpy (m_Buf, buf, sz); }
 
-			const uint64_t * GetLL () const { return ll; };
+	bool operator== (const Tag& other) const { return !memcmp (m_Buf, other.m_Buf, sz); }
+	bool operator< (const Tag& other) const { return memcmp (m_Buf, other.m_Buf, sz) < 0; }
 
-			bool operator== (const Tag<sz>& other) const { return !memcmp (m_Buf, other.m_Buf, sz); };
+	uint8_t * operator()() { return m_Buf; }
-			bool operator< (const Tag<sz>& other) const { return memcmp (m_Buf, other.m_Buf, sz) < 0; };
+	const uint8_t * operator()() const { return m_Buf; }
 
-			bool IsZero () const
+	operator uint8_t * () { return m_Buf; }
-			{
+	operator const uint8_t * () const { return m_Buf; }
-				for (int i = 0; i < sz/8; i++)
-					if (ll[i]) return false;
-				return true;
-			}
 
-      const uint8_t * data() const { return m_Buf; }
+	const uint8_t * data() const { return m_Buf; }
+	const uint64_t * GetLL () const { return ll; }
 
-      /** fill with a value */
+	bool IsZero () const
-			void Fill(uint8_t c)
+	{
-			{
+		for (size_t i = 0; i < sz/8; ++i)
-				memset(m_Buf, c, sz);
+			if (ll[i]) return false;
-			}
+		return true;
+	}
+
+    void Fill(uint8_t c)
+    {
+        memset(m_Buf, c, sz);
+    }
 			
-			std::string ToBase64 () const
+	std::string ToBase64 () const
-			{
+	{
-				char str[sz*2];
+		char str[sz*2];
-				int l = i2p::data::ByteStreamToBase64 (m_Buf, sz, str, sz*2);
+		size_t l = i2p::data::ByteStreamToBase64 (m_Buf, sz, str, sz*2);
-				str[l] = 0;
+		return std::string (str, str + l);
-				return std::string (str);
+	}
-			}
+
-
+	std::string ToBase32 () const
-			std::string ToBase32 () const
+	{
-			{
+		char str[sz*2];
-				char str[sz*2];
+		size_t l = i2p::data::ByteStreamToBase32 (m_Buf, sz, str, sz*2);
-				int l = i2p::data::ByteStreamToBase32 (m_Buf, sz, str, sz*2);
+		return std::string (str, str + l);
-				str[l] = 0;
+	}
-				return std::string (str);
+
-			}
+	void FromBase32 (const std::string& s)
-
+	{
-			void FromBase32 (const std::string& s)
+		i2p::data::Base32ToByteStream (s.c_str (), s.length (), m_Buf, sz);
-			{
+	}
-				i2p::data::Base32ToByteStream (s.c_str (), s.length (), m_Buf, sz);
+
-			}
+	void FromBase64 (const std::string& s)
-
+	{
-			void FromBase64 (const std::string& s)
+		i2p::data::Base64ToByteStream (s.c_str (), s.length (), m_Buf, sz);
-			{
+	}
-				i2p::data::Base64ToByteStream (s.c_str (), s.length (), m_Buf, sz);
+
-			}
+private:
-
+
-		private:
+	union // 8 bytes aligned
-
+	{
-			union // 8 bytes alignment
+		uint8_t m_Buf[sz];
-			{
+		uint64_t ll[sz/8];
-				uint8_t m_Buf[sz];
-				uint64_t ll[sz/8];
-			};
 	};
+};
+
 } // data
 } // i2p