Strings.cpp

#include "MantidKernel/Strings.h"
#include "MantidKernel/UnitLabel.h"

#include <Poco/StringTokenizer.h>
#include <Poco/Path.h>

#include <boost/algorithm/string.hpp>
#include <boost/lexical_cast.hpp>
#include <boost/shared_ptr.hpp>
#include <boost/make_shared.hpp>

#include <cmath>
#include <fstream>

using std::size_t;

namespace Mantid {
namespace Kernel {
namespace Strings {

//------------------------------------------------------------------------------------------------
/** Loads the entire contents of a text file into a string
 *
 * @param filename :: full path to file
 * @return string contents of text file
 */
std::string loadFile(const std::string &filename) {
  std::string retVal;
  std::string str;
  std::ifstream in;
  in.open(filename.c_str());
  getline(in, str);
  while (in) {
    retVal += str + "\n";
    getline(in, str);
  }
  in.close();
  return retVal;
}

//------------------------------------------------------------------------------------------------
/** Return a string with all matching occurence-strings
 *
 * @param input :: input string
 * @param find_what :: will search for all occurences of this string
 * @param replace_with :: ... and replace them with this.
 * @return the modified string.
 */
std::string replace(const std::string &input, const std::string &find_what,
                    const std::string &replace_with) {
  std::string output = input;
  std::string::size_type pos = 0;
  while ((pos = output.find(find_what, pos)) != std::string::npos) {
    output.erase(pos, find_what.length());
    output.insert(pos, replace_with);
    pos += replace_with.length();
  }
  return output;
}

/**
 * Return a string with all occurrences of the characters in the input replaced
 * by the replace string
 * @param input :: The input string to perform the replacement on
 * @param charStr :: Each occurrence of ANY character in this string within the
 * input string will be replaced by substitute
 * @param substitute :: A substitute string
 * @return A new string with the characters replaced
 */
MANTID_KERNEL_DLL std::string replaceAll(const std::string &input,
                                         const std::string &charStr,
                                         const std::string &substitute) {
  std::string replaced;
  replaced.reserve(input.size());
  std::string::const_iterator iend = input.end();
  for (std::string::const_iterator itr = input.begin(); itr != iend; ++itr) {
    char inputChar = (*itr);
    if (charStr.find_first_of(inputChar) == std::string::npos) // Input string
                                                               // char is not
                                                               // one of those
                                                               // to be replaced
    {
      replaced.push_back(inputChar);
    } else {
      replaced.append(substitute);
    }
  }
  return replaced;
}

//------------------------------------------------------------------------------------------------
/**
 * Function to convert a number into hex
 * output (and leave the stream un-changed)
 * @param OFS :: Output stream
 * @param n :: Integer to convert
 * \todo Change this to a stream operator
 */
void printHex(std::ostream &OFS, const int n) {
  std::ios_base::fmtflags PrevFlags = OFS.flags();
  OFS << "Ox";
  OFS.width(8);
  OFS.fill('0');
  hex(OFS);
  OFS << n;
  OFS.flags(PrevFlags);
  return;
}

//------------------------------------------------------------------------------------------------
/**
 * Removes the multiple spaces in the line
 * @param Line :: Line to process
 * @return String with single space components
 */
std::string stripMultSpc(const std::string &Line) {
  std::string Out;
  int spc(1);
  int lastReal(-1);
  for (unsigned int i = 0; i < Line.length(); i++) {
    if (Line[i] != ' ' && Line[i] != '\t' && Line[i] != '\r' &&
        Line[i] != '\n') {
      lastReal = i;
      spc = 0;
      Out += Line[i];
    } else if (!spc) {
      spc = 1;
      Out += ' ';
    }
  }
  lastReal++;
  if (lastReal < static_cast<int>(Out.length()))
    Out.erase(lastReal);
  return Out;
}

//------------------------------------------------------------------------------------------------
//------------------------------------------------------------------------------------------------
/**
 *  Checks that as least cnt letters of
 *  works is part of the string. It is currently
 *  case sensitive. It removes the Word if found
 *  @param Line :: Line to process
 *  @param Word :: Word to use
 * @param cnt :: Length of Word for significants [default =4]
 *  @retval 1 on success (and changed Line)
 *  @retval 0 on failure
 */
int extractWord(std::string &Line, const std::string &Word, const int cnt) {
  if (Word.empty())
    return 0;

  size_t minSize(cnt > static_cast<int>(Word.size()) ? Word.size() : cnt);
  std::string::size_type pos = Line.find(Word.substr(0, minSize));
  if (pos == std::string::npos)
    return 0;
  // Pos == Start of find
  size_t LinePt = minSize + pos;
  for (; minSize < Word.size() && LinePt < Line.size() &&
             Word[minSize] == Line[LinePt];
       LinePt++, minSize++) {
  }

  Line.erase(pos, LinePt - (pos - 1));
  return 1;
}

//------------------------------------------------------------------------------------------------
/** If a word ends with a number representing a positive integer, return
 * the value of that int.
 *
 * @param word :: string possibly ending in a number
 * @return the number, or -1 if it does not end in a number
 */
int endsWithInt(const std::string &word) {
  if (word.empty())
    return -1;
  int out = -1;
  // Find the index of the first number in the string (if any)
  int firstNumber = int(word.size());
  for (int i = int(word.size()) - 1; i >= 0; i--) {
    char c = word[i];
    if ((c > '9') || (c < '0'))
      break;
    firstNumber = i;
  }
  // Convert the string of decimals to an int
  if (firstNumber < int(word.size())) {
    std::string part = word.substr(firstNumber, word.size() - firstNumber);
    if (!convert(part, out))
      return -1;
  }
  return out;
}

//------------------------------------------------------------------------------------------------
/**
 *  Check to see if S is the same as the
 *  first part of a phrase. (case insensitive)
 *  @param S :: string to check
 *  @param fullPhrase :: complete phrase
 *  @return 1 on success
 */
int confirmStr(const std::string &S, const std::string &fullPhrase) {
  const size_t nS(S.length());
  const size_t nC(fullPhrase.length());
  if (nS > nC || nS == 0)
    return 0;
  for (size_t i = 0; i < nS; i++)
    if (S[i] != fullPhrase[i])
      return 0;
  return 1;
}

//------------------------------------------------------------------------------------------------
/**
 *  Gets a line and determine if there is addition component to add
 *  in the case of a very long line.
 *  @param fh :: input stream to get line
 *  @param Out :: string up to last 'tab' or ' '
 *  @param Excess :: string after 'tab or ' '
 *  @param spc :: number of char to try to read
 *  @retval 1 :: more line to be found
 *  @retval -1 :: Error with file
 *  @retval 0  :: line finished.
 */
int getPartLine(std::istream &fh, std::string &Out, std::string &Excess,
                const int spc) {
  // std::string Line;
  if (fh.good()) {
    char *ss = new char[spc + 1];
    const int clen = static_cast<int>(spc - Out.length());
    fh.getline(ss, clen, '\n');
    ss[clen + 1] = 0; // incase line failed to read completely
    Out += static_cast<std::string>(ss);
    delete[] ss;
    // remove trailing comments
    std::string::size_type pos = Out.find_first_of("#!");
    if (pos != std::string::npos) {
      Out.erase(pos);
      return 0;
    }
    if (fh.gcount() == clen - 1) // cont line
    {
      pos = Out.find_last_of("\t ");
      if (pos != std::string::npos) {
        Excess = Out.substr(pos, std::string::npos);
        Out.erase(pos);
      } else
        Excess.erase(0, std::string::npos);
      fh.clear();
      return 1;
    }
    return 0;
  }
  return -1;
}

//------------------------------------------------------------------------------------------------
/**
 *  Removes all spaces from a string
 * except those with in the form '\ '
 *  @param CLine :: Line to strip
 *  @return String without space
 */
std::string removeSpace(const std::string &CLine) {
  std::string Out;
  char prev = 'x';
  for (unsigned int i = 0; i < CLine.length(); i++) {
    if (!isspace(CLine[i]) || prev == '\\') {
      Out += CLine[i];
      prev = CLine[i];
    }
  }
  return Out;
}

//------------------------------------------------------------------------------------------------
/**
 *  Reads a line from the stream of max length spc.
 *  Trailing comments are removed. (with # or ! character)
 *  @param fh :: already open file handle
 *  @param spc :: max number of characters to read
 *  @return String read.
 */
std::string getLine(std::istream &fh, const int spc) {
  char *ss = new char[spc + 1];
  std::string Line;
  if (fh.good()) {
    fh.getline(ss, spc, '\n');
    ss[spc] = 0; // incase line failed to read completely
    Line = ss;
    // remove trailing comments
    std::string::size_type pos = Line.find_first_of("#!");
    if (pos != std::string::npos)
      Line.erase(pos);
  }
  delete[] ss;
  return Line;
}

/**
 * Peek at a line without extracting it from the stream
 */
std::string peekLine(std::istream &fh) {
  std::string str;
  std::streampos pos = fh.tellg();
  getline(fh, str);
  fh.seekg(pos);

  return strip(str);
}

//------------------------------------------------------------------------------------------------
/**
 *  Determines if a string is only spaces
 *  @param A :: string to check
 *  @return 1 on an empty string , 0 on failure
 */
int isEmpty(const std::string &A) {
  std::string::size_type pos = A.find_first_not_of(" \t");
  return (pos != std::string::npos) ? 0 : 1;
}

//------------------------------------------------------------------------------------------------
/**
 *  removes the string after the comment type of
 *  '$ ' or '!' or '#  '
 *  @param A :: String to process
 */
void stripComment(std::string &A) {
  std::string::size_type posA = A.find("$ ");
  std::string::size_type posB = A.find("# ");
  std::string::size_type posC = A.find("!");
  if (posA > posB)
    posA = posB;
  if (posA > posC)
    posA = posC;
  if (posA != std::string::npos)
    A.erase(posA, std::string::npos);
  return;
}

//------------------------------------------------------------------------------------------------
/**
 *  Returns the string from the first non-space to the
 *  last non-space
 * @param A :: string to process
 * @return shortened string
 */
std::string fullBlock(const std::string &A) { return strip(A); }

//------------------------------------------------------------------------------------------------
/** Returns the string from the first non-space to the
 *  last non-space
 *  @param A :: string to process
 *  @return shortened string
 */
std::string strip(const std::string &A) {
  std::string result(A);
  boost::trim(result);
  return result;
}

/**
* Return true if the line is to be skipped (starts with #).
* @param line :: The line to be checked
* @return True if the line should be skipped
*/
bool skipLine(const std::string &line) {
  // Empty or comment
  return (line.empty() || boost::starts_with(line, "#"));
}

//------------------------------------------------------------------------------------------------
/**
 *  Write out the line in the limited form for MCNPX
 *  ie initial line from 0->72 after that 8 to 72
 *  (split on a space or comma)
 *  @param Line :: full MCNPX line
 *  @param OX :: ostream to write to
 */
void writeMCNPX(const std::string &Line, std::ostream &OX) {
  const int MaxLine(72);
  std::string::size_type pos(0);
  std::string X = Line.substr(0, MaxLine);
  std::string::size_type posB = X.find_last_of(" ,");
  int spc(0);
  while (posB != std::string::npos &&
         static_cast<int>(X.length()) >= MaxLine - spc) {
    pos += posB + 1;
    if (!isspace(X[posB]))
      posB++;
    const std::string Out = X.substr(0, posB);
    if (!isEmpty(Out)) {
      if (spc)
        OX << std::string(spc, ' ');
      OX << X.substr(0, posB) << std::endl;
    }
    spc = 8;
    X = Line.substr(pos, MaxLine - spc);
    posB = X.find_last_of(" ,");
  }
  if (!isEmpty(X)) {
    if (spc)
      OX << std::string(spc, ' ');
    OX << X << std::endl;
  }
  return;
}

//------------------------------------------------------------------------------------------------
/**
 *  Splits the sting into parts that are space delminated.
 *  @param Ln :: line component to strip
 *  @return vector of components
 */
std::vector<std::string> StrParts(std::string Ln) {
  std::vector<std::string> Out;
  std::string Part;
  while (section(Ln, Part))
    Out.push_back(Part);
  return Out;
}

/**
 * Splits a string into key value pairs and returns them as a map. Whitespace
 * between separators is ignored
 * @param input :: The string containing the key/values
 * @param keyValSep :: The separator that splits a key and value [default: "="]
 * @param listSep :: The separator that splits elements of the list [default:
 * ","]
 * @returns A map of keys->values
 */
std::map<std::string, std::string>
splitToKeyValues(const std::string &input, const std::string &keyValSep,
                 const std::string &listSep) {
  std::map<std::string, std::string> keyValues;
  const int splitOptions =
      Poco::StringTokenizer::TOK_IGNORE_EMPTY + Poco::StringTokenizer::TOK_TRIM;
  Poco::StringTokenizer listSplitter(input, listSep);
  for (auto iter = listSplitter.begin(); iter != listSplitter.end(); ++iter) {
    Poco::StringTokenizer keyValSplitter(*iter, keyValSep, splitOptions);
    if (keyValSplitter.count() == 2) {
      keyValues[keyValSplitter[0]] = keyValSplitter[1];
    }
  }

  return keyValues;
}

//------------------------------------------------------------------------------------------------
/**
 *  Converts a vax number into a standard unix number
 *  @param A :: float number as read from a VAX file
 *  @return float A in IEEE little eindian format
 */
float getVAXnum(const float A) {
  union {
    // char a[4];
    float f;
    int ival;
  } Bd;

  int sign, expt, fmask;
  float frac;
  double onum;

  Bd.f = A;
  sign = (Bd.ival & 0x8000) ? -1 : 1;
  expt = ((Bd.ival & 0x7f80) >> 7); // reveresed ?
  if (!expt)
    return 0.0;

  fmask = ((Bd.ival & 0x7f) << 16) | ((Bd.ival & 0xffff0000) >> 16);
  expt -= 128;
  fmask |= 0x800000;
  frac = (float)fmask / 0x1000000;
  onum = frac * static_cast<float>(sign) * pow(2.0, expt);
  return (float)onum;
}

//------------------------------------------------------------------------------------------------
/**
 *  Takes a character string and evaluates
 *  the first [typename T] object. The string is then
 *  erase upt to the end of number.
 *  The diffierence between this and section is that
 *  it allows trailing characters after the number.
 *  @param out :: place for output
 *  @param A :: string to process
 *  @return 1 on success 0 on failure
 */
template <typename T> int sectPartNum(std::string &A, T &out) {
  if (A.empty())
    return 0;

  std::istringstream cx;
  T retval;
  cx.str(A);
  cx.clear();
  cx >> retval;
  const std::streamoff xpt = cx.tellg();
  if (xpt < 0)
    return 0;
  A.erase(0, static_cast<unsigned int>(xpt));
  out = retval;
  return 1;
}

//------------------------------------------------------------------------------------------------
/**
 *  Takes a character string and evaluates
 *  the first [typename T] object. The string is then filled with
 *  spaces upto the end of the [typename T] object
 *  @param out :: place for output
 *  @param cA :: char array for input and output.
 *  @return 1 on success 0 on failure
 */
template <typename T> int section(char *cA, T &out) {
  if (!cA)
    return 0;
  std::string sA(cA);
  const int item(section(sA, out));
  if (item) {
    strcpy(cA, sA.c_str());
    return 1;
  }
  return 0;
}

/**
 *  takes a character string and evaluates
 *  the first \<T\> object. The string is then filled with
 *  spaces upto the end of the \<T\> object
 *  @param out :: place for output
 *  @param A :: string for input and output.
 *  @return 1 on success 0 on failure
 */
template <typename T> int section(std::string &A, T &out) {
  if (A.empty())
    return 0;
  std::istringstream cx;
  T retval;
  cx.str(A);
  cx.clear();
  cx >> retval;
  if (cx.fail())
    return 0;
  const std::streamoff xpt = cx.tellg();
  const char xc = static_cast<char>(cx.get());
  if (!cx.fail() && !isspace(xc))
    return 0;
  A.erase(0, static_cast<unsigned int>(xpt));
  out = retval;
  return 1;
}

/**
 *  Takes a character string and evaluates
 *  the first [T] object. The string is then filled with
 *  spaces upto the end of the [T] object.
 *  This version deals with MCNPX numbers. Those
 *  are numbers that are crushed together like
 *  - 5.4938e+04-3.32923e-6
 *  @param out :: place for output
 *  @param A :: string for input and output.
 *  @return 1 on success 0 on failure
 */
template <typename T> int sectionMCNPX(std::string &A, T &out) {
  if (A.empty())
    return 0;
  std::istringstream cx;
  T retval;
  cx.str(A);
  cx.clear();
  cx >> retval;
  if (!cx.fail()) {
    const std::streamoff xpt = cx.tellg();
    if (xpt < 0) {
      return 0;
    }
    const char xc = static_cast<char>(cx.get());
    if (!cx.fail() && !isspace(xc) && (xc != '-' || xpt < 5)) {
      return 0;
    }
    A.erase(0, static_cast<unsigned int>(xpt));
    out = retval;
    return 1;
  }
  return 0;
}

//------------------------------------------------------------------------------------------------
/**
 *  Takes a character string and evaluates
 *  the first [typename T] object. The string is then
 *  erase upto the end of number.
 *  The diffierence between this and convert is that
 *  it allows trailing characters after the number.
 *  @param out :: place for output
 *  @param A :: string to process
 *  @retval number of char read on success
 *  @retval 0 on failure
 */
template <typename T> int convPartNum(const std::string &A, T &out) {
  if (A.empty())
    return 0;
  std::istringstream cx;
  T retval;
  cx.str(A);
  cx.clear();
  cx >> retval;
  // If we have reached the end of the stream, then we need to clear the error
  // as
  // it will cause the tellg() call to return -1.  Not pretty but works for now.
  cx.clear();
  const std::streamoff xpt = cx.tellg();
  if (xpt < 0)
    return 0;
  out = retval;
  return static_cast<int>(xpt);
}

//------------------------------------------------------------------------------------------------
/**
 *  Convert a string into a value
 *  @param A :: string to pass
 *  @param out :: value if found
 *  @return 0 on failure 1 on success
 */
template <typename T> int convert(const std::string &A, T &out) {
  if (A.empty())
    return 0;
  std::istringstream cx;
  T retval;
  cx.str(A);
  cx.clear();
  cx >> retval;
  if (cx.fail())
    return 0;
  const char clast = static_cast<char>(cx.get());
  if (!cx.fail() && !isspace(clast))
    return 0;
  out = retval;
  return 1;
}

//------------------------------------------------------------------------------------------------
/**
 *  Convert a string into a value
 *  @param A :: string to pass
 *  @param out :: value if found
 *  @return 0 on failure 1 on success
 */
template <typename T> int convert(const char *A, T &out) {
  // No string, no conversion
  if (!A)
    return 0;
  std::string Cx = A;
  return convert(Cx, out);
}

//------------------------------------------------------------------------------------------------
/** Convert a number or other value to a string
 *
 * @param value :: templated value (e.g. a double) to convert
 * @return a string
 */
template <typename T> std::string toString(const T &value) {
  std::ostringstream mess;
  mess << value;
  return mess.str();
}

/**
 * This assumes that the vector is sorted.
 *
 * @param value :: templated value (only works for integer types) to convert.
 * @return A reduced string representation.
 */
template <typename T> std::string toString(const std::vector<T> &value) {
  std::ostringstream mess;
  auto it = value.begin();
  auto last = value.end();
  T start;
  T stop;
  for (; it != last; ++it) {
    start = *(it);
    stop = start;
    for (; it != last; ++it) {
      if (it + 1 == last)
        break;
      else if ((stop + static_cast<T>(1)) == *(it + 1))
        stop = *(it + 1);
      else
        break;
    }
    mess << start;
    if (start != stop)
      mess << "-" << stop;
    if (it + 1 != last)
      mess << ",";
  }
  return mess.str();
}

template <typename T> std::string toString(const std::set<T> &value) {
  return toString(std::vector<T>(value.begin(), value.end()));
}

template <> MANTID_KERNEL_DLL std::string toString(const UnitLabel &value) {
  return value;
}

//------------------------------------------------------------------------------------------------
/**
 *  Write out the three vectors into a file of type dc 9
 *  @param step :: parameter to control x-step (starts from zero)
 * @param Y :: Y column
 *  @param Fname :: Name of the file
 *  @return 0 on success and -ve on failure
 */
template <template <typename T, typename A> class V, typename T, typename A>
int writeFile(const std::string &Fname, const T &step, const V<T, A> &Y) {
  V<T, A> Ex; // Empty vector
  V<T, A> X;  // Empty vector
  for (unsigned int i = 0; i < Y.size(); i++)
    X.push_back(i * step);

  return writeFile(Fname, X, Y, Ex);
}

//------------------------------------------------------------------------------------------------
/**
 *  Write out the three vectors into a file of type dc 9
 *  @param X :: X column
 *  @param Y :: Y column
 *  @param Fname :: Name of the file
 *  @return 0 on success and -ve on failure
 */
template <template <typename T, typename A> class V, typename T, typename A>
int writeFile(const std::string &Fname, const V<T, A> &X, const V<T, A> &Y) {
  V<T, A> Ex;                        // Empty vector/list
  return writeFile(Fname, X, Y, Ex); // don't need to specific ??
}

//------------------------------------------------------------------------------------------------
/**
 *  Write out the three container into a file with
 *  column free-formated data in the form :
 *   - X  Y Err
 *   If Err does not exist (or is short) 0.0 is substituted.
 *  @param X :: X column
 *  @param Y :: Y column
 *  @param Err :: Err column
 *  @param Fname :: Name of the file
 *  @return 0 on success and -ve on failure
 */
template <template <typename T, typename A> class V, typename T, typename A>
int writeFile(const std::string &Fname, const V<T, A> &X, const V<T, A> &Y,
              const V<T, A> &Err) {
  const size_t Npts(X.size() > Y.size() ? Y.size() : X.size());
  const size_t Epts(Npts > Err.size() ? Err.size() : Npts);

  std::ofstream FX;

  FX.open(Fname.c_str());
  if (!FX.good())
    return -1;

  FX << "# " << Npts << " " << Epts << std::endl;
  FX.precision(10);
  FX.setf(std::ios::scientific, std::ios::floatfield);
  typename V<T, A>::const_iterator xPt = X.begin();
  typename V<T, A>::const_iterator yPt = Y.begin();
  typename V<T, A>::const_iterator ePt = (Epts ? Err.begin() : Y.begin());

  // Double loop to include/exclude a short error stack
  size_t eCount = 0;
  for (; eCount < Epts; eCount++) {
    FX << (*xPt) << " " << (*yPt) << " " << (*ePt) << std::endl;
    ++xPt;
    ++yPt;
    ++ePt;
  }
  for (; eCount < Npts; eCount++) {
    FX << (*xPt) << " " << (*yPt) << " 0.0" << std::endl;
    ++xPt;
    ++yPt;
  }
  FX.close();
  return 0;
}

//------------------------------------------------------------------------------------------------
/**
 *  Call to read in various values in position x1,x2,x3 from the
 *  line. Note to avoid the dependency on crossSort this needs
 *  to be call IN ORDER
 *  @param Line :: string to read
 *  @param Index :: Indexes to read
 *  @param Out :: OutValues [unchanged if not read]
 *  @retval 0 :: success
 *  @retval -ve on failure.
 */
template <typename T>
int setValues(const std::string &Line, const std::vector<int> &Index,
              std::vector<T> &Out) {
  if (Index.empty())
    return 0;

  if (Out.size() != Index.size())
    return -1;
  //    throw ColErr::MisMatch<int>(Index.size(),Out.size(),
  //        "Mantid::Kernel::Strings::setValues");

  std::string modLine = Line;
  std::vector<int> sIndex(Index); // Copy for sorting
  std::vector<int> OPt(Index.size());
  for (unsigned int i = 0; i < Index.size(); i++)
    OPt[i] = i;

  //  mathFunc::crossSort(sIndex,OPt);

  typedef std::vector<int>::const_iterator iVecIter;
  std::vector<int>::const_iterator sc = sIndex.begin();
  std::vector<int>::const_iterator oc = OPt.begin();
  int cnt(0);
  T value;
  std::string dump;
  while (sc != sIndex.end() && *sc < 0) {
    ++sc;
    ++oc;
  }

  while (sc != sIndex.end()) {
    if (*sc == cnt) {
      if (!section(modLine, value))
        return static_cast<int>(
            -1 - distance(static_cast<iVecIter>(sIndex.begin()), sc));
      // this loop handles repeat units
      do {
        Out[*oc] = value;
        ++sc;
        ++oc;
      } while (sc != sIndex.end() && *sc == cnt);
    } else {
      if (!section(modLine, dump))
        return static_cast<int>(
            -1 - distance(static_cast<iVecIter>(sIndex.begin()), sc));
    }
    cnt++; // Add only to cnt [sc/oc in while loop]
  }
  // Success since loop only gets here if sc is exhaused.
  return 0;
}

//-----------------------------------------------------------------------------------------------
/** Get a word from a line and strips spaces
 *
 * @param in :: stream input
 * @param consumeEOL :: set to true to remove the new lines at the end of the
 *line
 * @return a string with the word read in
 */
std::string getWord(std::istream &in, bool consumeEOL) {
  std::string ret;
  char nextch = 0;

  // Skip leading spaces
  do {
    nextch = static_cast<char>(in.get());
  } while (nextch == ' ');

  // Return an empty string on EOL; optionally consume it
  if (nextch == '\n' || nextch == '\r') {
    if (!consumeEOL) {
      in.unget();
    } else if ((nextch == '\n' && in.peek() == '\r') ||
               (nextch == '\r' && in.peek() == '\n')) {
      // Handle CRLF and LFCR on Unix by consuming both
      in.ignore();
    }

    return ret;
  } else {      // Non-EOL and non-space character
    in.unget(); // Put it back on stream
  }

  // Get next word if stream is still valid
  if (in.good())
    in >> ret;

  // Optionally consume EOL character
  if (consumeEOL) {
    nextch = static_cast<char>(in.get());

    // Handle CRLF and LFCR on Unix by consuming both
    if (nextch == '\n' || nextch == '\r') {
      if ((nextch == '\n' && in.peek() == '\r') ||
          (nextch == '\r' && in.peek() == '\n')) {
        in.ignore();
      }
    } else {
      in.unget();
    }
  }

  return ret;
}

//-----------------------------------------------------------------------------------------------
/** Read up to the eol
 *
 * @param in :: stream input
 * @param ConsumeEOL :: set to true to remove the new lines at the end of the
 *line
 */
void readToEndOfLine(std::istream &in, bool ConsumeEOL) {
  while (in.good() && getWord(in, false).length() > 0)
    getWord(in, false);
  if (!ConsumeEOL)
    return;
  getWord(in, true);
}

/**
 * Function parses a path, placed into input string "path" and returns vector of
 * the folders contributed into the path
 *  @param path :: the string containing input path, found in path string, if
 * they are separated by \ or / symbols.
 *  Treats special symbols, if defined in the input string as path-es
 *  returns 0 for empty input string
 *  @param path_components :: holder for the individual folders in the path
 *  used to generate path in hdf file, so the resulting path has to obey hdf
 * constrains;
 */
size_t split_path(const std::string &path,
                  std::vector<std::string> &path_components) {
  if (path.empty()) {
    path_components.resize(0);
    return 0;
  }
  // convert Windows path into the unix one
  std::string working_path(path);
  for (size_t i = 0; i < path.size(); i++) {
    if (working_path[i] < 0x20 || working_path[i] > 0x7E)
      working_path[i] = '_';
    if (working_path[i] == '\\')
      working_path[i] = '/';
    if (working_path[i] == ' ')
      working_path[i] = '_';
  }

  // path start with relative character, and we need to convert it into full
  // path
  if (path[0] == '.') {
    // get absolute path using working directory as base;
    Poco::Path absol;
    absol = absol.absolute();
    working_path = absol.toString(Poco::Path::PATH_UNIX) + working_path;
  }
  // as poco splt using regular expressions is doing some rubbish, we need to do
  // split manually
  // code below implements perl split(/\\//,string) commamd. (\\ has been
  // converted to / above)
  std::list<int64_t> split_pos;
  split_pos.push_back(-1);
  size_t path_size = working_path.size();
  for (size_t i = 0; i < path_size; i++) {
    if (working_path[i] == '/') {
      split_pos.push_back(i);
    }
  }
  split_pos.push_back(path_size);
  // allocate target vector to keep folder structure and fill it in
  size_t n_folders = split_pos.size() - 1;
  path_components.resize(n_folders);
  std::list<int64_t>::iterator it1 = split_pos.begin();
  std::list<int64_t>::iterator it2 = it1;
  ++it2;

  int64_t ic(0);
  for (; it2 != split_pos.end(); ++it2) {
    std::string folder = working_path.substr(*it1 + 1, *it2 - *it1 - 1);
    if (folder.empty() ||
        (folder.size() == 1 &&
         folder == ".")) { // skip self-references and double slashes;
      it1 = it2;
      continue;
    }
    // reprocess up-references;
    if (folder == "..") {
      if (folder.size() != 2)
        throw(std::invalid_argument("path contains wrong path group"));
      ic--;
      if (ic < 0)
        throw(std::invalid_argument("path contains relative references to a "
                                    "folder outside of the seach tree"));