transactd 2.4.5 → 3.0.0

data/source/bzs/db/protocol/tdap/myDateTime.cpp

@@ -16,11 +16,14 @@
    Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
    02111-1307, USA.
 =================================================================*/
-#include <bzs/env/tstring.h>
+#include "myDateTime.h"
+#include <bzs/db/protocol/tdap/btrDate.h>
+#include <string.h>
 #include <stdlib.h>
 #include <stdio.h>
 #include <time.h>
-#include <bzs/db/protocol/tdap/btrDate.h>
+#include <algorithm>
+#include <bzs/env/crosscompile.h>
 
 namespace bzs
 {
@@ -30,166 +33,118 @@ namespace protocol
 {
 namespace tdap
 {
-
-#pragma pack(push, 1)
-pragma_pack1;
-
+#pragma warning(disable : 4996)
 #ifdef _WIN32
-
-const wchar_t wtime_format_ms[] = L"%02d:%02d:%02d.%u";
+const wchar_t wtime_format_ms[] = L"%02d:%02d:%02d.%0*u";
 const wchar_t wtime_format[] = L"%02d:%02d:%02d";
-const wchar_t wdatetime_format_ms[] = L"%04d-%02d-%02d %02d:%02d:%02d.%u";
+const wchar_t wdatetime_format_ms[] = L"%04d-%02d-%02d %02d:%02d:%02d.%0*u";
 const wchar_t wdatetime_format[] = L"%04d-%02d-%02d %02d:%02d:%02d";
-const wchar_t wdatetime_format_ms_i[] = L"%04d-%02d-%02d %02d:%02d:%02d.%u";
-const wchar_t wdatetime_format_i[] = L"%04d-%02d-%02d %02d:%02d:%02d";
-
-inline size_t _ttol_(const wchar_t* v)
-{
-    return _wtol(v);
-}
-inline size_t _tcslen_(const wchar_t* v)
-{
-    return wcslen(v);
-}
-inline wchar_t* _tcsncpy_(wchar_t* d, const wchar_t* s, size_t n)
-{
-    return wcsncpy(d, s, n);
-}
-
 #endif
-
-const char time_format_ms[] = "%02d:%02d:%02d.%u";
+const char time_format_ms[] = "%02d:%02d:%02d.%0*u";
 const char time_format[] = "%02d:%02d:%02d";
-const char datetime_format_ms[] = "%04d-%02d-%02d %02d:%02d:%02d.%u";
-const char datetime_format[] = "%04d-%02d-%02d %02d:%02d:%02d";
-const char datetime_format_ms_i[] = "%04d-%02d-%02d %02d:%02d:%02d.%u";
-const char datetime_format_i[] = "%04d-%02d-%02d %02d:%02d:%02d";
+const char datetime_format_ms[] =   "%04d-%02d-%02d %02d:%02d:%02d.%0*u";
+const char datetime_format[] =      "%04d-%02d-%02d %02d:%02d:%02d";
 
-inline size_t _ttol_(const char* v)
+//-------------------------------------------------------------
+void myDate::setValue(int v, bool btrDate_i)
 {
-    return atol(v);
+    if (btrDate_i)
+    {
+        btrDate btrd;
+        btrd.i = v;
+        yy = btrd.yy;
+        mm = btrd.mm;
+        dd = btrd.dd;
+        tmp = 0;
+    }
+    else
+        i = v;
 }
-inline size_t _tcslen_(const char* v)
+
+int myDate::getValue(bool btrDate_i)
 {
-    return strlen(v);
+    if (btrDate_i)
+    {
+        btrDate btrd;
+        btrd.yy = yy;
+        btrd.mm = mm;
+        btrd.dd = dd;
+        return btrd.i;
+    }
+    return i;
 }
-inline char* _tcsncpy_(char* d, const char* s, size_t n)
+
+char* myDate::toString(char* p, size_t size, bool w3_format)
 {
-    return strncpy(d, s, n);
+    if (w3_format)
+        sprintf_s(p, size, "%04d/%02d/%02d", yy, mm, dd);
+    else
+        sprintf_s(p, size, "%04d-%02d-%02d", yy, mm, dd);
+    return p;
 }
 
-#pragma warning(disable : 4996)
-union myDate
+myDate& myDate::operator=(const char* p)
 {
-    struct
-    {
-        unsigned int dd : 5;
-        unsigned int mm : 4;
-        unsigned int yy : 15;
-        unsigned int tmp : 8;
-    };
-
-    int i;
-
-    inline void setValue(int v, bool btrvValue = false)
+    size_t len = strlen(p);
+    i = 0;
+    if (len > 3)
     {
-        if (btrvValue)
+        yy = atol(p);
+        if (len > 6)
         {
-            btrDate btrd;
-            btrd.i = v;
-            yy = btrd.yy;
-            mm = btrd.mm;
-            dd = btrd.dd;
-            tmp = 0;
+            mm = atol(p + 5);
+            if (len > 9)
+                dd = atol(p + 8);
         }
-        else
-            i = v;
     }
+    return *this;
+}
+
+#ifdef _WIN32
+wchar_t* myDate::toString(wchar_t* p, size_t size, bool w3_format)
+{
+    if (w3_format)
+        swprintf_s(p, size, L"%04d/%02d/%02d", yy, mm, dd);
+    else
+        swprintf_s(p, size, L"%04d-%02d-%02d", yy, mm, dd);
+    return p;
+}
 
-    inline int getValue(bool btrvValue = false)
+myDate& myDate::operator=(const wchar_t* p)
+{
+    size_t len = wcslen(p);
+    i = 0;
+    if (len > 3)
     {
-        if (btrvValue)
+        yy = _wtol(p);
+        if (len > 6)
         {
-            btrDate btrd;
-            btrd.yy = yy;
-            btrd.mm = mm;
-            btrd.dd = dd;
-            return btrd.i;
+            mm = _wtol(p + 5);
+            if (len > 9)
+                dd = _wtol(p + 8);
         }
-        return i;
-    }
-
-    inline char* toStr(char* p, bool btrvValue)
-    {
-        if (btrvValue)
-            sprintf(p, "%04d/%02d/%02d", yy, mm, dd);
-        else
-            sprintf(p, "%04d-%02d-%02d", yy, mm, dd);
-        return p;
-    }
-
-#ifdef _WIN32
-    inline wchar_t* toStr(wchar_t* p, bool btrvValue)
-    {
-        if (btrvValue)
-            swprintf_s(p, 11, L"%04d/%02d/%02d", yy, mm, dd);
-        else
-            swprintf_s(p, 11, L"%04d-%02d-%02d", yy, mm, dd);
-        return p;
     }
+    return *this;
+}
 #endif
 
-    template <class T> inline myDate& operator=(const T* p)
-    {
-        tmp = 0;
-        yy = _ttol_(p);
-        mm = _ttol_(p + 5);
-        dd = _ttol_(p + 8);
-        return *this;
-    }
-};
 
-struct myTime
+//-------------------------------------------------------------
+void myTime::setValue(__int64 v, bool btrTime_i)
 {
-
-private:
-    int m_dec;
-
-public:
-    union
+    i64 = 0;
+    if (btrTime_i)
     {
-        struct
-        {
-            unsigned __int64 ms : 24;
-            unsigned __int64 ss : 6;
-            unsigned __int64 nn : 6;
-            unsigned __int64 hh : 10;
-            unsigned __int64 unused : 1;
-            unsigned __int64 sign : 1;
-            unsigned __int64 tmp : 16;
-        };
-        __int64 i64;
-    };
-
-public:
-    inline myTime(int size) : m_dec((size - 3) * 2){};
-
-    inline void setValue(__int64 v, bool btrvValue = false)
+        btrTime btrt;
+        btrt.i = (int)v;
+        hh = btrt.hh;
+        nn = btrt.nn;
+        ss = btrt.ss;
+        ms = btrt.uu * 10000;
+        return;
+    }
+    if (m_bigendian)
     {
-
-        if (btrvValue)
-        {
-            btrTime btrt;
-            btrt.i = (int)v;
-            hh = btrt.hh;
-            nn = btrt.nn;
-            ss = btrt.ss;
-            ms = btrt.uu * 10000;
-            tmp = 0;
-            sign = 1;
-            unused = 0;
-            return;
-        }
         char* p = (char*)&i64;
         char* src = (char*)&v;
         if (m_dec)
@@ -197,16 +152,37 @@ public:
             p[0] = src[5];
             p[1] = src[4];
             p[2] = src[3];
-            ms = ms >> (3 - m_dec / 2) * 8;
+            ms = ms >> (3 - ((m_dec + 1) / 2)) * 8;
+            ms /= ((m_dec % 2) ? 10 : 1);
         }
         p[3] = src[2];
         p[4] = src[1];
         p[5] = src[0];
+        sign = 0;
+    }else
+    {//DD�~24�~3600 + HH�~3600 + MM�~60 + SS
+        hh = v / 10000;
+        nn = (v % 10000) / 100;
+        ss = v % 100;
     }
+}
 
