f8utils.hpp

Go to the documentation of this file.

//-----------------------------------------------------------------------------------------
/*

Fix8 is released under the GNU LESSER GENERAL PUBLIC LICENSE Version 3.

Fix8 Open Source FIX Engine.
Copyright (C) 2010-16 David L. Dight <fix@fix8.org>

Fix8 is free software: you can  redistribute it and / or modify  it under the  terms of the
GNU Lesser General  Public License as  published  by the Free  Software Foundation,  either
version 3 of the License, or (at your option) any later version.

Fix8 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.

You should  have received a copy of the GNU Lesser General Public  License along with Fix8.
If not, see <http://www.gnu.org/licenses/>.

BECAUSE THE PROGRAM IS  LICENSED FREE OF  CHARGE, THERE IS NO  WARRANTY FOR THE PROGRAM, TO
THE EXTENT  PERMITTED  BY  APPLICABLE  LAW.  EXCEPT WHEN  OTHERWISE  STATED IN  WRITING THE
COPYRIGHT HOLDERS AND/OR OTHER PARTIES  PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY OF ANY
KIND,  EITHER EXPRESSED   OR   IMPLIED,  INCLUDING,  BUT   NOT  LIMITED   TO,  THE  IMPLIED
WARRANTIES  OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.  THE ENTIRE RISK AS TO
THE QUALITY AND PERFORMANCE OF THE PROGRAM IS WITH YOU. SHOULD THE PROGRAM PROVE DEFECTIVE,
YOU ASSUME THE COST OF ALL NECESSARY SERVICING, REPAIR OR CORRECTION.

IN NO EVENT UNLESS REQUIRED  BY APPLICABLE LAW  OR AGREED TO IN  WRITING WILL ANY COPYRIGHT
HOLDER, OR  ANY OTHER PARTY  WHO MAY MODIFY  AND/OR REDISTRIBUTE  THE PROGRAM AS  PERMITTED
ABOVE,  BE  LIABLE  TO  YOU  FOR  DAMAGES,  INCLUDING  ANY  GENERAL, SPECIAL, INCIDENTAL OR
CONSEQUENTIAL DAMAGES ARISING OUT OF THE USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT
NOT LIMITED TO LOSS OF DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR
THIRD PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER PROGRAMS), EVEN IF SUCH
HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.

*/
//-----------------------------------------------------------------------------------------
#ifndef FIX8_UTILS_HPP_
#define FIX8_UTILS_HPP_

//-----------------------------------------------------------------------------------------
#include <iostream>
#include <string>
#include <memory>
#include <mutex>

#include <Poco/DateTime.h>
#include <Poco/Net/SocketAddress.h>

#ifndef _MSC_VER
# include <sys/ioctl.h>
# include <termios.h>
#else
# include <io.h>
#endif

#if (FIX8_REGEX_SYSTEM == FIX8_REGEX_REGEX_H)
#include <regex.h>
#elif (FIX8_REGEX_SYSTEM == FIX8_REGEX_POCO)
#include <Poco/RegularExpression.h>
#include <Poco/Exception.h>
#endif

#include <fix8/f8dll.h>

// file/line stringification
#define STRINGOF(x) #x
#define STRINGIFY(x) STRINGOF(x)
#define FILE_LINE __FILE__ ":" STRINGIFY(__LINE__)

