io-utility.h

#ifndef ROSE_BinaryAnalysis_Concolic_io_utility_H
#define ROSE_BinaryAnalysis_Concolic_io_utility_H
#include <featureTests.h>
#ifdef ROSE_ENABLE_CONCOLIC_TESTING
#include <Rose/BinaryAnalysis/Concolic.h>


#include <fstream>
#include <streambuf>
#include <string>
#include <vector>

namespace Rose {
namespace BinaryAnalysis {
namespace Concolic {

template <class Container>
Container
loadFile(const std::string& filename, std::ios_base::openmode mode = std::ios_base::in)
{
  typedef std::istreambuf_iterator<char> stream_iterator;

  std::ifstream stream(filename.c_str(), mode);

  if (!stream.good())
    throw std::runtime_error("Unable to open " + filename + ".");

  Container     res;

  // \todo reserve capacity in res
  std::copy(stream_iterator(stream), stream_iterator(), std::back_inserter(res));
  return res;
}


template <class T, class CharT = char, class Traits = std::char_traits<CharT> >
struct OStreamBinaryIterator : std::iterator<std::output_iterator_tag, void, void, void, void>
{
    typedef std::basic_ostream<CharT, Traits> ostream_type;
    typedef Traits                            traits_type;
    typedef CharT                             char_type;

    explicit
    OStreamBinaryIterator(ostream_type& s) : stream(s) { }

    OStreamBinaryIterator& operator=(const T& value)
    {
      stream.write(reinterpret_cast<const char*>(&value), sizeof(T));
      return *this;
    }

    OStreamBinaryIterator& operator*()     { return *this; }
    OStreamBinaryIterator& operator++()    { return *this; }
    OStreamBinaryIterator& operator++(int) { return *this; }
  private:
    ostream_type& stream;

    OStreamBinaryIterator();
    OStreamBinaryIterator& operator=(const OStreamBinaryIterator&);
};

template <class T>
struct FileSink
{
    typedef OStreamBinaryIterator<T> insert_iterator;

    explicit
    FileSink(std::ostream& stream)
    : datastream(stream)
    {}

    void reserve(size_t) {}

    insert_iterator
    inserter()
    {
      return insert_iterator(datastream);
    }

  private:
    std::ostream& datastream;
};


template <class Container>
void
storeFile(const Container& data, const std::string& filename, std::ios_base::openmode mode = std::ios_base::out)
{
  std::ofstream stream(filename.c_str(), mode);

  if (!stream.good())
    throw std::runtime_error("Unable to open " + filename + ".");

  FileSink<char> sink(stream);

  sink.reserve(data.size());
  std::copy(data.begin(), data.end(), sink.inserter());
}


namespace
{
  inline
  std::string
  loadTextFile(const boost::filesystem::path& path)
  {
    return loadFile<std::string>(path.string());
  }


  inline
  void
  storeTextFile(const std::string& data, const boost::filesystem::path& path)
  {
    storeFile(data, path.string());
  }


  inline
  std::vector<uint8_t>
  loadBinaryFile(const boost::filesystem::path& path)
  {
    return loadFile<std::vector<uint8_t> >(path.string(), std::ios::in | std::ios::binary);
  }

  inline
  void
  storeBinaryFile(const std::vector<uint8_t>& data, const boost::filesystem::path& path)
  {
    storeFile(data, path.string(), std::ofstream::binary);
  }
} // anonymous namespace

} // namespace Concolic
} // namespace BinaryAnalysis
} // namespace Rose

#endif
#endif