OutputStream.h

Go to the documentation of this file.

// SPDX-FileCopyrightText: The Bio++ Development Group
//
// SPDX-License-Identifier: CECILL-2.1

#ifndef BPP_IO_OUTPUTSTREAM_H
#define BPP_IO_OUTPUTSTREAM_H


#include "../Clonable.h"

// From the STL:
#include <string>
#include <iostream>
#include <fstream>
#include <sstream>
#include <memory>
#include <iomanip>

namespace bpp
{
class OutputStream :
  public virtual Clonable
{
public:
  virtual OutputStream& operator<<(const std::string& message) = 0;
  virtual OutputStream& operator<<(const char* message) = 0;
  virtual OutputStream& operator<<(const char& message) = 0;
  virtual OutputStream& operator<<(const int& message) = 0;
  virtual OutputStream& operator<<(const unsigned int& message) = 0;
  virtual OutputStream& operator<<(const long int& message) = 0;
  virtual OutputStream& operator<<(const unsigned long int& message) = 0;
  virtual OutputStream& operator<<(const double& message) = 0;
  virtual OutputStream& operator<<(const long double& message) = 0;
  virtual OutputStream& operator<<(const bool& message) = 0;
  virtual OutputStream& endLine() = 0;
  virtual OutputStream& flush() = 0;
  virtual OutputStream& setPrecision(int digit) = 0;
  virtual int getPrecision() const = 0;
  virtual OutputStream& enableScientificNotation(bool yn) = 0;
  virtual bool isScientificNotationEnabled() const = 0;

  OutputStream* clone() const = 0;
};


class AbstractOutputStream :
  public virtual OutputStream
{
private:
  int precision_;
  bool scienceNotation_;

public:
  AbstractOutputStream() : precision_(6), scienceNotation_(false) {}

public:
  OutputStream& setPrecision(int digit)
  {
    precision_ = digit;
    return *this;
  }
  int getPrecision() const { return precision_; }

  virtual OutputStream& enableScientificNotation(bool yn) { scienceNotation_ = yn; return *this; }
  virtual bool isScientificNotationEnabled() const { return scienceNotation_; }
};


class NullOutputStream :
  public AbstractOutputStream
{
public:
  NullOutputStream& operator<<(const std::string& message) { return *this; }
  NullOutputStream& operator<<(const char* message) { return *this; }
  NullOutputStream& operator<<(const char& message) { return *this; }
  NullOutputStream& operator<<(const int& message) { return *this; }
  NullOutputStream& operator<<(const unsigned int& message) { return *this; }
  NullOutputStream& operator<<(const long int& message) { return *this; }
  NullOutputStream& operator<<(const unsigned long int& message) { return *this; }
  NullOutputStream& operator<<(const double& message) { return *this; }
  NullOutputStream& operator<<(const long double& message) { return *this; }
  NullOutputStream& operator<<(const bool& message) { return *this; }
  NullOutputStream& endLine() { return *this; }
  NullOutputStream& flush() { return *this; }

  NullOutputStream* clone() const { return new NullOutputStream(*this); }
};


class StlOutputStream :
  public AbstractOutputStream
{
private:
  mutable std::unique_ptr<std::ostream> stream_;

public:
  StlOutputStream(std::unique_ptr<std::ostream> stream) : stream_(std::move(stream)) {}
  StlOutputStream(const StlOutputStream& stlos) : stream_() { stream_ = std::move(stlos.stream_); }
  StlOutputStream& operator=(const StlOutputStream& stlos)
  {
    stream_ = std::move(stlos.stream_);
    return *this;
  }

public:
  StlOutputStream& operator<<(const std::string& message) { if (stream_.get()) *stream_ << message; return *this; }
  StlOutputStream& operator<<(const char* message) { if (stream_.get()) *stream_ << message; return *this; }
  StlOutputStream& operator<<(const char& message) { if (stream_.get()) *stream_ << message; return *this; }
  StlOutputStream& operator<<(const int& message) { if (stream_.get()) *stream_ << message; return *this; }
  StlOutputStream& operator<<(const unsigned int& message) { if (stream_.get()) *stream_ << message; return *this; }
  StlOutputStream& operator<<(const long int& message) { if (stream_.get()) *stream_ << message; return *this; }
  StlOutputStream& operator<<(const unsigned long int& message) { if (stream_.get()) *stream_ << message; return *this; }
  StlOutputStream& operator<<(const double& message)
  {
    if (stream_.get())
      *stream_ << std::setprecision(getPrecision()) << (isScientificNotationEnabled() ? std::scientific : std::fixed) << message;
    return *this;
  }
  StlOutputStream& operator<<(const long double& message)
  {
    if (stream_.get())
      *stream_ << std::setprecision(getPrecision()) << (isScientificNotationEnabled() ? std::scientific : std::fixed) << message;
    return *this;
  }
  StlOutputStream& operator<<(const bool& message) { if (stream_.get()) *stream_ << message; return *this; }
  StlOutputStream& endLine() { if (stream_.get()) *stream_ << std::endl; return *this; }
  StlOutputStream& flush() { if (stream_.get()) stream_->flush(); return *this; }

  StlOutputStream* clone() const { return new StlOutputStream(*this); }
};


class StlOutputStreamWrapper :
  public AbstractOutputStream
{
protected:
  std::ostream* stream_;

public:
  StlOutputStreamWrapper(std::ostream* stream) : stream_(stream) {}
  StlOutputStreamWrapper(const StlOutputStreamWrapper& stlos) : stream_(stlos.stream_) {}
  StlOutputStreamWrapper& operator=(const StlOutputStreamWrapper& stlos) { stream_ = stlos.stream_; return *this; }

public:
  StlOutputStreamWrapper& operator<<(const std::string& message) { if (stream_) *stream_ << message; return *this; }
  StlOutputStreamWrapper& operator<<(const char* message) { if (stream_) *stream_ << message; return *this; }
  StlOutputStreamWrapper& operator<<(const char& message) { if (stream_) *stream_ << message; return *this; }
  StlOutputStreamWrapper& operator<<(const int& message) { if (stream_) *stream_ << message; return *this; }
  StlOutputStreamWrapper& operator<<(const unsigned int& message) { if (stream_) *stream_ << message; return *this; }

  StlOutputStreamWrapper& operator<<(const long int& message) { if (stream_) *stream_ << message; return *this; }
  StlOutputStreamWrapper& operator<<(const unsigned long int& message) { if (stream_) *stream_ << message; return *this; }
  StlOutputStreamWrapper& operator<<(const double& message)
  {
    if (stream_)
      *stream_ << std::setprecision(getPrecision()) << (isScientificNotationEnabled() ? std::scientific : std::fixed) << message;
    return *this;
  }
  StlOutputStreamWrapper& operator<<(const long double& message)
  {
    if (stream_)
      *stream_ << std::setprecision(getPrecision()) << (isScientificNotationEnabled() ? std::scientific : std::fixed) << message;
    return *this;
  }
  StlOutputStreamWrapper& operator<<(const bool& message) { if (stream_) *stream_ << message; return *this; }
  StlOutputStreamWrapper& endLine() { if (stream_) *stream_ << std::endl; return *this; }
  StlOutputStreamWrapper& flush() { if (stream_) stream_->flush(); return *this; }

  StlOutputStreamWrapper* clone() const { return new StlOutputStreamWrapper(*this); }
};

class StdOut :
  public AbstractOutputStream
{
public:
  OutputStream& operator<<(const std::string& message) { std::cout << message; return *this; }
  OutputStream& operator<<(const char* message) { std::cout << message; return *this; }
  OutputStream& operator<<(const char& message) { std::cout << message; return *this; }
  OutputStream& operator<<(const int& message) { std::cout << message; return *this; }
  OutputStream& operator<<(const unsigned int& message) { std::cout << message; return *this; }
  OutputStream& operator<<(const long int& message) { std::cout << message; return *this; }
  OutputStream& operator<<(const unsigned long int& message) { std::cout << message; return *this; }
  OutputStream& operator<<(const double& message)
  {
    std::cout << std::setprecision(getPrecision()) << (isScientificNotationEnabled() ? std::scientific : std::fixed) << message;
    return *this;
  }
  OutputStream& operator<<(const long double& message)
  {
    std::cout << std::setprecision(getPrecision()) << (isScientificNotationEnabled() ? std::scientific : std::fixed) << message;
    return *this;
  }
  OutputStream& operator<<(const bool& message) { std::cout << message; return *this; }
  OutputStream& endLine() { std::cout << std::endl; return *this; }
  OutputStream& flush() { std::cout.flush(); return *this; }

  StdOut* clone() const { return new StdOut(*this); }
};


class StdErr :
  public AbstractOutputStream
{
public:
  OutputStream& operator<<(const std::string& message) { std::cerr << message; return *this; }
  OutputStream& operator<<(const char* message) { std::cerr << message; return *this; }
  OutputStream& operator<<(const char& message) { std::cerr << std::setprecision(getPrecision()) << message; return *this; }
  OutputStream& operator<<(const int& message) { std::cerr << std::setprecision(getPrecision()) << message; return *this; }
  OutputStream& operator<<(const unsigned int& message) { std::cerr << message; return *this; }
  OutputStream& operator<<(const long int& message) { std::cerr << std::setprecision(getPrecision()) << message; return *this; }
  OutputStream& operator<<(const unsigned long int& message) { std::cerr << message; return *this; }
  OutputStream& operator<<(const double& message)
  {
    std::cerr << std::setprecision(getPrecision()) << (isScientificNotationEnabled() ? std::scientific : std::fixed) << message;
    return *this;
  }
  OutputStream& operator<<(const long double& message)
  {
    std::cerr << std::setprecision(getPrecision()) << (isScientificNotationEnabled() ? std::scientific : std::fixed) << message;
    return *this;
  }
  OutputStream& operator<<(const bool& message) { std::cerr << message; return *this; }
  OutputStream& endLine() { std::cerr << std::endl; return *this; }
  OutputStream& flush() { std::cerr.flush(); return *this; }

  StdErr* clone() const { return new StdErr(*this); }
};

class StdStr :
  public StlOutputStreamWrapper
{
public:
  StdStr() : StlOutputStreamWrapper(new std::ostringstream()){}

  std::string str() const { return dynamic_cast<const std::ostringstream*>(stream_)->str();}

  virtual ~StdStr() { delete stream_;}
};
} // end of namespace bpp;
#endif // BPP_IO_OUTPUTSTREAM_H