namespace FIX8 {

//----------------------------------------------------------------------------------------
F8API std::string& InPlaceStrToUpper(std::string& src);

F8API std::string& InPlaceStrToLower(std::string& src);

F8API std::string StrToLower(const std::string& src);

F8API int decode_dow(const std::string& from);

F8API std::string& CheckAddTrailingSlash(std::string& source);

F8API std::string& InPlaceReplaceInSet(const std::string& iset, std::string& src, const char repl='_');

F8API std::string Str_error(const int err, const char *str=0);

F8API const std::string& GetTimeAsStringMS(std::string& result, const class Tickval *tv=0, const unsigned dplaces=6, bool use_gm=false);

inline std::string GetTimeAsStringMS(const class Tickval *tv, const unsigned dplaces=6, bool use_gm=false)
{
   std::string result;
   GetTimeAsStringMS(result, tv, dplaces, use_gm);
   return result;
}

F8API const std::string& GetTimeAsStringMini(std::string& result, const Tickval *tv);

inline std::string GetTimeAsStringMini(const Tickval *tv)
{
   std::string result;
   GetTimeAsStringMini(result, tv);
   return result;
}

inline std::string trim(const std::string& source, const std::string& ws=" \t")
{
    const size_t bgstr(source.find_first_not_of(ws));
    return bgstr == std::string::npos
       ? source : source.substr(bgstr, source.find_last_not_of(ws) - bgstr + 1);
}

inline const std::string& trim(std::string& source, const std::string& ws=" \t")
{
    const size_t bgstr(source.find_first_not_of(ws));
    return bgstr == std::string::npos
       ? source : source = source.substr(bgstr, source.find_last_not_of(ws) - bgstr + 1);
}

//----------------------------------------------------------------------------------------
using Package_info = std::map<f8String, f8String>;

F8API const Package_info& package_info();

F8API f8String find_package_info_string(const f8String& what);

//----------------------------------------------------------------------------------------
template<typename T>
inline void ignore_value (T val) { (void) val; }

template<typename T>
inline void ignore_value (T *val) { (void) val; }

//----------------------------------------------------------------------------------------
template<typename T>
inline T rotl(const T val, const int times) { return val << times | val >> (sizeof(T) * 8 - times); }

template<typename T>
inline T rotr(const T val, const int times) { return val >> times | val << (sizeof(T) * 8 - times); }

inline unsigned ROT13Hash (const std::string& str)
{
   unsigned int hash(0);

   for (const auto& pp : str)
   {
      hash += pp;
      hash -= rotl(hash, 13);
   }

   return hash;
}

//-------------------------------------------------------------------------------------------------
inline unsigned rothash(unsigned result, unsigned value)
{
   // hash derived from http://stackoverflow.com/users/905902/wildplasser
   return result ^= (result >> 2) ^ (result << 5) ^ (result << 13) ^ value ^ 0x80001801;
}

//----------------------------------------------------------------------------------------
template<typename _CharT, typename _Traits, typename _Alloc>
   inline bool operator% (const std::basic_string<_CharT, _Traits, _Alloc>& __lhs,
      const std::basic_string<_CharT, _Traits, _Alloc>& __rhs)
{
#ifdef _MSC_VER
   return _stricmp(__lhs.c_str(), __rhs.c_str()) == 0;
#else
   return strcasecmp(__lhs.c_str(), __rhs.c_str()) == 0;
#endif
}

template<typename _CharT, typename _Traits, typename _Alloc>
   inline bool operator% (const _CharT* __lhs, const std::basic_string<_CharT, _Traits, _Alloc>& __rhs)
      { return strcasecmp(__lhs, __rhs.c_str()) == 0; }

template<typename _CharT, typename _Traits, typename _Alloc>
   inline bool operator% (const std::basic_string<_CharT, _Traits, _Alloc>& __lhs, const _CharT* __rhs)
{
#ifdef _MSC_VER
   return _stricmp(__lhs.c_str(), __rhs) == 0;
#else
   return strcasecmp(__lhs.c_str(), __rhs) == 0;
#endif
}

template<typename _CharT, typename _Traits, typename _Alloc>
inline bool operator^ (const std::basic_string<_CharT, _Traits, _Alloc>& __lhs,
   const std::basic_string<_CharT, _Traits, _Alloc>& __rhs)
{
#ifdef _MSC_VER
   return _stricmp(__lhs.c_str(), __rhs.c_str()) < 0;
#else
   return strcasecmp(__lhs.c_str(), __rhs.c_str()) < 0;
#endif
}

//----------------------------------------------------------------------------------------
F8API void create_path(const std::string& path);

//----------------------------------------------------------------------------------------
class RegMatch
{
#if FIX8_REGEX_SYSTEM == FIX8_REGEX_REGEX_H
   enum { SubLimit_ = 32 };
   regmatch_t subexprs_[SubLimit_];
   int subCnt_;
#elif FIX8_REGEX_SYSTEM == FIX8_REGEX_POCO
   Poco::RegularExpression::MatchVec _matchVec;
#endif

public:
   RegMatch()
#if FIX8_REGEX_SYSTEM == FIX8_REGEX_REGEX_H
      : subexprs_(), subCnt_()
#endif
    {}

   virtual ~RegMatch() {}

