/////////////////////////////////////////////////////////////////////////////// 
// Copyright (C) 2002-2016, Open Design Alliance (the "Alliance"). 
// All rights reserved. 
// 
// This software and its documentation and related materials are owned by 
// the Alliance. The software may only be incorporated into application 
// programs owned by members of the Alliance, subject to a signed 
// Membership Agreement and Supplemental Software License Agreement with the
// Alliance. The structure and organization of this software are the valuable  
// trade secrets of the Alliance and its suppliers. The software is also 
// protected by copyright law and international treaty provisions. Application  
// programs incorporating this software must include the following statement 
// with their copyright notices:
//   
//   This application incorporates Teigha(R) software pursuant to a license 
//   agreement with Open Design Alliance.
//   Teigha(R) Copyright (C) 2002-2016 by Open Design Alliance. 
//   All rights reserved.
//
// By use of this software, its documentation or related materials, you 
// acknowledge and accept the above terms.
///////////////////////////////////////////////////////////////////////////////


#ifndef _OD_PLATFORMSTREAMER_H_
#define _OD_PLATFORMSTREAMER_H_

#include "OdPlatform.h"
#include "OdStreamBuf.h"
#include "DbHandle.h"
#include "OdString.h"

/** \details
    This class implements platform dependent stream I/O for various data types.
    <group Other_Classes>
*/
class OdPlatformStreamer
{
public:
  /** \details
    Reads a 16-bit integer from the specified StreamBuf object.
    \param streamBuf [in]  StreamBuf object from which the data are to be read.
  */
  static OdInt16    rdInt16   (OdStreamBuf& streamBuf);
  /** \details
    Reads a 32-bit integer from the specified StreamBuf object.
    \param streamBuf [in]  StreamBuf object from which the data are to be read.
  */
  static OdInt32    rdInt32   (OdStreamBuf& streamBuf);
  /** \details
    Reads a 64-bit integer from the specified StreamBuf object.
    \param streamBuf [in]  StreamBuf object from which the data are to be read.
  */
  static OdInt64    rdInt64   (OdStreamBuf& streamBuf);
  /** \details
    Reads a 32-bit floating point number from the specified StreamBuf object.
    \param streamBuf [in]  StreamBuf object from which the data are to be read.
  */
  static float      rdFloat   (OdStreamBuf& streamBuf);
  /** \details
    Reads a double from the specified StreamBuf object.
    \param streamBuf [in]  StreamBuf object from which the data are to be read.
  */
  static double     rdDouble  (OdStreamBuf& streamBuf);
  /** \details
    Reads a handle from the specified StreamBuf object.
    \param streamBuf [in]  StreamBuf object from which the data are to be read.
  */
  static OdDbHandle rdDbHandle(OdStreamBuf& streamBuf);
  /** \details
    Reads two doubles from the specified StreamBuf object.
    \param streamBuf [in]  StreamBuf object from which the data are to be read.
    \param doubles [out]  Array of doubles to receive the data.
  */
  static void       rd2Doubles(OdStreamBuf& streamBuf, void* doubles);

  /** \details
    Reads three doubles from the specified StreamBuf object.
    \param streamBuf [in]  StreamBuf object from which the data are to be read.
    \param doubles [out]  Array of doubles to receive the data.
  */
  static void       rd3Doubles(OdStreamBuf& streamBuf, void* doubles);
  
  /** \details
    Reads the specified number of doubles from the specified StreamBuf object.
    \param streamBuf [in]  StreamBuf object from which the data are to be read.
    \param doubles [out]  Array of doubles to receive the data.
    \param numDoubles [in]  Number of doubles.
  */
  static void       rdDoubles (OdStreamBuf& streamBuf, int numDoubles, void* doubles);

