FieldTypes.h

Go to the documentation of this file.

/* -*- C++ -*- */

/****************************************************************************
** Copyright (c) quickfixengine.org  All rights reserved.
**
** This file is part of the QuickFIX FIX Engine
**
** This file may be distributed under the terms of the quickfixengine.org
** license as defined by quickfixengine.org and appearing in the file
** LICENSE included in the packaging of this file.
**
** This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
** WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
**
** See http://www.quickfixengine.org/LICENSE for licensing information.
**
** Contact ask@quickfixengine.org if any conditions of this licensing are
** not clear to you.
**
****************************************************************************/

#ifndef FIX_FIELDTYPES_H
#define FIX_FIELDTYPES_H

#ifdef _MSC_VER
#pragma warning( disable : 4503 4355 4786 4290 )
#endif

#include "Utility.h"
#include <string>
#include <time.h>

namespace FIX
{











struct DateTime 
{
  int m_date;
  int m_time;

  enum 
  {
    SECONDS_PER_DAY = 86400,
    SECONDS_PER_HOUR = 3600,
    SECONDS_PER_MIN = 60,
    MINUTES_PER_HOUR = 60,

    MILLIS_PER_DAY = 86400000,
    MILLIS_PER_HOUR = 3600000,
    MILLIS_PER_MIN = 60000,
    MILLIS_PER_SEC = 1000,

    // time_t epoch (1970-01-01) as a Julian date
    JULIAN_19700101 = 2440588
  };

  DateTime () : m_date (0), m_time (0) {}

  DateTime (int date, int time) : m_date (date), m_time (time) {}

  DateTime( int year, int month, int day,
            int hour, int minute, int second, int millis ) 
  {
    m_date = julianDate( year, month, day );
    m_time = makeHMS( hour, minute, second, millis );
  }

  virtual ~DateTime() {}

  inline int getYear() const 
  {
    int y, m, d;
    getYMD( y, m, d );
    return y;
  }
    
  inline int getMonth() const 
  {
    int y, m, d;
    getYMD( y, m, d );
    return m;
  }

  inline int getDay() const 
  {
    int y, m, d;
    getYMD( y, m, d );
    return d;
  }

  inline int getDate() const { return getDay(); }

  inline int getJulianDate() const { return m_date; }

  inline int getHour() const 
  {
    return m_time / MILLIS_PER_HOUR;
  }

  inline int getMinute() const 
  {
    return (m_time / MILLIS_PER_MIN) % MINUTES_PER_HOUR;
  }

  inline int getSecond() const 
  {
    return (m_time / MILLIS_PER_SEC) % SECONDS_PER_MIN;
  }

  inline int getMillisecond() const 
  {
    return m_time % MILLIS_PER_SEC;
  }

  inline void getYMD (int& year, int& month, int& day) const 
  {
    getYMD( m_date, year, month, day );
  }

  inline void getHMS( int& hour, int& minute, int& second, int& millis ) const 
  {
    int ticks = m_time / MILLIS_PER_SEC;
    hour = ticks / SECONDS_PER_HOUR;
    minute = (ticks / SECONDS_PER_MIN) % MINUTES_PER_HOUR;
    second = ticks % SECONDS_PER_MIN;
    millis = m_time % MILLIS_PER_SEC;
  }

  inline int getWeekDay() const 
  {
    int Y, M, D;
    getYMD (Y, M, D);
    int m = M >= 3 ? M - 2 : M + 10;
    int Yprime = M >= 3 ? Y : Y - 1;
    int y = Yprime % 100;
    int c = Yprime / 100;
    int wd = (D + int (2.6 * m - 0.2) + y + int (y / 4) + int (c / 4) -
              (2 * c)) % 7;
    return 1 + (wd < 0 ? 7 + wd : wd);
  }

  inline time_t getTimeT() const 
  {
    return (SECONDS_PER_DAY * (m_date - JULIAN_19700101) +
            m_time / MILLIS_PER_SEC);
  }