   unsigned SubCnt() const
   {
#if FIX8_REGEX_SYSTEM == FIX8_REGEX_REGEX_H
      return subCnt_;
#elif FIX8_REGEX_SYSTEM == FIX8_REGEX_POCO
      return static_cast<unsigned>(_matchVec.size());
#endif
   }

   size_t SubSize(const int which=0) const
   {
#if FIX8_REGEX_SYSTEM == FIX8_REGEX_REGEX_H
      return which < subCnt_ ? subexprs_[which].rm_eo - subexprs_[which].rm_so : -1;
#elif FIX8_REGEX_SYSTEM == FIX8_REGEX_POCO
      return which < static_cast<int>(_matchVec.size()) ? _matchVec[which].length : -1;
#endif
   }

   unsigned SubPos(const int which=0) const
   {
#if FIX8_REGEX_SYSTEM == FIX8_REGEX_REGEX_H
      return which < subCnt_ ? subexprs_[which].rm_so : -1;
#elif FIX8_REGEX_SYSTEM == FIX8_REGEX_POCO
      return which < static_cast<int>(_matchVec.size()) ? static_cast<int>(_matchVec[which].offset) : -1;
#endif
   }

   friend class RegExp;
};

//----------------------------------------------------------------------------------------
class RegExp
{
   const std::string pattern_;
#if FIX8_REGEX_SYSTEM == FIX8_REGEX_REGEX_H
   enum { MaxErrLen_ = 256 };

   regex_t reg_;
#elif FIX8_REGEX_SYSTEM == FIX8_REGEX_POCO
   Poco::RegularExpression * _regexp;
#endif
   std::string errString;
   int errCode_;

public:
   RegExp(const char *pattern, const int flags=0)
#if FIX8_REGEX_SYSTEM == FIX8_REGEX_REGEX_H
      : pattern_(pattern)
   {
      if ((errCode_ = regcomp(&reg_, pattern_.c_str(), REG_EXTENDED|flags)) != 0)
      {
         char rbuf[MaxErrLen_];
         regerror(errCode_, &reg_, rbuf, MaxErrLen_);
         errString = rbuf;
      }
   }
#elif FIX8_REGEX_SYSTEM == FIX8_REGEX_POCO
      : pattern_(pattern), _regexp()
   {
      try
      {
         _regexp = new Poco::RegularExpression(pattern, flags, true);
      }
      catch(const Poco::RegularExpressionException& ex)
      {
         errCode_ = ex.code();
         errString = ex.message();
      }
   }
#endif

   virtual ~RegExp()
   {
#if FIX8_REGEX_SYSTEM == FIX8_REGEX_REGEX_H
      if (errCode_ == 0)
         regfree(&reg_);
#elif FIX8_REGEX_SYSTEM == FIX8_REGEX_POCO
      delete _regexp;
#endif
   }

   int SearchString(RegMatch& match, const std::string& source, const int subExpr, const int offset=0) const
   {
#if FIX8_REGEX_SYSTEM == FIX8_REGEX_REGEX_H
      match.subCnt_ = 0;
      if (regexec(&reg_, source.c_str() + offset, subExpr <= RegMatch::SubLimit_ ? subExpr : RegMatch::SubLimit_, match.subexprs_, 0) == 0)
         while (match.subCnt_ < subExpr && match.subexprs_[match.subCnt_].rm_so != -1)
            ++match.subCnt_;
      return match.subCnt_;
#elif FIX8_REGEX_SYSTEM == FIX8_REGEX_POCO
      match._matchVec.clear();
      return _regexp ? _regexp->match(source, offset, match._matchVec) : 0;
#endif
   }

   static std::string& SubExpr(RegMatch& match, const std::string& source, std::string& target, const int offset=0, const int num=0)
   {
#if FIX8_REGEX_SYSTEM == FIX8_REGEX_REGEX_H
      if (num < match.subCnt_)
         target = source.substr(offset + match.subexprs_[num].rm_so, match.subexprs_[num].rm_eo - match.subexprs_[num].rm_so);
#elif FIX8_REGEX_SYSTEM == FIX8_REGEX_POCO
      if (num < static_cast<int>(match.SubCnt()))
         target = source.substr(offset + match.SubPos(num), match.SubSize(num));
#endif
      else
         target.empty();
      return target;
   }

