Fix header ranking

4 files changed, 176 insertions, 2 deletions

diff --git a/src/compat/fwd.hpp b/src/compat/fwd.hpp
index c16e196..3fa0dd2 100644
--- a/src/compat/fwd.hpp
+++ b/src/compat/fwd.hpp
@@ -20,6 +20,10 @@
 
 #include "../sanity.hpp"
 
+#include "../ints/fwd.hpp" // rank 1
+#include "../strings/fwd.hpp" // rank 1
+// compat/fwd.hpp is rank 2
+
 
 namespace tmwa
 {
@@ -33,5 +37,6 @@ namespace tmwa
     template<class T>
     class Borrowed;
 
+    struct TimeT;
 // meh, add more when I feel like it
 } // namespace tmwa
diff --git a/src/compat/operators.hpp b/src/compat/operators.hpp
new file mode 100644
index 0000000..bb05765
--- /dev/null
+++ b/src/compat/operators.hpp
@@ -0,0 +1,68 @@
+#pragma once
+//    operators.hpp - ADL helper for value wrappers.
+//
+//    Copyright © 2013 Ben Longbons <b.r.longbons@gmail.com>
+//
+//    This file is part of The Mana World (Athena server)
+//
+//    This program is free software: you can redistribute it and/or modify
+//    it under the terms of the GNU General Public License as published by
+//    the Free Software Foundation, either version 3 of the License, or
+//    (at your option) any later version.
+//
+//    This program is distributed in the hope that it will be useful,
+//    but WITHOUT ANY WARRANTY; without even the implied warranty of
+//    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+//    GNU General Public License for more details.
+//
+//    You should have received a copy of the GNU General Public License
+//    along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+#include "fwd.hpp"
+
+
+namespace tmwa
+{
+namespace _operators
+{
+    class Comparable {};
+
+    template<class T>
+    bool operator == (T l, T r)
+    {
+        return l.value == r.value;
+    }
+
+    template<class T>
+    bool operator != (T l, T r)
+    {
+        return l.value != r.value;
+    }
+
+    template<class T>
+    bool operator < (T l, T r)
+    {
+        return l.value < r.value;
+    }
+
+    template<class T>
+    bool operator <= (T l, T r)
+    {
+        return l.value <= r.value;
+    }
+
+    template<class T>
+    bool operator > (T l, T r)
+    {
+        return l.value > r.value;
+    }
+
+    template<class T>
+    bool operator >= (T l, T r)
+    {
+        return l.value >= r.value;
+    }
+}
+
+using _operators::Comparable;
+} // namespace tmwa
diff --git a/src/compat/rawmem.hpp b/src/compat/rawmem.hpp
index c271a56..66af204 100644
--- a/src/compat/rawmem.hpp
+++ b/src/compat/rawmem.hpp
@@ -22,6 +22,8 @@
 #include <cstdint>
 #include <cstring>
 
+#include <type_traits>
+
 #include "fwd.hpp"
 
 
@@ -49,4 +51,23 @@ void really_memset0(uint8_t *dest, size_t n)
 {
     memset(dest, '\0', n);
 }
+
+template<class T>
+struct is_trivially_copyable
+: std::integral_constant<bool,
+    // come back when GCC actually implements the public traits properly
+    __has_trivial_copy(T)
+    && __has_trivial_assign(T)
+    && __has_trivial_destructor(T)>
+{};
+
+template<class T>
+void really_memzero_this(T *v)
+{
+    static_assert(is_trivially_copyable<T>::value, "only for mostly-pod types");
+    static_assert(std::is_class<T>::value || std::is_union<T>::value, "Only for user-defined structures (for now)");
+    memset(v, '\0', sizeof(*v));
+}
+template<class T, size_t n>
+void really_memzero_this(T (&)[n]) = delete;
 } // namespace tmwa
diff --git a/src/compat/time_t.hpp b/src/compat/time_t.hpp
index 9e7cf25..e9c97c4 100644
--- a/src/compat/time_t.hpp
+++ b/src/compat/time_t.hpp
@@ -20,10 +20,90 @@
 
 #include "fwd.hpp"
 
-// TODO fix this ordering violation by promoting TimeT here
-#include "../mmo/utils.hpp"
+#include <ctime>
+
+#include "../ints/little.hpp"
+
+#include "operators.hpp"
 
 
 namespace tmwa
 {
+// Exists in place of time_t, to give it a predictable printf-format.
+// (on x86 and amd64, time_t == long, but not on x32)
+static_assert(sizeof(long long) >= sizeof(time_t), "long long >= time_t");
+struct TimeT : Comparable
+{
+    long long value;
+
+    // conversion
+    TimeT(time_t t=0) : value(t) {}
+    TimeT(struct tm t) : value(timegm(&t)) {}
+    operator time_t() const { return value; }
+    operator struct tm() const { time_t v = value; return *gmtime(&v); }
+
+    explicit operator bool() const { return value; }
+    bool operator !() const { return !value; }
+
+    // prevent surprises
+    template<class T>
+    TimeT(T) = delete;
+    template<class T>
+    operator T() const = delete;
+
+    static
+    TimeT now()
+    {
+        // poisoned, but this is still in header-land
+        return time(nullptr);
+    }
+
+    bool error() const
+    {
+        return value == -1;
+    }
+    bool okay() const
+    {
+        return !error();
+    }
+};
+
+inline
+long long convert_for_printf(TimeT t)
+{
+    return t.value;
+}
+
+// 2038 problem
+inline __attribute__((warn_unused_result))
+bool native_to_network(Little32 *net, TimeT nat)
+{
+    time_t tmp = nat;
+    return native_to_network(net, static_cast<uint32_t>(tmp));
+}
+
+inline __attribute__((warn_unused_result))
+bool network_to_native(TimeT *nat, Little32 net)
+{
+    uint32_t tmp;
+    bool rv = network_to_native(&tmp, net);
+    *nat = static_cast<time_t>(tmp);
+    return rv;
+}
+
+inline __attribute__((warn_unused_result))
+bool native_to_network(Little64 *net, TimeT nat)
+{
+    time_t tmp = nat;
+    return native_to_network(net, static_cast<uint64_t>(tmp));
+}
+
+inline __attribute__((warn_unused_result))
+bool network_to_native(TimeT *nat, Little64 net)
+{
+    uint64_t tmp;
+    bool rv = network_to_native(&tmp, net);
+    *nat = static_cast<time_t>(tmp);
+    return rv;
+}
 } // namespace tmwa