options::escapedIO Namespace Reference

Functions
std::istream &	operator>> (std::istream &aStream, const char *&aCstring)
std::ostream &	operator<< (std::ostream &aStream, const std::string &aString)
std::istream &	operator>> (std::istream &aStream, std::string &aString)
std::ostream &	operator<< (std::ostream &aStream, const std::chrono::system_clock::time_point &aTime)
std::istream &	operator>> (std::istream &aStream, std::chrono::system_clock::time_point &aTime)
template<class Rep , class Period >
std::ostream &	operator<< (std::ostream &aStream, const std::chrono::duration< Rep, Period > &aDuration)
template<class Rep , class Period >
std::istream &	operator>> (std::istream &aStream, std::chrono::duration< Rep, Period > &aDuration)

Function Documentation

operator<<() [1/3]

template<class Rep , class Period >

std::ostream& options::escapedIO::operator<<	(	std::ostream &	aStream,
		const std::chrono::duration< Rep, Period > &	aDuration
	)

Definition at line 46 of file OptionsChrono.h.

                                                                                                                                        {
            auto flags(aStream.flags());
            aStream << std::fixed;
            aStream << aDuration.count();
            aStream.flags(flags);
            return aStream;
        }

operator<<() [2/3]

std::ostream & options::escapedIO::operator<<	(	std::ostream &	aStream,
		const std::chrono::system_clock::time_point &	aTime
	)

Definition at line 465 of file OptionsChrono.cpp.

                                                                                                  {
            single<std::chrono::system_clock::time_point>::fDefaultValuePrinter(aStream, aTime);
            return aStream;
        }

operator<<() [3/3]

std::ostream & options::escapedIO::operator<<	(	std::ostream &	aStream,
		const std::string &	aString
	)

Definition at line 447 of file Options.cpp.

                                                                              {
            parser::fPrintEscapedString(aStream, aString);
            return aStream;
        }

References options::parser::fPrintEscapedString().

Here is the call graph for this function:

operator>>() [1/4]

std::istream & options::escapedIO::operator>>	(	std::istream &	aStream,
		const char *&	aCstring
	)

Definition at line 435 of file Options.cpp.

                                                                            {
            auto buffer = new std::string;
            aStream >> *buffer;
            if (aStream.fail()) {
                delete buffer;
            } else { // leak a string...
                aCstring = buffer->c_str();
            }
            return aStream;
        }

operator>>() [2/4]

template<class Rep , class Period >

std::istream& options::escapedIO::operator>>	(	std::istream &	aStream,
		std::chrono::duration< Rep, Period > &	aDuration
	)

Definition at line 53 of file OptionsChrono.h.

                                                                                                                                  {
            std::string buf;
            aStream >> buf;
            if (!aStream.fail()) {
                internal::parseDurationString(aDuration, buf);
            }
            return aStream;
        };

References options::internal::parseDurationString().

Here is the call graph for this function:

operator>>() [3/4]

std::istream & options::escapedIO::operator>>	(	std::istream &	aStream,
		std::chrono::system_clock::time_point &	aTime
	)

Definition at line 469 of file OptionsChrono.cpp.

                                                                                            {
            std::string buf;
            aStream >> buf;
            if (!aStream.fail()) {
                aTime = internal::fParseTimePointString(buf);
            }
            return aStream;
        }

References options::internal::fParseTimePointString().

Here is the call graph for this function:

operator>>() [4/4]

std::istream & options::escapedIO::operator>>	(	std::istream &	aStream,
		std::string &	aString
	)

Definition at line 451 of file Options.cpp.

                                                                        {
            std::istream::sentry s(aStream);
            if (s) {
                aString.clear();
                auto delimiter = aStream.peek();
                if (delimiter == '"' || delimiter == '\'') { // string is enclosed in a pair of delimiters
                    aStream.get();
                } else {
                    delimiter = '\0';
                }
                while (! aStream.eof()) {
                    auto c = aStream.peek();
                    if (c == '\n' || aStream.eof()) {
                        break;
                    }
                    aStream.get();
                    if (c == '\\') {
                        c = aStream.get();
                        switch (c) {
                            case 'a':
                                aString.push_back('\a');
                                break;
                            case 'b':
                                aString.push_back('\b');
                                break;
                            case 'f':
                                aString.push_back('\f');
                                break;
                            case 'n':
                                aString.push_back('\n');
                                break;
                            case 'r':
                                aString.push_back('\r');
                                break;
                            case 't':
                                aString.push_back('\t');
                                break;
                            case 'v':
                                aString.push_back('\v');
                                break;
                            default:
                                if (c >= '0' && c <= '7') {
                                    char ch = 0;
                                    for (int i = 0; i < 3 && c >= '0' && c <= '7'; i++) {
                                        ch = (ch << 3) | ((c - '0') & 0x7);
                                        c = aStream.get();
                                    }
                                    aString.push_back(ch);
                                } else {
                                    aString.push_back(c);
                                }
                                break;
                        }
                    } else if (c == delimiter) {
                        break;
                    } else {
                        aString.push_back(c);
                    }
                }
            }
            auto eof = aStream.eof();
            aStream.clear();
            if (eof) {
                aStream.setstate(std::ios_base::eofbit);
            };
            return aStream;
        }