#include <boost/thread.hpp>

namespace renwin
{
    // calls glfwInit on construction and glfwTerminate on destruction
    class GLFWInstance
    {
        public:
        GLFWInstance() { glfwInit(); };
        ~GLFWInstance() { glfwTerminate(); };
    };
    class Window // THIS IS THE ERROR
    {
        public:
        // constructs window
        Window(const std::string &appTitle,math::vector2i &resolution,bool isFullscreen);
        // sets the window dimensions
        void SetResolution(math::vector2i &resolution);
        // swaps the display buffers
        void SwapBuffers() const { glfwSwapBuffers(); };
        // issues request to close window
        void Quit() {};
        private:
        boost::mutex mutex; // thread mutex for window // THIS IS THE ERROR TOO
        GLFWInstance glfwIns; // glfw Instance
    };
}

// reads count objects into output iterator dest
template <typename Stream,typename OutputIterator,typename ValueT>
void Read(Stream &s,OutputIterator &dest, boost::uint32_t count)
{
	std::iterator_traits<OutputIterator>::value_type temp; // THIS IS THE ERROR
	while (count--)
	{
		Read(s,temp);
		*dest++=temp;
	}
}

namespace renwin
{
    lg::Log<std::fstream> Log()
    {
        boost::shared_ptr<std::fstream> pLogFile(new std::fstream("log.txt",std::ios::out|std::ios::app));
        return lg::Log<std::fstream>(pLogFile,"PakFile");
    }
}

using namespace renwin;

Window::Window(const std::string &appTitle,math::vector2i &resolution,bool isFullscreen)
{
    if( !glfwOpenWindow( resolution[math::X], resolution[math::Y], 0, 0, 0, 0, 16, 0, (isFullscreen ? GLFW_FULLSCREEN : GLFW_WINDOW) ) );
       throw ex::open_failed_error(Log(),std::string("Failed to open window: ")+appTitle); // THIS IS THE ERROR
    glfwSetWindowTitle(appTitle.c_str());
}

#pragma once

namespace lg
{
	class endl
	{
	};

	template <typename Stream>
	Stream& operator << (Stream& os,const endl& end) { os<<")>-"<<std::endl;return os; };
	template <typename Stream>
	class Log
	{
	public:
		Log(boost::shared_ptr<Stream> pOutputStream,const std::string ownerLabel) : ownerLbl(ownerLabel), pLS(pOutputStream) { };
		~Log() { pLS->flush(); }; // writes output to log

		// returns stream for logging errors
		Stream &Error(void) { (*pLS)<<"-<("<<ownerLbl<<"-Error: ";pLS->flush();return *pLS; };
		// returns stream for logging warnings
		Stream &Warning(void) { (*pLS)<<"-<("<<ownerLbl<<"-Warning: ";pLS->flush();return *pLS; };
		// returns stream for logging messages
		Stream &Message(void) { (*pLS)<<"-<("<<ownerLbl<<"-Message: ";pLS->flush();return *pLS; };

	private:
		boost::shared_ptr<Stream> pLS; // pointer to stream for log output
		std::string ownerLbl; // string label for owner of log
	};
};

class open_failed_error : public write_error{public:	open_failed_error throw() {};	virtual ~read_only_error() throw() {};	template<typename LOG>	open_failed_error &log,std::string msg) { Log(*this,log,msg); };	template<typename LOG,typename T>	open_failed_error &log,T &t,std::string msg) { Log(*this,log,t,msg); };	virtual const char *ExName() { return "write attempt to read only data"; }; // name of exception};

//open_failed_error throw() {};open_failed_error() throw() {};//open_failed_error &log,std::string msg) { Log(*this,log,msg); };open_failed_error(const LOG &log,std::string msg) { Log(*this,log,msg); };//open_failed_error &log,T &t,std::string msg) { Log(*this,log,t,msg); };open_failed_error(const LOG &log,T &t,std::string msg) { Log(*this,log,t,msg); };