  tm getTmUtc() const 
  {
    int year, month, day;
    int hour, minute, second, millis;
    tm result = { 0 };

    getYMD( year, month, day );
    getHMS( hour, minute, second, millis );

    result.tm_year = year - 1900;
    result.tm_mon = month - 1;
    result.tm_mday = day;
    result.tm_hour = hour;
    result.tm_min = minute;
    result.tm_sec = second;
    result.tm_isdst = -1;

    return result;
  }

  void setYMD( int year, int month, int day ) 
  {
    m_date = julianDate( year, month, day );
  }

  void setHMS( int hour, int minute, int second, int millis )
  {
    m_time = makeHMS( hour, minute, second, millis );
  }

  void setHour( int hour )
  {
    int old_hour, min, sec, millis;
    getHMS( old_hour, min, sec, millis );
    setHMS( hour, min, sec, millis );
  }

  void setMinute( int min )
  {
    int hour, old_min, sec, millis;
    getHMS( hour, old_min, sec, millis );
    setHMS( hour, min, sec, millis );
  }

  void setSecond( int sec )
  {
    int hour, min, old_sec, millis;
    getHMS( hour, min, old_sec, millis );
    setHMS( hour, min, sec, millis );
  }

  void setMillisecond( int millis )
  {
    int hour, min, sec, old_millis;
    getHMS( hour, min, sec, old_millis );
    setHMS( hour, min, sec, millis );
  }

  void clearDate() 
  {
    m_date = 0;
  }

  void clearTime() 
  {
    m_time = 0;
  }

  void set( int date, int time ) { m_date = date; m_time = time; }

  void set( const DateTime& other ) 
  {
    m_date = other.m_date;
    m_time = other.m_time;
  }

  void operator+=( int seconds ) 
  {
    int d = seconds / SECONDS_PER_DAY;
    int s = seconds % SECONDS_PER_DAY;

    m_date += d;
    m_time += s * MILLIS_PER_SEC;

    if( m_time > MILLIS_PER_DAY )
    {
      m_date++;
      m_time %= MILLIS_PER_DAY;
    }
    else if( m_time < 0 )
    {
      m_date--;
      m_time += MILLIS_PER_DAY;
    }
  }

  static int makeHMS( int hour, int minute, int second, int millis )
  {
    return MILLIS_PER_SEC * (SECONDS_PER_HOUR * hour +
                             SECONDS_PER_MIN * minute +
                             second) + millis;
  }

  static DateTime nowUtc();

  static DateTime nowLocal();

  static DateTime fromUtcTimeT( time_t t, int millis = 0 ) 
  {
    struct tm tm = time_gmtime( &t );
    return fromTm( tm, millis );
  }

  static DateTime fromLocalTimeT( time_t t, int millis = 0 )
  {
    struct tm tm = time_localtime( &t );
    return fromTm( tm, millis );
  }

  static DateTime fromTm( const tm& tm, int millis = 0 )
  {
    return DateTime ( julianDate(tm.tm_year + 1900, tm.tm_mon + 1,
                                 tm.tm_mday),
                     makeHMS(tm.tm_hour, tm.tm_min, tm.tm_sec, millis) );
  }

  static int julianDate( int year, int month, int day )
  {
    int a = (14 - month) / 12;
    int y = year + 4800 - a;
    int m = month + 12 * a - 3;
    return (day + int ((153 * m + 2) / 5) + y * 365 +
            int (y / 4) - int (y / 100) + int (y / 400) - 32045);
  }

