D:/C++/Visualisierung/vislab/src/common.h

#pragma once


#include <windows.h>


#include <glew.h>
#include <glut.h>
#include <commdlg.h>
#include <stdlib.h>
#include <io.h>
#include <GL/glu.h>
#include <iostream>
#include <sstream>
#include <string>


#define PI 3.14159265f
#define BOUNDARY 0.9125f

template <class Type>
inline const Type fromString(const std::string & strString)
{
        Type tValue;
        std::stringstream(std::string(strString)) >> tValue;            
        return tValue;
};


template <class Type>
inline const bool fromString(Type & tValue, const std::string & strString)
{
        Type tTemp;

        std::stringstream ss;
        ss << strString;
        ss >> std::ws;

        if (ss >> tTemp)
        {
                ss >> std::ws;

                if (ss.eof())
                {
                        tValue = tTemp;
                        return true;
                }
        }

        return false;
};


template <class Type>
inline const std::string toString(const Type & tValue)
{
        std::stringstream ss;
        ss << tValue;
        return ss.str();
};


inline const std::string trimLeft( const std::string &str, const std::string &strWhitespace = "\n\r\t ")
{
        size_t uIndex = str.find_first_not_of(strWhitespace);
        if( uIndex != std::string::npos )
                return str.substr(uIndex);

        return "";
};


inline const std::string trimRight( const std::string &str, const std::string &strWhitespace = "\n\r\t ")
{
        size_t  uIndex = str.find_last_not_of(strWhitespace);
        if( uIndex != std::string::npos )
                return str.substr(0,uIndex+1);

        return str;
};


inline const std::string trim( const std::string &str, const std::string & strWhitespace = "\n\r\t ")
{
        return trimRight(trimLeft(str,strWhitespace),strWhitespace);
};



class eat
{
        friend std::istream & operator>>(std::istream &is, eat & e);

public:
        eat(const std::string & strString) : m_strString(strString)
        {
        };

private:

        void process(std::istream & is)
        {
                const unsigned int uLength = unsigned int(m_strString.size());

                if (uLength > 0)
                {
                        char c; 
                        unsigned int uIndex = 0; 

                        is >> std::ws;
                        std::ios::fmtflags f = is.flags();
                        is.unsetf(std::ios::skipws);

                        do
                        {
                                if (!(is >> c)) 
                                {
                                        break;
                                }
                                else
                                {
                                        if (c != m_strString[uIndex])
                                        {
                                                is.setstate(std::ios::failbit);
                                                break;
                                        }
                                }
                        }
                        while (++uIndex < uLength);

                        is.flags(f);

                        if (!is.fail())
                                is >> std::ws;
                }
        };

private:
        std::string m_strString;
};

inline std::istream & operator>> (std::istream &is, eat & e)
{
        e.process(is);
        return is;
}

//void renderString(void* font, const std::string input);
void printGLErrors();

char *textFileRead(char *fn);
int textFileWrite(char *fn, char *s);

void renderString(void* font, const std::string input);

---