// base/io-funcs.cc
  
  // Copyright 2009-2011  Microsoft Corporation;  Saarland University
  
  // See ../../COPYING for clarification regarding multiple authors
  //
  // Licensed under the Apache License, Version 2.0 (the "License");
  // you may not use this file except in compliance with the License.
  // You may obtain a copy of the License at
  
  //  http://www.apache.org/licenses/LICENSE-2.0
  
  // THIS CODE IS PROVIDED *AS IS* BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
  // KIND, EITHER EXPRESS OR IMPLIED, INCLUDING WITHOUT LIMITATION ANY IMPLIED
  // WARRANTIES OR CONDITIONS OF TITLE, FITNESS FOR A PARTICULAR PURPOSE,
  // MERCHANTABLITY OR NON-INFRINGEMENT.
  // See the Apache 2 License for the specific language governing permissions and
  // limitations under the License.
  
  #include "base/io-funcs.h"
  #include "base/kaldi-math.h"
  
  namespace kaldi {
  
  template<>
  void WriteBasicType<bool>(std::ostream &os, bool binary, bool b) {
    os << (b ? "T":"F");
    if (!binary) os << " ";
    if (os.fail())
      KALDI_ERR << "Write failure in WriteBasicType<bool>";
  }
  
  template<>
  void ReadBasicType<bool>(std::istream &is, bool binary, bool *b) {
    KALDI_PARANOID_ASSERT(b != NULL);
    if (!binary) is >> std::ws;  // eat up whitespace.
    char c = is.peek();
    if (c == 'T') {
        *b = true;
        is.get();
    } else if (c == 'F') {
        *b = false;
        is.get();
    } else {
      KALDI_ERR << "Read failure in ReadBasicType<bool>, file position is "
                << is.tellg() << ", next char is " << CharToString(c);
    }
  }
  
  template<>
  void WriteBasicType<float>(std::ostream &os, bool binary, float f) {
    if (binary) {
      char c = sizeof(f);
      os.put(c);
      os.write(reinterpret_cast<const char *>(&f), sizeof(f));
    } else {
      os << f << " ";
    }
  }
  
  template<>
  void WriteBasicType<double>(std::ostream &os, bool binary, double f) {
    if (binary) {
      char c = sizeof(f);
      os.put(c);
      os.write(reinterpret_cast<const char *>(&f), sizeof(f));
    } else {
      os << f << " ";
    }
  }
  
  template<>
  void ReadBasicType<float>(std::istream &is, bool binary, float *f) {
    KALDI_PARANOID_ASSERT(f != NULL);
    if (binary) {
      double d;
      int c = is.peek();
      if (c == sizeof(*f)) {
        is.get();
        is.read(reinterpret_cast<char*>(f), sizeof(*f));
      } else if (c == sizeof(d)) {
        ReadBasicType(is, binary, &d);
        *f = d;
      } else {
        KALDI_ERR << "ReadBasicType: expected float, saw " << is.peek()
                  << ", at file position " << is.tellg();
      }
    } else {
      is >> *f;
    }
    if (is.fail()) {
      KALDI_ERR << "ReadBasicType: failed to read, at file position "
                << is.tellg();
    }
  }
  
  template<>
  void ReadBasicType<double>(std::istream &is, bool binary, double *d) {
    KALDI_PARANOID_ASSERT(d != NULL);
    if (binary) {
      float f;
      int c = is.peek();
      if (c == sizeof(*d)) {
        is.get();
        is.read(reinterpret_cast<char*>(d), sizeof(*d));
      } else if (c == sizeof(f)) {
        ReadBasicType(is, binary, &f);
        *d = f;
      } else {
        KALDI_ERR << "ReadBasicType: expected float, saw " << is.peek()
                  << ", at file position " << is.tellg();
      }
    } else {
      is >> *d;
    }
    if (is.fail()) {
      KALDI_ERR << "ReadBasicType: failed to read, at file position "
                << is.tellg();
    }
  }
  
  void CheckToken(const char *token) {
    if (*token == '\0')
      KALDI_ERR << "Token is empty (not a valid token)";
    const char *orig_token = token;
    while (*token != '\0') {
      if (::isspace(*token))
        KALDI_ERR << "Token is not a valid token (contains space): '"
                  << orig_token << "'";
      token++;
    }
  }
  
  void WriteToken(std::ostream &os, bool binary, const char *token) {
    // binary mode is ignored;
    // we use space as termination character in either case.
    KALDI_ASSERT(token != NULL);
    CheckToken(token);  // make sure it's valid (can be read back)
    os << token << " ";
    if (os.fail()) {
      KALDI_ERR << "Write failure in WriteToken.";
    }
  }
  
  int Peek(std::istream &is, bool binary) {
    if (!binary) is >> std::ws;  // eat up whitespace.
    return is.peek();
  }
  
  void WriteToken(std::ostream &os, bool binary, const std::string & token) {
    WriteToken(os, binary, token.c_str());
  }
  
  void ReadToken(std::istream &is, bool binary, std::string *str) {
    KALDI_ASSERT(str != NULL);
    if (!binary) is >> std::ws;  // consume whitespace.
    is >> *str;
    if (is.fail()) {
      KALDI_ERR << "ReadToken, failed to read token at file position "
                << is.tellg();
    }
    if (!isspace(is.peek())) {
      KALDI_ERR << "ReadToken, expected space after token, saw instead "
                << CharToString(static_cast<char>(is.peek()))
                << ", at file position " << is.tellg();
    }
    is.get();  // consume the space.
  }
  
  int PeekToken(std::istream &is, bool binary) {
    if (!binary) is >> std::ws;  // consume whitespace.
    bool read_bracket;
    if (static_cast<char>(is.peek()) == '<') {
      read_bracket = true;
      is.get();
    } else {
      read_bracket = false;
    }
    int ans = is.peek();
    if (read_bracket) {
      if (!is.unget()) {
        // Clear the bad bit. This code can be (and is in fact) reached, since the
        // C++ standard does not guarantee that a call to unget() must succeed.
        is.clear();
      }
    }
    return ans;
  }
  
  
  void ExpectToken(std::istream &is, bool binary, const char *token) {
    int pos_at_start = is.tellg();
    KALDI_ASSERT(token != NULL);
    CheckToken(token);  // make sure it's valid (can be read back)
    if (!binary) is >> std::ws;  // consume whitespace.
    std::string str;
    is >> str;
    is.get();  // consume the space.
    if (is.fail()) {
      KALDI_ERR << "Failed to read token [started at file position "
                << pos_at_start << "], expected " << token;
    }
    // The second half of the '&&' expression below is so that if we're expecting
    // "<Foo>", we will accept "Foo>" instead.  This is so that the model-reading
    // code will tolerate errors in PeekToken where is.unget() failed; search for
    // is.clear() in PeekToken() for an explanation.
    if (strcmp(str.c_str(), token) != 0 &&
        !(token[0] == '<' && strcmp(str.c_str(), token + 1) == 0)) {
      KALDI_ERR << "Expected token \"" << token << "\", got instead \""
                << str <<"\".";
    }
  }
  
  void ExpectToken(std::istream &is, bool binary, const std::string &token) {
    ExpectToken(is, binary, token.c_str());
  }
  
  }  // end namespace kaldi