TextOutput.h

Go to the documentation of this file.

#ifndef G3D_TextOutput_h
#define G3D_TextOutput_h

#include "G3D/platform.h"
#include "G3D/Array.h"
#include <string>

namespace G3D {

class TextOutput {
public:

 class Settings {
 public:
 enum WordWrapMode {WRAP_NONE, WRAP_WITHOUT_BREAKING, WRAP_ALWAYS};

 WordWrapMode wordWrap;

 bool allowWordWrapInsideDoubleQuotes;

 int numColumns;

 int spacesPerIndent;

 enum NewlineStyle {NEWLINE_WINDOWS, NEWLINE_UNIX};

 NewlineStyle newlineStyle;

 bool convertNewlines;

 std::string trueSymbol;

 std::string falseSymbol;

 Settings() :
 wordWrap(WRAP_WITHOUT_BREAKING),
 allowWordWrapInsideDoubleQuotes(false),
 numColumns(80),
 spacesPerIndent(4),
 convertNewlines(true),
 trueSymbol("true"),
 falseSymbol("false") {
 #ifdef G3D_WINDOWS
 newlineStyle = NEWLINE_WINDOWS;
 #else
 newlineStyle = NEWLINE_UNIX;
 #endif
 }
 };

private:

 bool startingNewLine;

 int currentColumn;

 bool inDQuote;

 std::string filename;

 Array<char> data;

 Settings option;

 int indentLevel;

 void setIndentLevel(int i);

 int indentSpaces;

 std::string newline;

 int m_currentLine;

 void setOptions(const Settings& _opt);

 void convertNewlines(const std::string& in, std::string& out);

 void wordWrapIndentAppend(const std::string& str);

 void indentAppend(char c);

public:

 explicit TextOutput(const std::string& filename, const Settings& options = Settings());

 explicit TextOutput(const Settings& options = Settings());

 int line() const {
 return m_currentLine;
 }

 void commit(bool flush = true);

 void commitString(std::string& string);

 void pushIndent();

 void popIndent();

 std::string commitString();

 void writeString(const std::string& string);

 void writeBoolean(bool b);

 void writeNumber(double n);

 void writeNumber(int n);

 void writeNewline();
 void writeNewlines(int numLines);

 bool deleteSpace();

 void writeSymbol(const std::string& string);

 void writeSymbol(char s);

 void writeSymbols(
 const std::string& a,
 const std::string& b = "",
 const std::string& c = "",
 const std::string& d = "",
 const std::string& e = "",
 const std::string& f = "");

 void __cdecl printf(const char* fmt, ...)
 G3D_CHECK_PRINTF_METHOD_ARGS;

 // Can't pass by reference because that confuses va_start
 void __cdecl printf(const std::string fmt, ...);
 void __cdecl vprintf(const char* fmt, va_list argPtr) 
 G3D_CHECK_VPRINTF_METHOD_ARGS;
};

// Primitive serializers
void serialize(const bool& b, TextOutput& to);
void serialize(const int& b, TextOutput& to);
void serialize(const uint8& b, TextOutput& to);
void serialize(const double& b, TextOutput& to);
void serialize(const float& b, TextOutput& to);
void serialize(const std::string& b, TextOutput& to);
void serialize(const char* b, TextOutput& to);

}

#endif