   static std::string& Erase(RegMatch& match, std::string& source, const int num=0)
   {
#if FIX8_REGEX_SYSTEM == FIX8_REGEX_REGEX_H
      if (num < match.subCnt_)
         source.erase(match.subexprs_[num].rm_so, match.subexprs_[num].rm_eo - match.subexprs_[num].rm_so);
#elif FIX8_REGEX_SYSTEM == FIX8_REGEX_POCO
      if (num < static_cast<int>(match.SubCnt()))
         source.erase(match.SubPos(num), match.SubSize(num));
#endif
      return source;
   }

   static std::string& Replace(RegMatch& match, std::string& source, const std::string& with, const int num=0)
   {
#if FIX8_REGEX_SYSTEM == FIX8_REGEX_REGEX_H
      if (num < match.subCnt_)
         source.replace(match.subexprs_[num].rm_so, match.subexprs_[num].rm_eo - match.subexprs_[num].rm_so, with);
#elif FIX8_REGEX_SYSTEM == FIX8_REGEX_POCO
      if (num < static_cast<int>(match.SubCnt()))
         source.replace(match.SubPos(num), match.SubSize(num), with);
#endif
      return source;
   }

   static std::string& Replace(RegMatch& match, std::string& source, const char with, const int num=0)
   {
#if FIX8_REGEX_SYSTEM == FIX8_REGEX_REGEX_H
      if (num < match.subCnt_)
         source.replace(match.subexprs_[num].rm_so, match.subexprs_[num].rm_eo - match.subexprs_[num].rm_so, 1, with);
#elif FIX8_REGEX_SYSTEM == FIX8_REGEX_POCO
      if (num < static_cast<int>(match.SubCnt()))
         source.replace(match.SubPos(num), match.SubSize(num), 1, with);
#endif
      return source;
   }

   const std::string& GetPattern() const { return pattern_; }

   const std::string& ErrString() const { return errString; }

   bool operator!() const { return errCode_; }