  /** \details
    Writes a 16-bit integer to the specified StreamBuf object.
    \param streamBuf [out]  StreamBuf object to which the data are to be written.
    \param value [in]  Value to be written.
  */
  static void       wrInt16   (OdStreamBuf& streamBuf, OdInt16 value);
  /** \details
    Writes a 32-bit integer to the specified StreamBuf object.
    \param streamBuf [out]  StreamBuf object to which the data are to be written.
    \param value [in]  Value to be written.
  */
  static void       wrInt32   (OdStreamBuf& streamBuf, OdInt32 value);
  /** \details
    Writes a 64-bit integer to the specified StreamBuf object.
    \param streamBuf [out]  StreamBuf object to which the data are to be written.
    \param value [in]  Value to be written.
  */
  static void       wrInt64   (OdStreamBuf& streamBuf, OdInt64 value);
  /** \details
    Writes a 32-bit floating point number to the specified StreamBuf object.
    \param streamBuf [out]  StreamBuf object to which the data are to be written.
    \param value [in]  Value to be written.
  */
  static void       wrFloat   (OdStreamBuf& out, float val);
  /** \details
    Writes a double to the specified StreamBuf object.
    \param streamBuf [out]  StreamBuf object to which the data are to be written.
    \param value [in]  Value to be written.
  */
  static void       wrDouble  (OdStreamBuf& streamBuf, double value);
  /** \details
    Writes a handle to the specified StreamBuf object.
    \param streamBuf [out]  StreamBuf object to which the data are to be written.
    \param value [in]  Value to be written.
  */
  static void       wrDbHandle(OdStreamBuf& streamBuf, OdDbHandle value);
  /** \details
    Writes two doubles to the specified StreamBuf object.
    \param streamBuf [out]  StreamBuf object to which the data are to be written.
    \param doubles [in]  Array of doubles to be written.
  */
  static void       wr2Doubles(OdStreamBuf& streamBuf, const void* doubles);
  /** \details
    Writes three doubles to the specified StreamBuf object.
    \param streamBuf [out]  StreamBuf object to which the data are to be written.
    \param doubles [in]  Array of doubles to be written.
  */
  static void       wr3Doubles(OdStreamBuf& streamBuf, const void* doubles);
  /** \details
    Writes the specified number of doubles to the specified StreamBuf object.
    \param streamBuf [out]  StreamBuf object to which the data are to be written.
    \param doubles [in]  Array of doubles to be written.
    \param numDoubles [in]  Number of doubles.
  */
  static void       wrDoubles (OdStreamBuf& streamBuf, int numDoubles, const void* doubles);

  /** \details
      Extracts a Unicode string from buffer, and returns it as an OdString.

      \param buffer [in/out] Buffer pointer to read the Unicode string from.
      \param size [in] Length of the Unicode string in characters (assumes 2 byte characters in buffer
               stored in little endian format), or -1 if the string is null terminated.

      \remarks
      The buffer pointer is incremented to the next byte past the string that
      was read in.  If size is > 0, size * 2 bytes will be read.  If size is -1,
      a null terminated string will be read from buffer, including the null byte.
  */
  inline static OdString getUnicodeStrFromBuffer(const OdUInt8*& buffer, OdInt32 size);

  /** \details
      Writes a Unicode string to the passed in buffer, in little endian format, 
      using 2 bytes per character.  The trailing null character is NOT written.

      \param val [in]  Unicode string to be written.
      \param buffer [in]  Char buffer to which will receive the Unicode data.

      \remarks
      The buffer pointer is incremented to the next byte past the string that
      was written. 
  */
  inline static void putUnicodeStrToBuffer(const OdString& val, OdUInt8*& buffer);

};