-    inline __int64 getValue(bool btrvValue = false)
+__int64 myTime::getValue(bool btrTime_i)
+{
+    if (btrTime_i)
+    {
+        btrTime btrt;
+        btrt.hh = hh;
+        btrt.nn = nn;
+        btrt.ss = ss;
+        btrt.uu = (char)(ms / 100000);
+        return btrt.i;
+    }
+
+    __int64 v = 0;
+    sign = 1;
+    if (m_bigendian)
     {
-        __int64 v = 0;
         char* src = (char*)&i64;
         char* p = (char*)&v;
         p[2] = src[3];
@@ -214,107 +190,194 @@ public:
         p[0] = src[5];
         if (m_dec)
         {
-            ms = ms << (3 - m_dec / 2) * 8;
+            ms = ms << (3 - ((m_dec + 1) / 2)) * 8;
+            ms *= ((m_dec % 2) ? 10 : 1);
             p[3] = src[2];
             p[4] = src[1];
             p[5] = src[0];
         }
-        if (btrvValue)
-        {
-            btrTime btrt;
-            btrt.hh = hh;
-            btrt.nn = nn;
-            btrt.ss = ss;
-            btrt.uu = (char)(ms / 100000);
-            return btrt.i;
-        }
-        return v;
-    }
+    }else
+        v =  (hh * 10000LL) + (nn * 100LL) + ss;
+    sign = 0;
+    return v;
+}
 