  static void getYMD( int jday, int& year, int& month, int& day )
  {
    int a = jday + 32044;
    int b = (4 * a + 3) / 146097;
    int c = a - int ((b * 146097) / 4);
    int d = (4 * c + 3) / 1461;
    int e = c - int ((1461 * d) / 4);
    int m = (5 * e + 2) / 153;
    day = e - int ((153 * m + 2) / 5) + 1;
    month = m + 3 - 12 * int (m / 10);
    year = b * 100 + d - 4800 + int (m / 10);
  }
};

inline bool operator==( const DateTime& lhs, const DateTime& rhs )
{
  return lhs.m_date == rhs.m_date && lhs.m_time == rhs.m_time;
}

inline bool operator!=( const DateTime& lhs, const DateTime& rhs )
{
  return !(lhs == rhs);
}

inline bool operator<( const DateTime& lhs, const DateTime& rhs )
{
  if( lhs.m_date < rhs.m_date )
    return true;
  else if( lhs.m_date > rhs.m_date )
    return false;
  else if( lhs.m_time < rhs.m_time )
    return true;
  return false;
}

inline bool operator>( const DateTime& lhs, const DateTime& rhs )
{
  return !(lhs == rhs || lhs < rhs);
}

inline bool operator<=( const DateTime& lhs, const DateTime& rhs )
{
  return lhs == rhs || lhs < rhs;
}

inline bool operator>=( const DateTime& lhs, const DateTime& rhs )
{
  return lhs == rhs || lhs > rhs;
}

inline int operator-( const DateTime& lhs, const DateTime& rhs )
{
  return (DateTime::SECONDS_PER_DAY * (lhs.m_date - rhs.m_date) +
          // Truncate the millis before subtracting
          lhs.m_time / 1000 - rhs.m_time / 1000);
}

class UtcTimeStamp : public DateTime
{
public:
  UtcTimeStamp()
  : DateTime( DateTime::nowUtc() ) {}

  UtcTimeStamp( int hour, int minute, int second, int millisecond = 0 )
  : DateTime( DateTime::nowUtc() )
  {
    setHMS( hour, minute, second, millisecond );
  }

  UtcTimeStamp( int hour, int minute, int second,
                int date, int month, int year )
  : DateTime( year, month, date, hour, minute, second, 0 ) {}

  UtcTimeStamp( int hour, int minute, int second, int millisecond,
                int date, int month, int year )
  : DateTime( year, month, date, hour, minute, second, millisecond ) {}

  UtcTimeStamp( time_t time, int millisecond = 0 )
  : DateTime( fromUtcTimeT (time, millisecond) ) {}

  UtcTimeStamp( const tm* time, int millisecond = 0 )
  : DateTime( fromTm (*time, millisecond) ) {}

  void setCurrent() 
  {
    set( DateTime::nowUtc() );
  }
};

class LocalTimeStamp : public DateTime
{
public:
  LocalTimeStamp()
  : DateTime( DateTime::nowLocal() ) {}

  LocalTimeStamp( int hour, int minute, int second, int millisecond = 0 )
  : DateTime( DateTime::nowLocal() )
  {
    setHMS( hour, minute, second, millisecond );
  }

  LocalTimeStamp( int hour, int minute, int second,
                int date, int month, int year )
  : DateTime( year, month, date, hour, minute, second, 0 ) {}

  LocalTimeStamp( int hour, int minute, int second, int millisecond,
                int date, int month, int year )
  : DateTime( year, month, date, hour, minute, second, millisecond ) {}

  LocalTimeStamp( time_t time, int millisecond = 0 )
  : DateTime( fromLocalTimeT (time, millisecond) ) {}

  LocalTimeStamp( const tm* time, int millisecond = 0 )
  : DateTime( fromTm (*time, millisecond) ) {}

  void setCurrent() 
  {
    set( DateTime::nowLocal() );
  }
};

class UtcTimeOnly : public DateTime
{
public:
  UtcTimeOnly()
  {
    setCurrent();
  }

  UtcTimeOnly( const DateTime& val )
  : DateTime(val)
  {
    clearDate();
  }

  UtcTimeOnly( int hour, int minute, int second, int millisecond = 0 )
  {
    setHMS( hour, minute, second, millisecond );
  }

  UtcTimeOnly( time_t time, int millisecond = 0 )
  : DateTime( fromUtcTimeT (time, millisecond) )
  {
    clearDate();
  }

  UtcTimeOnly( const tm* time, int millisecond = 0 )
  : DateTime( fromTm (*time, millisecond) )
  {
    clearDate();
  }

  void setCurrent()
  {
    DateTime d = nowUtc();
    m_time = d.m_time;
  }
};

class LocalTimeOnly : public DateTime
{
public:
  LocalTimeOnly()
  {
    setCurrent();
  }