inline OdInt16 OdPlatformStreamer::rdInt16(OdStreamBuf& streamBuf)
{
  OdInt16 res;
  streamBuf.getBytes(&res, sizeof(res));
  odSwap2BytesNumber(res);
  return res;
}
inline OdInt32 OdPlatformStreamer::rdInt32(OdStreamBuf& streamBuf)
{
  OdInt32 res;
  streamBuf.getBytes(&res, sizeof(res));
  odSwap4BytesNumber(res);
  return res;
}
inline OdInt64 OdPlatformStreamer::rdInt64(OdStreamBuf& streamBuf)
{
  OdInt64 res;
  streamBuf.getBytes(&res, sizeof(res));
  odSwap8Bytes(&res);
  return res;
}
inline float OdPlatformStreamer::rdFloat(OdStreamBuf& streamBuf)
{
  float res;
  streamBuf.getBytes(&res, sizeof(res));
  odSwap4Bytes(&res);
  return res;
}
inline double OdPlatformStreamer::rdDouble(OdStreamBuf& streamBuf)
{
  double res;
  ODA_ASSUME(sizeof(res) == 8)
  streamBuf.getBytes(&res, 8);
  odSwap8Bytes(&res);
  // if unnormalized or NaN or infinity, set it to 0.0
  if (!isValidNonZeroIEEEDouble((OdUInt8 *)&res))
    return 0.0;
  return res;
}
inline OdDbHandle OdPlatformStreamer::rdDbHandle(OdStreamBuf& streamBuf)
{
  OdDbHandle res;
  ODA_ASSUME(sizeof(res) == 8)
  streamBuf.getBytes(&res, 8);
  odSwapInt64(&res);
  return res;
}
inline void OdPlatformStreamer::rd2Doubles(OdStreamBuf& streamBuf, void* pRes2Doubles)
{
  ODA_ASSUME(sizeof(double) == 8)
  streamBuf.getBytes(pRes2Doubles, sizeof(double)*2);
  fixDouble((double*)pRes2Doubles);
  fixDouble((double*)pRes2Doubles+1);
}
inline void OdPlatformStreamer::rd3Doubles(OdStreamBuf& streamBuf, void* pRes3Doubles)
{
  ODA_ASSUME(sizeof(double) == 8)
  streamBuf.getBytes(pRes3Doubles, sizeof(double)*3);
  fixDouble((double*)pRes3Doubles);
  fixDouble((double*)pRes3Doubles+1);
  fixDouble((double*)pRes3Doubles+2);
}
inline void OdPlatformStreamer::rdDoubles(OdStreamBuf& streamBuf, int n, void* pResDoubles)
{
  ODA_ASSUME(sizeof(double) == 8)
  streamBuf.getBytes(pResDoubles, sizeof(double)*n);
  double* pD = (double*)pResDoubles;
  while (n--) { fixDouble(pD++); }
}

inline void OdPlatformStreamer::wrInt16(OdStreamBuf& streamBuf, OdInt16 val)
{
  odSwap2BytesNumber(val);
  streamBuf.putBytes(&val, sizeof(val));
}
inline void OdPlatformStreamer::wrInt32(OdStreamBuf& streamBuf, OdInt32 val)
{
  odSwap4BytesNumber(val);
  streamBuf.putBytes(&val, sizeof(val));
}
inline void OdPlatformStreamer::wrInt64(OdStreamBuf& streamBuf, OdInt64 val)
{
  odSwap8Bytes(&val);
  streamBuf.putBytes(&val, sizeof(val));
}
inline void OdPlatformStreamer::wrFloat(OdStreamBuf& streamBuf, float val)
{
  odSwap4Bytes(&val);
  streamBuf.putBytes(&val, sizeof(val));
}
inline void OdPlatformStreamer::wrDouble(OdStreamBuf& streamBuf, double val)
{
  ODA_ASSUME(sizeof(double) == 8)
  odSwap8Bytes(&val);
  streamBuf.putBytes(&val, sizeof(val));
}
inline void OdPlatformStreamer::wrDbHandle(OdStreamBuf& streamBuf, OdDbHandle val)
{
  odSwapInt64(&val);
  streamBuf.putBytes(&val, sizeof(val));
}