-    inline char* toStr(char* p)
+char* myTime::toString(char* p, size_t size)
+{
+    if (m_dec)
+        sprintf_s(p, size, time_format_ms, (int)hh, (int)nn, (int)ss,
+                m_dec, (unsigned int)ms);
+    else
+        sprintf_s(p, size, time_format, (int)hh, (int)nn, (int)ss);
+    return p;
+}
+
+myTime& myTime::operator=(const char* p)
+{
+    i64 = 0;
+    size_t len = strlen(p);
+    if (len > 1)
     {
-        if (m_dec)
-            sprintf(p, time_format_ms, (int)hh, (int)nn, (int)ss,
-                    (unsigned int)ms);
-        else
-            sprintf(p, time_format, (int)hh, (int)nn, (int)ss);
-        return p;
+        hh = atol(p);
+        if (len > 4)
+        {
+            nn = atol(p + 3);
+            if (len > 7)
+            {
+                ss = atol(p + 6);
+                if (m_dec && len > 9)
+                {
+                    char tmp[10] = { 0x00 };
+                    strncpy(tmp, p + 9, (size_t)m_dec);
+                    ms = atol(tmp);
+                }
+            }
+        }
     }
+    return *this;
+}
 
 #ifdef _WIN32
-    inline wchar_t* toStr(wchar_t* p)
-    {
-        if (m_dec)
-            swprintf_s(p, 17, wtime_format_ms, (int)hh, (int)nn, (int)ss,
-                       (unsigned int)ms);
-        else
-            swprintf_s(p, 9, wtime_format, (int)hh, (int)nn, (int)ss);
-        return p;
-    }
-#endif
+wchar_t* myTime::toString(wchar_t* p, size_t size)
+{
+    if (m_dec)
+        swprintf_s(p, size, wtime_format_ms, (int)hh, (int)nn, (int)ss,
+                    m_dec, (unsigned int)ms);
+    else
+        swprintf_s(p, size, wtime_format, (int)hh, (int)nn, (int)ss);
+    return p;
+}
 
-    template <class T> inline myTime& operator=(const T* p)
+myTime& myTime::operator=(const wchar_t* p)
+{
+    i64 = 0;
+    size_t len = wcslen(p);
+    if (len > 1)
     {
-        sign = 1;
-        unused = 0;
-        ms = 0;
-        hh = _ttol_(p);
-        nn = _ttol_(p + 3);
-        ss = _ttol_(p + 6);
-        if (m_dec && _tcslen_(p) > 9)
+        hh = _wtol(p);
+        if (len > 4)
         {
-            T tmp[10] = { 0x00 };
-            _tcsncpy_(tmp, p + 9, (size_t)m_dec);
-            ms = _ttol_(tmp);
+            nn = _wtol(p + 3);
+            if (len > 7)
+            {
+                ss = _wtol(p + 6);
+                if (m_dec && len > 9)
+                {
+                    wchar_t tmp[10] = { 0x00 };
+                    wcsncpy(tmp, p + 9, (size_t)m_dec);
+                    ms = _wtol(tmp);
+                }
+            }
         }
-        return *this;
     }
-};
+    return *this;
+}
+#endif
+//-------------------------------------------------------------
+static int digit_logs[7] = {1, 10, 100, 1000, 10000, 100000, 1000000}; // digit 0 to 6
+#define ZEROPOINT_SEC 3020400ULL 
 
