myDateTime.h

#ifndef BZS_DB_PROTOCOL_TDAP_MYDATETIME_H
#define BZS_DB_PROTOCOL_TDAP_MYDATETIME_H
/*=================================================================
   Copyright (C) 2015 BizStation Corp All rights reserved.

   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 2
   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, write to the Free Software
   Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
   02111-1307, USA.
=================================================================*/
#include <tchar.h>
#include <bzs/env/compiler.h>
#include <stddef.h>

namespace bzs
{
namespace db
{
namespace protocol
{
namespace tdap
{
/** @cond INTERNAL */

#pragma pack(push, 1)
pragma_pack1;

struct PACKAGE myDate
{
    union
    {
            struct
            {
                unsigned int dd : 5;
                unsigned int mm : 4;
                unsigned int yy : 15;
                unsigned int tmp : 8;
            };
            int i;
        };
    inline myDate() {};
    inline myDate(int /*dec*/, bool /*bigendian*/) {};
    void setValue(int v, bool btrDate_i = false);
    int getValue(bool btrvValue = false);
    char* toString(char* p, size_t size, bool w3_format = false);
    myDate& operator=(const char* p);
#ifdef _WIN32
    wchar_t* toString(wchar_t* p, size_t size, bool w3_format = false);
    myDate& operator=(const wchar_t* p);
#endif
    inline __int64 internalValue() const { return i; }
    inline void setInternalValue(__int64 v) { i = (int)v; }
};

struct PACKAGE myTime
{

protected:
    int m_dec;
    bool m_bigendian;
public:
    union
    {
        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 dec, bool bigendian) : m_dec(dec), 
        m_bigendian(bigendian){};
    virtual void setValue(__int64 v, bool btrTime_i = false);
    virtual __int64 getValue(bool btrTime_i = false);
    char* toString(char* p, size_t size);
    myTime& operator=(const char* p);
#ifdef _WIN32
    wchar_t* toString(wchar_t* p, size_t size);
    myTime& operator=(const wchar_t* p);
#endif
    inline __int64 internalValue() const { return i64; }
    inline void setInternalValue(__int64 v) { i64 = v; }
};

struct PACKAGE maTime : public  myTime
{
    virtual void setValue(__int64 v, bool btrTime_i = false);
    virtual __int64 getValue(bool btrTime_i = false);
public:
    inline maTime(int dec, bool bigendian) : myTime(dec, bigendian){}
    maTime& operator=(const char* p);
#ifdef _WIN32
    maTime& operator=(const wchar_t* p) ;
#endif
};

struct PACKAGE myDateTime
{
protected:
    int m_dec;
    bool m_bigendian;
public:
    union
    {
        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;  //always 1 0 is reserved
        };
        __int64 i64;
    };

    inline myDateTime(int dec, bool bigendian) : m_dec(dec), m_bigendian(bigendian){};
    virtual void setValue(__int64 v);
    virtual __int64 getValue();
    char* toString(char* p, size_t size) const;
    myDateTime& operator=(const char* p);
    char* dateStr(char* p, size_t size) const;
    char* timeStr(char* p, size_t size) const;
    void setTime(const char* p);

#ifdef _WIN32
    wchar_t* toString(wchar_t* p, size_t size) const ;
    myDateTime& operator=(const wchar_t* p) ;
    wchar_t* dateStr(wchar_t* p, size_t size) const;
    wchar_t* timeStr(wchar_t*, size_t size) const;
    void setTime(const wchar_t* p);
#endif
    inline __int64 internalValue() const { return i64; }
    inline void setInternalValue(__int64 v) { i64 = v; }
};

struct PACKAGE maDateTime : public  myDateTime
{
    virtual void setValue(__int64 v);
    virtual __int64 getValue();
public:
    inline maDateTime(int dec, bool bigendian) : myDateTime(dec, bigendian){};
    maDateTime& operator=(const char* p);
#ifdef _WIN32
    maDateTime& operator=(const wchar_t* p) ;
#endif
};

struct PACKAGE myTimeStamp
{
private:
    int m_dec;
    bool m_bigendian;
protected:
    bool m_mariadb;
public:
    union
    {
        struct
        {
            unsigned __int64 ms : 24;
            unsigned __int64 datetime : 32;
            unsigned __int64 tmp : 8;
        };
        __int64 i64;
    };

    inline myTimeStamp(int dec, bool bigendian) : m_dec(dec), 
        m_bigendian(bigendian), m_mariadb(false){};
    void setValue(__int64 v);
    __int64 getValue();
    char* toString(char* p, size_t size);
    myTimeStamp& operator=(const char* p);
    char* dateStr(char* p, size_t size) const;
    char* timeStr(char* p, size_t size) const;

#ifdef _WIN32
    wchar_t* toString(wchar_t* p, size_t size);
    myTimeStamp& operator=(const wchar_t* p);
    wchar_t* dateStr(wchar_t* p, size_t size) const;
    wchar_t* timeStr(wchar_t* p, size_t size) const;
#endif
    inline __int64 internalValue() const { return i64; }
    inline void setInternalValue(__int64 v) { i64 = v; }
};


struct PACKAGE maTimeStamp : public myTimeStamp
{

    inline maTimeStamp (int dec, bool bigendian) : myTimeStamp(dec, bigendian)
    {
        m_mariadb = true;
    }
    inline maTimeStamp& operator=(const char* p){ myTimeStamp::operator=(p); return *this;}
#ifdef _WIN32
    inline maTimeStamp& operator=(const wchar_t* p) { myTimeStamp::operator=(p); return *this; }
#endif
};

inline int btrdateToMydate(int btrd)
{
    myDate myd;
    myd.setValue(btrd, true);
    return myd.i;
}

// Do not work at maridab
inline __int64 btrtimeToMytime(int btrTime_i, bool bigendian)
{
    myTime myt(4, bigendian);
    myt.setValue(btrTime_i, true);
    return myt.i64;
}

inline int mydateToBtrdate(int myDate_i)
{
    myDate myd;
    myd.i = myDate_i;
    return myd.getValue(true);
}

inline int mytimeToBtrtime(__int64 myTime_i, bool bigendian, int dec)
{
    myTime myt(dec, bigendian);
    myt.i64 = myTime_i;
    return (int)myt.getValue(true);
}

template <class T>
__int64 getInternalValue(int dec, bool bigendian, __int64 value)
{
    T t(dec, bigendian);
    t.setValue(value);
    return t.internalValue();
}

template <class T>
__int64 getStoreValue(int dec, bool bigendian, __int64 value)
{
    T t(dec, bigendian);
    t.setInternalValue(value);
    return t.getValue();
}

#pragma warning(disable : 4244)
template <class T, typename CHAR>
const CHAR* date_time_str(int dec, bool bigendian, __int64 value, CHAR* buf, size_t size)
{
    T t(dec, bigendian);
    t.setValue(value);
    return t.toString(buf, size);
}

template <class T, class T2>
inline __int64 str_to_64(int dec, bool bigendian, const T2* data)
{
    T t(dec, bigendian);
    t = data;
    return t.getValue();
}

#pragma warning(default : 4244)



#pragma pack(pop)
pragma_pop;
/** @endcond */

} // namespace tdap
} // namespace protocol
} // namespace db
} // namespace bzs

#endif //BZS_DB_PROTOCOL_TDAP_MYDATETIME_H