   operator void*() { return errCode_ ? 0 : this; }
};

//----------------------------------------------------------------------------------------
struct StringPtrLessThanNoCase
{
   bool operator()(const std::string *a, const std::string *b) const
      { return *a ^ *b; }
};

struct StringPtrLessThan
{
   bool operator()(const std::string *a, const std::string *b) const
      { return *a < *b; }
};

struct StringLessThanNoCase
{
   bool operator()(const std::string& a, const std::string& b) const
      { return a ^ b; }
};

//----------------------------------------------------------------------------------------
template<typename T>
inline T get_value(const std::string& source)
{
   std::istringstream istr(source);
   T result((T()));
   istr >> result;
   return result;
}

template<>
inline unsigned get_value(const std::string& source) { return std::stoul(source); }

template<>
inline int get_value(const std::string& source) { return std::stoi(source); }

template<>
inline double get_value(const std::string& source) { return std::stod(source); }

template<>
inline float get_value(const std::string& source) { return std::stof(source); }

template<>
inline bool get_value(const std::string& source)
{
   if (source.empty())
      return false;
#if !defined FIX8_XMLENTITY_STRICT_BOOL
   return source % "true" || source % "yes" || source % "y" || source == "1";
#else
   bool result(false);
   std::istringstream istr(source);
   istr >> std::boolalpha >> result;
   return result;
#endif
}

//----------------------------------------------------------------------------------------
template<typename T>
T fast_atoi(const char *str, const char term='\0')
{
   T retval(0);
   for (; *str != term; ++str)
      retval = (retval << 3) + (retval << 1) + *str - '0';
   return retval;
}

//----------------------------------------------------------------------------------------

template<typename T>
inline size_t itoa(T value, char *result, int base)
{
   // check that the base if valid
   if (base < 2 || base > 36)
   {
      *result = 0;
      return 0;
   }

   char *ptr(result), *ptr1(result);
   T tmp_value;

   do
   {
      tmp_value = value;
      value /= base;
      *ptr++ = "zyxwvutsrqponmlkjihgfedcba9876543210123456789abcdefghijklmnopqrstuvwxyz" [35 + (tmp_value - value * base)];
   }
   while (value);

   // Apply negative sign
   if (tmp_value < 0)
      *ptr++ = '-';
   *ptr-- = 0;
   while(ptr1 < ptr)
   {
      const char tmp_char(*ptr);
      *ptr-- = *ptr1;
      *ptr1++ = tmp_char;
   }
   return ::strlen(result);
}


template<>
inline size_t itoa<unsigned int>(unsigned int value, char *result, int base)
{
   // check that the base if valid
   if (base < 2 || base > 36)
   {
      *result = 0;
      return 0;
   }

   char *ptr(result), *ptr1(result);
   unsigned int tmp_value;

   do
   {
      tmp_value = value;
      value /= base;
      *ptr++ = "zyxwvutsrqponmlkjihgfedcba9876543210123456789abcdefghijklmnopqrstuvwxyz" [35 + (tmp_value - value * base)];
   }
   while (value);

   *ptr-- = 0;
   while(ptr1 < ptr)
   {
      const char tmp_char(*ptr);
      *ptr-- = *ptr1;
      *ptr1++ = tmp_char;
   }
   return ::strlen(result);
}

//----------------------------------------------------------------------------------------
inline fp_type fast_atof (const char *p)
{
   bool frac(false);
   fp_type sign(1.), value(0.), scale(1.);

   while (isspace(*p))
      ++p;

   // Get sign, if any.
   if (*p == '-')
   {
      sign = -1.;
      ++p;
   }
   else if (*p == '+')
      ++p;

   // Get digits before decimal point or exponent, if any.
   while (isdigit(*p))
   {
      value = value * 10. + (*p - '0');
      ++p;
   }

   // Get digits after decimal point, if any.
   if (*p == '.')
   {
      ++p;
      fp_type mpow10(10.);
      while (isdigit(*p))
      {
         value += (*p - '0') / mpow10;
         mpow10 *= 10.;
         ++p;
      }
   }

   // Handle exponent, if any.
   if (toupper(*p) == 'E')
   {
      unsigned int expon(0);
      ++p;

   // Get sign of exponent, if any.
      if (*p == '-')
      {
         frac = true;
         ++p;
      }
      else if (*p == '+')
         ++p;

   // Get digits of exponent, if any.
      while (isdigit(*p))
      {
         expon = expon * 10 + (*p - '0');
         ++p;
      }
#if defined FIX8_USE_SINGLE_PRECISION
      if (expon > 38)
         expon = 38;
#else
      if (expon > 308)
         expon = 308;

   // Calculate scaling factor.
      while (expon >= 50)
      {
         scale *= 1E50;
         expon -= 50;
      }
#endif

      while (expon >= 8)
      {
         scale *= 1E8;
         expon -=  8;
      }
      while (expon > 0)
      {
         scale *= 10.0;
         expon -=  1;
      }
   }

   // Return signed and scaled floating point result.
   return sign * (frac ? (value / scale) : (value * scale));
}

//----------------------------------------------------------------------------------------

extern "C" { size_t modp_dtoa(double value, char* str, int prec); }

//----------------------------------------------------------------------------------------
#ifndef _MSC_VER
constexpr unsigned bitsum() { return 0; }

template <typename T, typename... Args>
constexpr unsigned bitsum(T value, Args... args)
   { return 1 << value | bitsum(args...); }
#endif

//----------------------------------------------------------------------------------------

template<typename T, typename B=unsigned int>
class ebitset
{
   using integral_type = B;
   integral_type a_;

public:
   ebitset() : a_() {}

   ebitset(const ebitset<T, B>& from) : a_(from.a_) {}

   explicit ebitset(const integral_type a) : a_(a) {}

   explicit ebitset(const T sbit) : a_((1 << sbit) - 1) {}

   ebitset<T, B>& operator=(const ebitset<T, B>& that)
   {
      if (this != &that)
         a_ = that.a_;
      return *this;
   }

   integral_type has(const T sbit) const { return a_ & 1 << sbit; }

   integral_type operator&(const T sbit) const { return a_ & 1 << sbit; }

   void set(const T sbit, bool on=true) { if (on) a_ |= 1 << sbit; else a_ &= ~(1 << sbit); }

   void set(const integral_type bset) { a_ = bset; }

   int set(const std::vector<std::string>& sset, const std::string& what, bool ignorecase, bool on=true)
   {
      auto itr(sset.cbegin());
      for (; itr != sset.cend(); ++itr)
         if (ignorecase ? trim(*itr) % what : trim(*itr) == what)
            break;
      if (itr == sset.cend())
         return -1;
      const int dist(std::distance(sset.cbegin(), itr));
      set(static_cast<T>(dist), on);
      return dist;
   }