-struct myDateTime
+void maTime::setValue(__int64 v, bool btrTime_i)
 {
-private:
-    int m_dec;
-
-public:
-    union
+    if (m_bigendian && !btrTime_i)
     {
-        struct
-        {
-            unsigned __int64 ms : 24;
-            unsigned __int64 ss : 6;
-            unsigned __int64 nn : 6;
-            unsigned __int64 hh : 5;
-            unsigned __int64 dd : 5;
-            unsigned __int64 yymm : 17; // yy*13+mm   (yy 0-9999, mm 0-12)
-            unsigned __int64 sign : 1;
-        };
-        __int64 i64;
-    };
+        i64 = 0;
+        char* p = (char*)&i64;
+        char* src = (char*)&v;
+        p[0] = src[5];
+        p[1] = src[4];
+        p[2] = src[3];
+        p[3] = src[2];
+        p[4] = src[1];
+        p[5] = src[0];
+        i64 = i64 >> (3 - ((m_dec + 1) / 2)) * 8;
+        __int64 v = i64;
+        if (v)
+            v -= (ZEROPOINT_SEC * digit_logs[m_dec]);
+        ms = v % digit_logs[m_dec]; v /= digit_logs[m_dec];
+        ss = v % 60; v /= 60;
+        nn = v % 60; v /= 60;
+        hh = v % 24;
+        sign = 0;
+    }else
+        myTime::setValue(v, btrTime_i);
+}
+
+__int64 maTime::getValue(bool btrTime_i)
+{
+    if (!m_bigendian || btrTime_i) return myTime::getValue(btrTime_i);
+    unsigned __int64 i64t = (((hh) * 60ULL +  nn) * 60ULL + ss) * digit_logs[m_dec] +  ms;
+    if (i64t)
+        i64t += ZEROPOINT_SEC * digit_logs[m_dec];
+
+    __int64 v = 0;
+    char* src = (char*)&i64t;
+    char* p = (char*)&v;
+    p[2] = src[3];
+    p[1] = src[4];
+    p[0] = src[5];
+    p[3] = src[2];
+    p[4] = src[1];
+    p[5] = src[0];
+    v = v >> (3 - ((m_dec + 1) / 2)) * 8;
+    return v;
+}
 
-    inline myDateTime(int size) : m_dec((size - 5) * 2){};
+maTime& maTime::operator=(const char* p)
+{
+    myTime::operator=(p);
+    return *this;
+}
 
-    inline void setValue(__int64 v)
+#ifdef _WIN32
+maTime& maTime::operator=(const wchar_t* p)
+{
+    myTime::operator=(p);
+    return *this;
+}
+#endif
+//-------------------------------------------------------------
+void myDateTime::setValue(__int64 v)
+{
+    i64 = 0;
+    if (m_bigendian)
     {
         char* p = (char*)&i64;
         char* src = (char*)&v;
-        if (m_dec)
-        {
-            p[0] = src[7];
-            p[1] = src[6];
-            p[2] = src[5];
-            ms = ms >> (3 - m_dec / 2) * 8;
-        }
+
         p[3] = src[4];
         p[4] = src[3];
         p[5] = src[2];
         p[6] = src[1];
         p[7] = src[0];
+        if (i64 && m_dec)
+        {
+            p[0] = src[7];
+            p[1] = src[6];
+            p[2] = src[5];
+            ms = ms >> (3 - ((m_dec + 1) / 2)) * 8;
+            ms /= ((m_dec % 2) ? 10 : 1);
+        }
+
+    }else
+    {   // YYYY�~10000 + MM�~100 + DD  HH�~10000 + MM�~100 + SS
+        __int64 yy = v / 10000000000LL;
+        __int64 m = (v / 100000000LL) % 100;
+        yymm = yy*13 + m;
+        dd = (v / 1000000L) % 100;
+        hh = (v / 10000L) % 100;
+        nn = (v / 100L) % 100;
+        ss = v % 100;
     }
+    sign = 0;
+}
 