  LocalTimeOnly( const DateTime& val )
  : DateTime(val)
  {
    clearDate();
  }

  LocalTimeOnly( int hour, int minute, int second, int millisecond = 0 )
  {
    setHMS( hour, minute, second, millisecond );
  }

  LocalTimeOnly( time_t time, int millisecond = 0 )
  : DateTime( fromLocalTimeT (time, millisecond) )
  {
    clearDate();
  }

  LocalTimeOnly( const tm* time, int millisecond = 0 )
  : DateTime( fromTm (*time, millisecond) )
  {
    clearDate();
  }

  void setCurrent()
  {
    DateTime d = nowLocal();
    m_time = d.m_time;
  }
};

class UtcDate : public DateTime
{
public:
  UtcDate()
  {
    setCurrent();
  }

  UtcDate( const DateTime& val )
  : DateTime( val )
  {
    clearTime();
  }

  UtcDate( int date, int month, int year )
  : DateTime(year, month, date, 0, 0, 0, 0) {}

  UtcDate( long sec )
  : DateTime( sec / DateTime::SECONDS_PER_DAY, 0 ) {}

  UtcDate( const tm* time )
  : DateTime( fromTm (*time) )
  {
    clearTime();
  }

  void setCurrent()
  {
    DateTime d = nowUtc();
    m_date = d.m_date;
  }
};

class LocalDate : public DateTime
{
public:
  LocalDate()
  {
    setCurrent();
  }

  LocalDate( const DateTime& val )
  : DateTime( val )
  {
    clearTime();
  }

  LocalDate( int date, int month, int year )
  : DateTime(year, month, date, 0, 0, 0, 0) {}

  LocalDate( long sec )
  : DateTime( sec / DateTime::SECONDS_PER_DAY, 0 ) {}

  LocalDate( const tm* time )
  : DateTime( fromTm (*time) )
  {
    clearTime();
  }

  void setCurrent()
  {
    DateTime d = nowLocal();
    m_date = d.m_date;
  }
};

typedef UtcDate UtcDateOnly;

typedef std::string FIX_STRING;
typedef char FIX_CHAR;
typedef double FIX_PRICE;
typedef int FIX_INT;
typedef double FIX_AMT;
typedef double FIX_QTY;
typedef std::string FIX_CURRENCY;
typedef std::string FIX_MULTIPLEVALUESTRING;
typedef std::string FIX_MULTIPLESTRINGVALUE;
typedef std::string FIX_MULTIPLECHARVALUE;
typedef std::string FIX_EXCHANGE;
typedef UtcTimeStamp FIX_UTCTIMESTAMP;
typedef bool FIX_BOOLEAN;
typedef std::string FIX_LOCALMKTDATE;
typedef std::string FIX_DATA;
typedef double FIX_FLOAT;
typedef double FIX_PRICEOFFSET;
typedef std::string FIX_MONTHYEAR;
typedef std::string FIX_DAYOFMONTH;
typedef UtcDate FIX_UTCDATE;
typedef UtcDateOnly FIX_UTCDATEONLY;
typedef UtcTimeOnly FIX_UTCTIMEONLY;
typedef int FIX_NUMINGROUP;
typedef double FIX_PERCENTAGE;
typedef int FIX_SEQNUM;
typedef int FIX_LENGTH;
typedef std::string FIX_COUNTRY;
typedef std::string FIX_TZTIMEONLY;
typedef std::string FIX_TZTIMESTAMP;

namespace TYPE
{
enum Type
{
  Unknown,
  String,
  Char,
  Price,
  Int,
  Amt,
  Qty,
  Currency,
  MultipleValueString,
  MultipleStringValue,
  MultipleCharValue,
  Exchange,
  UtcTimeStamp,
  Boolean,
  LocalMktDate,
  Data,
  Float,
  PriceOffset,
  MonthYear,
  DayOfMonth,
  UtcDate,
  UtcDateOnly = UtcDate,
  UtcTimeOnly,
  NumInGroup,
  Percentage,
  SeqNum,
  Length,
  Country,
  TzTimeOnly,
  TzTimeStamp
};
}
}

#endif //FIX_FIELDTYPES_H