inline OdString OdPlatformStreamer::getUnicodeStrFromBuffer(const OdUInt8*& buffer, OdInt32 size)
{
  OdString ret;
#if ODCHAR_IS_INT16LE
  if (size == -1)
  {
    // null terminated
    ret = (OdChar*)buffer;
    buffer += ((ret.getLength() + 1) * 2);
  }
  else
  {
    OdUInt8* pBuf = (OdUInt8*)ret.getBuffer(size+1);
    OD_BYTES_FROM_BUFFPTR(buffer, pBuf, (size<<1));
    ret.releaseBuffer(size);
  }
#else
  OdInt32 finalSize = size;
  if (size == -1)
  {
    // null terminated
    size = 1; 
    OdUInt16* tmp16 = (OdUInt16*)buffer;
    for ( ; *tmp16; tmp16++)
      size++;
    finalSize = size - 1;
  }
  OdChar* pBuf = ret.getBuffer(size + 1);
  for (OdInt32 i = 0; i < size; i++)
  {
    *pBuf++ = OdUInt16(OD_INT16_FROM_BUFFPTR(buffer));
  }
  *pBuf = L'\0';
  ret.releaseBuffer(finalSize);
#endif

  return ret;
}

#ifndef ODCHAR_IS_INT16LE
#error "OdaDefs.h must be included before OdPlatformStreamer.h"
#endif

void OdPlatformStreamer::putUnicodeStrToBuffer(const OdString& val, OdUInt8*& buffer)
{
  OdInt32 nLen = val.getLength();
#if ODCHAR_IS_INT16LE
  OD_BYTES_TO_BUFFPTR(buffer, val.c_str(), nLen*sizeof(OdChar));
#else
  const OdChar* p = val.c_str();
  for (OdUInt32 i = 0; i < nLen; i++)
  {
    OD_INT16_TO_BUFFPTR(buffer, (OdInt16)*p++);
  }
#endif
}


// Verify that preprocessor symbol ODCHAR_IS_INT16LE has been correctly defined
#if ODCHAR_IS_INT16LE
#ifdef ODA_BIGENDIAN
#error "ODCHAR_IS_INT16LE is defined for a big endian platform"
#endif
ODA_ASSUME(sizeof(OdChar) == 2);
#endif


#ifdef ODA_BIGENDIAN

inline void OdPlatformStreamer::wr2Doubles(OdStreamBuf& streamBuf, const void* p2Doubles)
{
  wrDouble(streamBuf, *(((double*)p2Doubles)+0));
  wrDouble(streamBuf, *(((double*)p2Doubles)+1));
}
inline void OdPlatformStreamer::wr3Doubles(OdStreamBuf& streamBuf, const void* p3Doubles)
{
  wrDouble(streamBuf, *(((double*)p3Doubles)+0));
  wrDouble(streamBuf, *(((double*)p3Doubles)+1));
  wrDouble(streamBuf, *(((double*)p3Doubles)+2));
}
inline void OdPlatformStreamer::wrDoubles(OdStreamBuf& streamBuf, int n, const void* pDoubles)
{
  while(n--) wrDouble(streamBuf, ((double*)pDoubles)[n]);
}

#else // #ifdef ODA_BIGENDIAN

inline void OdPlatformStreamer::wr2Doubles(OdStreamBuf& streamBuf, const void* p2Doubles)
{
  ODA_ASSUME(sizeof(double) == 8)
  streamBuf.putBytes(p2Doubles, sizeof(double)*2);
}
inline void OdPlatformStreamer::wr3Doubles(OdStreamBuf& streamBuf, const void* p3Doubles)
{
  ODA_ASSUME(sizeof(double) == 8)
  streamBuf.putBytes(p3Doubles, sizeof(double)*3);
}
inline void OdPlatformStreamer::wrDoubles(OdStreamBuf& streamBuf, int n, const void* pDoubles)
{
  ODA_ASSUME(sizeof(double) == 8)
  streamBuf.putBytes(pDoubles, sizeof(double) * n);
}

#endif // ODA_BIGENDIAN

#endif // _OD_PLATFORMSTREAMER_H_