-    inline __int64 getValue()
+__int64 myDateTime::getValue()
+{
+    __int64 v = 0;
+    sign = 1;
+    if (m_bigendian)
     {
-        __int64 v = 0;
         char* src = (char*)&i64;
         char* p = (char*)&v;
         p[4] = src[3];
@@ -322,97 +385,301 @@ public:
         p[2] = src[5];
         p[1] = src[6];
         p[0] = src[7];
-        if (m_dec)
+        if (v && m_dec)
         {
-            ms = ms << (3 - m_dec / 2) * 8;
+            ms = ms << (3 - ((m_dec + 1) / 2)) * 8;
+            ms *= ((m_dec % 2) ? 10 : 1);
             p[5] = src[2];
             p[6] = src[1];
             p[7] = src[0];
         }
-        return v;
+
+    }else
+    { // YYYY�~10000 + MM�~100 + DD  HH�~10000 + MM�~100 + SS
+        __int64 yy = yymm / 13;
+        __int64 m =  yymm % 13;
+        v = (yy * 10000000000) + (m * 100000000LL) + (dd * 1000000LL) +
+             (hh * 10000LL) + (nn * 100LL) + ss;
     }
+    sign = 0;
+    return v;
+}
+
+myDateTime& myDateTime::operator=(const char* p)
+{
+    size_t len = strlen(p);
+    i64 = 0;
 
-    inline char* toStr(char* p)
+    if (len > 6)
     {
-        if (m_dec)
-            sprintf(p, datetime_format_ms, (int)(yymm / 13), (int)(yymm % 13),
-                    (int)dd, (int)hh, (int)nn, (int)ss, (unsigned int)ms);
-        else
-            sprintf(p, datetime_format, (int)(yymm / 13), (int)(yymm % 13),
-                    (int)dd, (int)hh, (int)nn, (int)ss);
-        return p;
+        yymm = atol(p) * 13 + atol(p + 5);
+        if (len > 9)
+        {
+            dd = atol(p + 8);
+            if (len > 12)
+            {
+                hh = atol(p + 11);
+                if (len > 15)
+                {
+                    nn = atol(p + 14);
+                    if (len > 18)
+                    {
+                        ss = atol(p + 17);
+                        if (m_dec && len > 20)
+                        {
+                            char tmp[10] = { 0x00 };
+                            strncpy(tmp, p + 20, (size_t)m_dec);
+                            ms = atol(tmp);
+                        }
+                    }
+                }
+            }
+        }
+    }
+    return *this;
+}
+
+
+void myDateTime::setTime(const char* p)
+{
+    i64 = 0;
+    size_t len = strlen(p);
+    if (len > 1)
+    {
+        hh = atol(p);
+        if (len > 4)
+        {
+            nn = atol(p + 3);
+            if (len > 7)
+            {
+                ss = atol(p + 6);
+                if (m_dec && len > 9)
+                {
+                    char tmp[10] = { 0x00 };
+                    strncpy(tmp, p + 9, (size_t)m_dec);
+                    ms = atol(tmp);
+                }
+            }
+        }
+    }
+}
+
+
+char* myDateTime::dateStr(char* p, size_t size) const
+{
+    sprintf_s(p, size, "%04d-%02d-%02d", (int)(yymm / 13),
+                    (int)(yymm % 13), (int)dd);
+    return p;
+}
+
+char* myDateTime::timeStr(char* p, size_t size) const
+{
+    if (m_dec)
+        sprintf_s(p, size, time_format_ms, (int)hh, (int)nn, (int)ss,
+                    m_dec, (unsigned int)ms);
+    else
+        sprintf_s(p, size, time_format, (int)hh, (int)nn, (int)ss);
+    return p;
+}
+
+char* myDateTime::toString(char* p, size_t size) const
+{
+    if (m_dec)
+    {
+        sprintf_s(p, size, datetime_format_ms, (int)(yymm / 13), (int)(yymm % 13),
+                (int)dd, (int)hh, (int)nn, (int)ss, m_dec, (unsigned int)ms);
     }
+    else
+        sprintf_s(p, size, datetime_format, (int)(yymm / 13), (int)(yymm % 13),
+                (int)dd, (int)hh, (int)nn, (int)ss);
+    return p;
+}
+
 
 #ifdef _WIN32
-    inline wchar_t* toStr(wchar_t* p)
+
+
+myDateTime& myDateTime::operator=(const wchar_t* p)
+{
+    size_t len = wcslen(p);
+    i64 = 0;
+    
+    if (len > 6)
     {
-        if (m_dec)
-            swprintf_s(p, 26, wdatetime_format_ms, (int)(yymm / 13),
-                       (int)(yymm % 13), (int)dd, (int)hh, (int)nn, (int)ss,
-                       (unsigned int)ms);
-        else
-            swprintf_s(p, 20, wdatetime_format, (int)(yymm / 13),
-                       (int)(yymm % 13), (int)dd, (int)hh, (int)nn, (int)ss);
-        return p;
+        yymm = _wtol(p) * 13 + _wtol(p + 5);
+        if (len > 9)
+        {
+            dd = _wtol(p + 8);
+            if (len > 12)
+            {
+                hh = _wtol(p + 11);
+                if (len > 15)
+                {
+                    nn = _wtol(p + 14);
+                    if (len > 18)
+                    {
+                        ss = _wtol(p + 17);
+                        if (m_dec && len > 20)
+                        {
+                            wchar_t tmp[10] = { 0x00 };
+                            wcsncpy(tmp, p + 20, (size_t)m_dec);
+                            ms = _wtol(tmp);
+                        }
+                    }
+                }
+            }
+        }
     }
-#endif
+    return *this;
+}
 
-    template <class T> myDateTime& operator=(const T* p)
+void myDateTime::setTime(const wchar_t* p)
+{
+    i64 = 0;
+    size_t len = wcslen(p);
+    if (len > 1)
     {
-        sign = 1;
-        ms = 0;
-        yymm = _ttol_(p) * 13 + _ttol_(p + 5);
-        dd = _ttol_(p + 8);
-        hh = _ttol_(p + 11);
-        nn = _ttol_(p + 14);
-        ss = _ttol_(p + 17);
-        if (m_dec && _tcslen_(p) > 20)
+        hh = _wtol(p);
+        if (len > 4)
         {
-            T tmp[10] = { 0x00 };
-            _tcsncpy_(tmp, p + 20, (size_t)m_dec);
-            ms = _ttol_(tmp);
+            nn = _wtol(p + 3);
+            if (len > 7)
+            {
+                ss = _wtol(p + 6);
+                if (m_dec && len > 9)
+                {
+                    wchar_t tmp[10] = { 0x00 };
+                    wcsncpy(tmp, p + 9, (size_t)m_dec);
+                    ms = _wtol(tmp);
+                }
+            }
         }
-        return *this;
     }
-};
+}
+
+wchar_t* myDateTime::dateStr(wchar_t* p, size_t size) const
+{
+    swprintf_s(p, size, L"%04d-%02d-%02d", (int)(yymm / 13),
+                    (int)(yymm % 13), (int)dd);
+    return p;
+}
+
+wchar_t* myDateTime::timeStr(wchar_t* p, size_t size) const
+{
+    if (m_dec)
+        swprintf_s(p, size, wtime_format_ms, (int)hh, (int)nn, (int)ss,
+                    m_dec, (unsigned int)ms);
+    else
+        swprintf_s(p, size, wtime_format, (int)hh, (int)nn, (int)ss);
+    return p;
+}
 
