#include "MainInclude.h"
#ifndef __NEW_LOG__
#define __NEW_LOG__
class NewLog
{
 private:
 ostream& out;
 
   bool is_file;
   bool includeDate;
 public:
 NewLog(ostream& myout = cout) : out(myout)
 {
  includeDate = false;
 
 }
 
 NewLog( ofstream &o) : out(o)
 {
  includeDate = false;
 
  if ( out.fail() )
  {
   throw DHException ("Could not open output file for writing..."); 
  }
 }
 
 
 void setIncludeDate( bool inclDate )
 {
  includeDate = inclDate; 
 } 
ostream& operator<<(const string s)
  {
 
   if ( !out.good() )
    {
      throw DHException ("Could not open output file for writing..."); 
    }
 
    if ( includeDate )
    {
 
       out<<Date::getFormattedDate()<<"->";
 }
 
    return out<< s;
 
  }
 
};
#endif

class LogBase {
  bool _includeDate;
public:
  void setIncludeDate(bool inclDate) { _includeDate = inclDate; }
  virtual ostream& operator<<(const string& s) = 0;
};
 
class Log: public LogBase {
  ostream& _out;
public:
  Log(ostream& out = cout): _out(out) {}
  ostream& operator<<(const string& s) { return _out<< s; }
private:
  Log operator=(const Log&);
};
 
class FileLog: public LogBase {
  const string _filename;
  ofstream _out;
public:
  FileLog(const string& file): _filename(file), _out(file.c_str())
  {
    if (!_out.is_open())
      throw runtime_error("File open failure");
  }
 
  ostream& operator<<(const string& s) { return _out<< s; }
private:
  FileLog(const FileLog&);
  FileLog operator=(const FileLog&);
};

FileLog fl ("LogOne.txt");
FileLog fl2( "LogTwo.txt" );
 
MulitiLog ml;
ml.add( fl );
ml.add( fl2);
 
ml<<"Write this to both logs"<<endl;
ml<<"blah1"< " blah2"<<endl;

class MultiLog
{
		 vector<Log*> logs;
	public:
		//etc addLog, other functions.
	 ostream & operator<<(const string &s )
	 {
	 for ( int i=0;i< logs.size();i++)
		{
				*logs[i]<<s;
		}
 
	 //WHAT DO I RETURN HERE? (considering I want to handle endl, etc...)
 
	 }
 
};

#include <iostream>
#include <string>
 
using namespace std;
 
namespace jsw {
  class DualLog {
    ostream& _o1;
    ostream& _o2;
  public:
    DualLog(ostream& o1, ostream& o2)
      : _o1(o1), _o2(o2)
    {};
 
    // Redefine the no-argument manipulator controller
    DualLog& operator<<(DualLog& (*manip)(DualLog&))
    {
      return manip(*this);
    }
 
    DualLog& operator<<(const string& s)
    {
      _o1<< s;
      _o2<< s;
 
      return *this;
    }
 
    // For proper definition of endl
    void flush()
    {
      _o1.flush();
      _o2.flush();
    }
  };
 
  // DualLog specialized manipulator
  DualLog& endl(DualLog& log)
  {
    log<<"\n";
    log.flush();
 
    return log;
  }
}
 
int main()
{
  jsw::DualLog log(cout, cerr);
 
  log<<"This is a test"<<jsw::endl;
  log<<"Another test"<<jsw::endl;
  log<<"Last test"<<jsw::endl;
}

#include <iostream>
#include <vector>
 
class A {
  std::vector<std::ostream*> _o;
public:
  void add(std::ostream *o) { _o.push_back(o); }
  std::ostream& operator[](int i) { return *_o[i]; }
};
 
int main()
{
  A a;
 
  a.add(&std::cout);
  a.add(&std::cerr);
 
  a[0]<<"This is a test"<<std::endl;
  a[1]<<"Another test"<<std::endl;
}