   void clear(const T sbit) { a_ &= ~(1 << sbit); }

   void clearall() { a_ = 0; }

   void setall(const T sbit) { a_ = (1 << sbit) - 1; }

   integral_type get() const { return a_; }

   void operator|=(const T sbit) { a_ |= 1 << sbit; }

   ebitset& operator<<(const T sbit) { a_ |= 1 << sbit; return *this; }
   //friend ebitset operator|(const T lbit, const T rbit) { return ebitset(lbit) |= 1 << rbit; }
};


template<typename T, typename B=unsigned int>
class ebitset_r
{
   using integral_type = B;
   f8_atomic<integral_type> a_;

public:
   ebitset_r() { a_ = 0; }

   ebitset_r(const ebitset_r<T, B>& from) { a_ = from.a_; }

   explicit ebitset_r(const integral_type a) { a_ = a; }

   explicit ebitset_r(const T sbit) { a_ = (1 << sbit) - 1; }

   ebitset_r<T, B>& operator=(const ebitset_r<T, B>& that)
   {
      if (this != &that)
         a_ = that.a_;
      return *this;
   }

   integral_type has(const T sbit) const { return a_ & 1 << sbit; }

   integral_type operator&(const T sbit) const { return a_ & 1 << sbit; }

   void set(const T sbit, bool on=true) { if (on) a_ |= 1 << sbit; else a_ &= ~(1 << sbit); }

   bool set(const std::vector<std::string>& sset, const std::string& what, bool ignorecase=false, bool on=true)
   {
      auto itr(sset.cbegin());
      for (; itr != sset.cend(); ++itr)
         if (ignorecase ? trim(*itr) % what : trim(*itr) == what)
            break;
      if (itr == sset.cend())
         return false;
      set(static_cast<T>(std::distance(sset.cbegin(), itr)), on);
      return true;
   }

   void set(const integral_type bset) { a_ = bset; }

   void clear(const T sbit) { integral_type a = a_; a &= ~(1 << sbit); a_ = a; }

   void clearall() { a_ = 0; }

   void setall(const T sbit) { a_ = (1 << sbit) - 1; }

   integral_type get() const { return a_; }

   void operator|=(const T sbit) { integral_type a = a_; a |= 1 << sbit; a_ = a; }

   void operator&=(const T sbit) { integral_type a = a_; a &= 1 << sbit; a_ = a; }

   ebitset_r& operator<<(const T sbit) { a_ |= 1 << sbit; return *this; }
};

//----------------------------------------------------------------------------------------
template<typename T>
T enum_str_get(const std::vector<std::string>& sset, const std::string& what, const T def, bool ignorecase=false)
{
   if (sset.empty())
      return def;
   auto itr(sset.cbegin());
   for (; itr != sset.cend(); ++itr)
      if (ignorecase ? *itr % what : *itr == what)
         break;
   return itr == sset.cend() ? def : static_cast<T>(std::distance(sset.begin(), itr));
}

//----------------------------------------------------------------------------------------
F8API int get_umask();

//----------------------------------------------------------------------------------------
inline bool exist(const std::string& fname)
{
#ifdef _MSC_VER
   return _access(fname.c_str(), 0) == 0;
#else
   return access(fname.c_str(), F_OK) == 0;
#endif
}

//-----------------------------------------------------------------------------------------
inline void split_path(const std::string& source, std::string& filepart, std::string& dirpart)
{
   std::string::size_type slpos(source.find_last_of("/\\"));
   if (slpos == std::string::npos)
      filepart = source;
   else
   {
      filepart.assign(source.substr(slpos + 1));
      dirpart.assign(source.substr(0, slpos));
   }
}

//----------------------------------------------------------------------------------------
inline char *CopyString(const std::string& src, char *target, unsigned limit=0)
{
   if (!target)
      return nullptr;
   const unsigned sz(limit && static_cast<unsigned>(src.size()) > limit ? limit : (unsigned)src.size() + 1);
   src.copy(target, sz - 1);
   target[sz - 1] = 0;
   return target;
}

//----------------------------------------------------------------------------------------
template <typename T>
class Singleton
{
public:
   Singleton() {}

   virtual ~Singleton() {}

   Singleton(const Singleton&) = delete;
   Singleton& operator=(const Singleton&) = delete;