-struct myTimeStamp
+wchar_t* myDateTime::toString(wchar_t* p, size_t size) const
 {
-private:
-    int m_dec;
+    if (m_dec)
+        swprintf_s(p, size, wdatetime_format_ms, (int)(yymm / 13),
+                    (int)(yymm % 13), (int)dd, (int)hh, (int)nn, (int)ss,
+                    m_dec, (unsigned int)ms);
+    else
+        swprintf_s(p, size, wdatetime_format, (int)(yymm / 13),
+                    (int)(yymm % 13), (int)dd, (int)hh, (int)nn, (int)ss);
+    return p;
+}
 
-public:
-    union
+#endif
+//-------------------------------------------------------------
+void maDateTime::setValue(__int64 v)
+{
+    if (m_bigendian)
     {
-        struct
-        {
-            unsigned __int64 ms : 24;
-            unsigned __int64 datetime : 32;
-            unsigned __int64 tmp : 8;
-        };
-        __int64 i64;
-    };
+        i64 = 0;
+        char* p = (char*)&i64;
+        char* src = (char*)&v;
+        p[3] = src[4];
+        p[4] = src[3];
+        p[5] = src[2];
+        p[6] = src[1];
+        p[7] = src[0];
+        p[0] = src[7];
+        p[1] = src[6];
+        p[2] = src[5];
+        i64 = i64 >> (3 - ((m_dec + 1) / 2)) * 8;
+        __int64 v = i64;
+        ms = v % digit_logs[m_dec]; v /= digit_logs[m_dec];
+        ss = v % 60; v /= 60;
+        nn = v % 60; v /= 60;
+        hh = v % 24; v /= 24;
+        dd = v % 32; v /= 32;
+        __int64 mm = v % 13; v /= 13;
+        __int64 yy = v;
+        yymm = yy*13 + mm;
+        
+    }else
+        myDateTime::setValue(v);
+}
 
-    inline myTimeStamp(int size) : m_dec((size - 4) * 2){};
+__int64 maDateTime::getValue()
+{
+    if (!m_bigendian) return myDateTime::getValue();
+    unsigned __int64 i64t = (((((yymm) * 32ULL + dd) * 24ULL + hh) * 60ULL + nn) * 60ULL +
+                                ss) * digit_logs[m_dec] + ms;
+    __int64 v;
+    char* src = (char*)&i64t;
+    char* p = (char*)&v;
+    p[4] = src[3];
+    p[3] = src[4];
+    p[2] = src[5];
+    p[1] = src[6];
+    p[0] = src[7];
+    p[5] = src[2];
+    p[6] = src[1];
+    p[7] = src[0];
+    v = v >> (3 - ((m_dec + 1) / 2)) * 8;
+    return v;
+}
+
+maDateTime& maDateTime::operator=(const char* p)
+{
+    myDateTime::operator=(p);
+    return *this;
+}
 
-    inline void setValue(__int64 v)
+#ifdef _WIN32
+maDateTime& maDateTime::operator=(const wchar_t* p)
+{
+    myDateTime::operator=(p);
+    return *this;
+}
+#endif
+
+//-------------------------------------------------------------
+void myTimeStamp::setValue(__int64 v)
+{
+    i64 = 0;
+    if (m_bigendian)
     {
         char* p = (char*)&i64;
         char* src = (char*)&v;
-        if (m_dec)
+        p[3] = src[3];
+        p[4] = src[2];
+        p[5] = src[1];
+        p[6] = src[0];
+        if (m_dec && datetime)
         {
             p[0] = src[6];
             p[1] = src[5];
             p[2] = src[4];
-            ms = ms >> (3 - m_dec / 2) * 8;
+            ms = ms >> (3 - ((m_dec + 1) / 2)) * 8;
+            if (!m_mariadb)
+                ms /= ((m_dec % 2) ? 10 : 1);
         }
-        p[3] = src[3];
-        p[4] = src[2];
-        p[5] = src[1];
-        p[6] = src[0];
-    }
+    }else
+        datetime = v;
+}
 
-    inline __int64 getValue()
+__int64 myTimeStamp::getValue()
+{
+    if (m_bigendian)
     {
         __int64 v = 0;
         char* src = (char*)&i64;
@@ -424,80 +691,229 @@ public:
         p[0] = src[6];
         if (m_dec)
         {
-            ms = ms << (3 - m_dec / 2) * 8;
+            ms = ms << (3 - ((m_dec + 1) / 2)) * 8;
+            if (!m_mariadb)
+                ms *= ((m_dec % 2) ? 10 : 1);
             p[4] = src[2];
             p[5] = src[1];
             p[6] = src[0];
         }
         return v;
     }
+    return datetime;
+}
 
-#ifdef _WIN32
-    inline wchar_t* toStr(wchar_t* p)
+char* myTimeStamp::toString(char* p, size_t size)
+{
+    if (datetime)
     {
-        struct tm* st;
         time_t v = (time_t)datetime;
-        st = localtime(&v);
+        struct tm* st = localtime(&v);
 
         if (m_dec)
-            swprintf_s(p, 26, wdatetime_format_ms_i, st->tm_year + 1900,
-                       st->tm_mon + 1, st->tm_mday, st->tm_hour, st->tm_min,
-                       st->tm_sec, (unsigned int)ms);
+            sprintf_s(p, size, datetime_format_ms, st->tm_year + 1900, st->tm_mon + 1,
+                    st->tm_mday, st->tm_hour, st->tm_min, st->tm_sec,
+                    m_dec, (unsigned int)ms);
+        else
+            sprintf_s(p, size, datetime_format, st->tm_year + 1900, st->tm_mon + 1,
+                    st->tm_mday, st->tm_hour, st->tm_min, st->tm_sec);
+    }else
+    {
+        if (m_dec)
+            sprintf_s(p, size, datetime_format_ms, 0, 0, 0, 0, 0, 0, m_dec, 0);
         else
-            swprintf_s(p, 20, wdatetime_format_i, st->tm_year + 1900,
-                       st->tm_mon + 1, st->tm_mday, st->tm_hour, st->tm_min,
-                       st->tm_sec);
-        return p;
+            sprintf_s(p, size, datetime_format, 0, 0, 0, 0, 0, 0);
+
     }
-#endif
+    return p;
+}
 
-    inline char* toStr(char* p)
+myTimeStamp& myTimeStamp::operator=(const char* p)
+{
+    size_t len = strlen(p);
+    struct tm st;
+    memset(&st, 0, sizeof(tm));
+    i64 = 0;
+    if (len > 3)
+    {
+        st.tm_year = (int)atol(p) - 1900;
+        if (len > 6)
+        {
+            st.tm_mon =  (int)atol(p + 5) - 1;
+            if (len > 9)
+            {
+                st.tm_mday = (int)atol(p + 8);
+                if (len > 12)
+                {
+                    st.tm_hour = (int)atol(p + 11);
+                    if (len > 15)
+                    {
+                        st.tm_min = (int)atol(p + 14);
+                        if (len > 18)
+                        {
+                            st.tm_sec = (int)atol(p + 17);
+                            if (m_dec && len > 20)
+                            {
+                                char tmp[10] = { 0x00 };
+                                strncpy(tmp, p + 20, (size_t)m_dec);
+                                ms = atol(tmp);
+                            }
+                        }
+                    }
+                }
+            }
+        }
+    }
+    datetime = (__int64)mktime(&st); 
+    return *this;
+}
+
+char* myTimeStamp::dateStr(char* p, size_t size) const
+{
+    if (datetime)
     {
-        struct tm* st;
         time_t v = (time_t)datetime;
-        st = localtime(&v);
+        struct tm* st = localtime(&v);
+        sprintf_s(p, size, "%04d-%02d-%02d", st->tm_year + 1900, st->tm_mon + 1,st->tm_mday);
+    }else
+        sprintf_s(p, size, "%04d-%02d-%02d", 0, 0, 0);
+    return p;
+}
+
+char* myTimeStamp::timeStr(char* p, size_t size) const
+{
+    if (datetime)
+    {
+        time_t v = (time_t)datetime;
+        struct tm* st = localtime(&v);
 
         if (m_dec)
-            sprintf(p, datetime_format_ms_i, st->tm_year + 1900, st->tm_mon + 1,
-                    st->tm_mday, st->tm_hour, st->tm_min, st->tm_sec,
-                    (unsigned int)ms);
+            sprintf_s(p, size, time_format_ms, st->tm_hour, st->tm_min, st->tm_sec,
+                    m_dec, (unsigned int)ms);
         else
-            sprintf(p, datetime_format_i, st->tm_year + 1900, st->tm_mon + 1,
-                    st->tm_mday, st->tm_hour, st->tm_min, st->tm_sec);
-        return p;
+            sprintf_s(p, size, time_format, st->tm_hour, st->tm_min, st->tm_sec);
+    }else
+    {
+        if (m_dec)
+            sprintf_s(p, size, time_format_ms,  0, 0, 0, m_dec, 0);
+        else
+            sprintf_s(p, size, time_format,  0, 0, 0);
     }
-};
-inline int btrdateToMydate(int btrd)
+    return p;
+}
+
+#ifdef _WIN32
+#pragma warning(disable : 4477)
+wchar_t* myTimeStamp::toString(wchar_t* p, size_t size)
 {
-    myDate myd;
-    myd.setValue(btrd, true);
-    return myd.getValue(true);
+    if (datetime)
+    {
+        time_t v = (time_t)datetime;
+        errno = 0;
+        struct tm* st = localtime(&v);
+        if (st == NULL)
+        {
+            swprintf_s(p, size, L"er:%d %s", errno, _tcserror(errno));
+            return p;
+        }
+        if (m_dec)
+            swprintf_s(p, size, wdatetime_format_ms, st->tm_year + 1900,
+                        st->tm_mon + 1, st->tm_mday, st->tm_hour, st->tm_min,
+                        st->tm_sec, m_dec, (unsigned int)ms);
+        else
+            swprintf_s(p, size, wdatetime_format, st->tm_year + 1900,
+                        st->tm_mon + 1, st->tm_mday, st->tm_hour, st->tm_min,
+                        st->tm_sec);
+    }else
+    {
+        if (m_dec)
+            swprintf_s(p, size, wdatetime_format_ms, 0, 0, 0, 0, 0, 0, m_dec, 0);
+        else
+            swprintf_s(p, size, wdatetime_format, 0, 0, 0, 0, 0, 0);
+    }
+    return p;
 }