   static T *instance()
   {
      static T instance;
      return &instance;
   }
};

//---------------------------------------------------------------------------------------------------
class fdinbuf : public std::streambuf
{
   enum { _back_limit = 4, _buffer_size = 16 };

protected:
   char _buffer[_buffer_size];
   int _fd;

   virtual int_type underflow()
   {
      if (gptr() < egptr())
         return *gptr();
      int put_back_cnt(gptr() - eback());
      if (put_back_cnt > _back_limit)
         put_back_cnt = _back_limit;
      memcpy(_buffer + (_back_limit - put_back_cnt), gptr() - put_back_cnt, put_back_cnt);
#ifdef _MSC_VER
      int num_read(_read (_fd, _buffer + _back_limit, _buffer_size - _back_limit));
#else
      int num_read(read (_fd, _buffer + _back_limit, _buffer_size - _back_limit));
#endif
      if (num_read <= 0)
         return -1;
      setg(_buffer + (_back_limit - put_back_cnt), _buffer + _back_limit, _buffer + _back_limit + num_read);
      return *gptr();
   }

public:
   fdinbuf(int infd) : _buffer(), _fd(infd) { setg(_buffer + _back_limit, _buffer + _back_limit, _buffer + _back_limit); }
};

//---------------------------------------------------------------------------------------------------
class tty_save_state
{
   bool _raw_mode = false;
   int _fd;
#ifndef _MSC_VER
#ifdef __APPLE__
   termios _tty_state;
#else
   termio _tty_state;
#endif
#endif

public:
   explicit tty_save_state(int fd) : _fd(fd) {}

   tty_save_state& operator=(const tty_save_state& from)
   {
      if (&from != this)
      {
         _raw_mode = from._raw_mode;
         _fd = from._fd;
#ifndef _MSC_VER
         _tty_state = from._tty_state;
#endif
      }
      return *this;
   }

   void unset_raw_mode()
   {
      if (_raw_mode)
      {
#ifndef _MSC_VER
#ifdef __APPLE__
         if (ioctl(_fd, TIOCSETA, &_tty_state) < 0)
#else
         if (ioctl(_fd, TCSETA, &_tty_state) < 0)
#endif
            std::cerr << Str_error(errno, "Cannot reset ioctl") << std::endl;
         else
#endif
            _raw_mode = false;
      }
   }

   void set_raw_mode()
   {
      if (!_raw_mode)
      {
#ifndef _MSC_VER
#ifdef __APPLE__
         if (ioctl(_fd, TIOCGETA, &_tty_state) < 0)
#else
         if (ioctl(_fd, TCGETA, &_tty_state) < 0)
#endif
         {
            std::cerr << Str_error(errno, "Cannot get ioctl") << std::endl;
            return;
         }
#ifdef __APPLE__
         termios tty_state(_tty_state);
#else
         termio tty_state(_tty_state);
#endif
         tty_state.c_lflag = 0;
         tty_state.c_cc[VTIME] = 0;
         tty_state.c_cc[VMIN] = 1;
#ifdef __APPLE__
         if (ioctl(_fd, TIOCSETA, &tty_state) < 0)
#else
         if (ioctl(_fd, TCSETA, &tty_state) < 0)
#endif
            std::cerr << Str_error(errno, "Cannot reset ioctl") << std::endl;
         else
#endif
            _raw_mode = true;
      }
   }
};

//----------------------------------------------------------------------------------------
class filestdin
{
   std::istream *ifs_;
   bool nodel_;

public:
   filestdin(std::istream *ifs, bool nodel=false) : ifs_(ifs), nodel_(nodel) {}
   ~filestdin() { if (!nodel_) delete ifs_; }

   std::istream& operator()() { return *ifs_; }
};

//----------------------------------------------------------------------------------------
#if defined POCO_VERSION && POCO_VERSION <= 0x01040100
inline bool operator==(const Poco::Net::SocketAddress &a, const Poco::Net::SocketAddress &b)
{
   return a.host() == b.host() && a.port() == b.port();
}

inline bool operator!=(const Poco::Net::SocketAddress &a, const Poco::Net::SocketAddress &b)
{
   return !(a == b);
}
#endif

//----------------------------------------------------------------------------------------
} // namespace FIX8

#endif // _F8_UTILS_HPP_