+#pragma warning(default : 4477)
 
-inline __int64 btrtimeToMytime(int btrt)
+myTimeStamp& myTimeStamp::operator=(const wchar_t* p)
 {
-    myTime myt(4);
-    myt.setValue(btrt, true);
-    return myt.getValue(true);
+    size_t len = wcslen(p);
+    struct tm st;
+    memset(&st, 0, sizeof(tm));
+    i64 = 0;
+    if (len > 3)
+    {
+        st.tm_year = (int)_wtol(p) - 1900;
+        if (len > 6)
+        {
+            st.tm_mon =  (int)_wtol(p + 5) - 1;
+            if (len > 9)
+            {
+                st.tm_mday = (int)_wtol(p + 8);
+                if (len > 12)
+                {
+                    st.tm_hour = (int)_wtol(p + 11);
+                    if (len > 15)
+                    {
+                        st.tm_min = (int)_wtol(p + 14);
+                        if (len > 18)
+                        {
+                            st.tm_sec = (int)_wtol(p + 17);
+                            if (m_dec && len > 20)
+                            {
+                                wchar_t tmp[10] = { 0x00 };
+                                wcsncpy(tmp, p + 20, (size_t)m_dec);
+                                ms = _wtol(tmp);
+                            }
+                        }
+                    }
+                }
+            }
+        }
+    }
+    datetime = (__int64)mktime(&st); 
+    return *this;
 }
 
-inline int mydateToBtrdate(int mydate)
+wchar_t* myTimeStamp::dateStr(wchar_t* p, size_t size) const
 {
-    myDate myd;
-    myd.setValue(mydate);
-    return myd.getValue(true);
+    if (datetime)
+    {
+        time_t v = (time_t)datetime;
+        struct tm* st = localtime(&v);
+        swprintf_s(p, size, L"%04d-%02d-%02d", st->tm_year + 1900, st->tm_mon + 1,st->tm_mday);
+    }else
+        swprintf_s(p, size, L"%04d-%02d-%02d", 0, 0, 0);
+    return p;
 }
 
-inline int mytimeToBtrtime(__int64 mytime, int size)
+wchar_t* myTimeStamp::timeStr(wchar_t* p, size_t size) const
 {
-    myTime myt(size);
-    myt.setValue(mytime);
-    return (int)myt.getValue(true);
+    if (datetime)
+    {
+        time_t v = (time_t)datetime;
+        struct tm* st = localtime(&v);
+
+        if (m_dec)
+            swprintf_s(p, size, wtime_format_ms, st->tm_hour, st->tm_min, st->tm_sec,
+                    m_dec, (unsigned int)ms);
+        else
+            swprintf_s(p, size, wtime_format, st->tm_hour, st->tm_min, st->tm_sec);
+    }else
+    {
+        if (m_dec)
+            swprintf_s(p, size, wtime_format_ms,  0, 0, 0, m_dec, 0);
+        else
+            swprintf_s(p, size, wtime_format,  0, 0, 0);
+    }
+    return p;
 }
-#pragma warning(default : 4996)
+#endif
+
+
+
+#pragma warning(default : 4996)    
 
-#pragma pack(pop)
-pragma_pop;
 
 } // namespace tdap
 } // namespace protocol