XmlDataFactory.hpp

Go to the documentation of this file.

 
#pragma once
 
#include <alib/string>
#include <alib/deque>
#include <alib/measure>
 
#include <sax/Token.h>
#include <sax/SaxParseInterface.h>
#include <sax/SaxComposeInterface.h>
#include <core/xmlApi.hpp>
#include <measure/xml/MeasurementResults.hpp>
 
namespace factory {
 
class XmlDataFactory {
public:
 
    class fromFile {
        const std::string & filename;
 
    public:
        fromFile ( const std::string & file ) : filename ( file ) {
        }
 
        template < class T >
        operator T ( ) {
            return fromTokens ( sax::SaxParseInterface::parseFile ( filename ) );
        }
    };
 
    class fromString {
        const std::string & string;
 
    public:
        fromString ( const std::string & str ) : string ( str ) {
        }
 
        template < class T >
        operator T ( ) {
            return fromTokens ( sax::SaxParseInterface::parseMemory ( string ) );
        }
    };
 
    class fromStdin {
    public:
        template < class T >
        operator T ( ) {
            return fromTokens ( sax::SaxParseInterface::parseStdin ( ) );
        }
    };
 
    class fromStream {
        ext::istream & in;
 
    public:
        fromStream ( ext::istream & i ) : in ( i ) {
        }
 
        template < class T >
        operator T ( ) {
            return fromTokens ( sax::SaxParseInterface::parseStream ( in ) );
 
        }
    };
 
    class fromTokens {
        ext::deque < sax::Token > tokens;
 
    public:
        fromTokens ( ext::deque < sax::Token > && toks ) : tokens ( std::move ( toks ) ) {
        }
 
        template < class T >
        operator T ( ) {
            core::xmlApiInputContext context ( tokens.begin ( ) );
 
            if ( context == tokens.end ( ) ) throw exception::CommonException ( "Empty tokens list" );
 
            measurements::start ( "XML Parser", measurements::Type::INIT );
            T res = core::xmlApi < T >::parse ( context );
            measurements::end ( );
 
            if ( context != tokens.end ( ) ) throw exception::CommonException ( "Unexpeted tokens at the end of the xml" );
 
            return res;
        }
    };
 
    template < class T >
    static bool first ( const ext::deque < sax::Token > & tokens ) {
        if( tokens.empty ( ) ) throw exception::CommonException ( "Empty tokens list" );
 
        return core::xmlApi < T >::first ( tokens.begin ( ) );
    }
 
    template < class T >
    static void toFile ( const T & data, const std::string & filename ) {
        ext::deque < sax::Token > tokens = toTokens < T > ( data );
        sax::SaxComposeInterface::composeFile ( filename, tokens );
    }
 
    template < class T >
    static std::string toString ( const T & data ) {
        ext::deque < sax::Token > tokens = toTokens < T > ( data );
        return sax::SaxComposeInterface::composeMemory ( tokens );
    }
 
    template < class T >
    static void toStdout ( const T & data ) {
        ext::deque < sax::Token > tokens = toTokens < T > ( data );
        sax::SaxComposeInterface::composeStdout ( tokens );
    }
 
    template < class T >
    static void toStream ( const T & data, ext::ostream & out ) {
        ext::deque < sax::Token > tokens = toTokens < T > ( data );
        sax::SaxComposeInterface::composeStream ( out, tokens );
    }
 
    template < class T >
    static ext::deque < sax::Token > toTokens ( const T & data ) {
        core::xmlApiOutputContext context;
 
        measurements::start ( "XML Composer", measurements::Type::FINALIZE );
        core::xmlApi < T >::compose ( context, data );
        measurements::end ( );
 
        ext::deque < sax::Token > res = std::move ( context ); // FIXME present only not to get conflicting varnings from g++ and clang++ if "return context;" is used
        return res;
    }
 
};
 
template < >
inline XmlDataFactory::fromTokens::operator measurements::MeasurementResults ( ) {
    core::xmlApiInputContext context ( tokens.begin ( ) );
 
    if ( context == tokens.end ( ) ) throw exception::CommonException ( "Empty tokens list" );
 
    measurements::MeasurementResults res = core::xmlApi < measurements::MeasurementResults >::parse ( context );
 
    if ( context != tokens.end ( ) ) throw exception::CommonException ( "Unexpeted tokens at the end of the xml" );
 
    return res;
}
 
template < >
inline ext::deque < sax::Token > XmlDataFactory::toTokens ( const measurements::MeasurementResults & data ) {
    core::xmlApiOutputContext context;
 
    core::xmlApi < measurements::MeasurementResults >::compose ( context, data );
 
    ext::deque < sax::Token > res = std::move ( context ); // FIXME present only not to get conflicting varnings from g++ and clang++ if "return context;" is used
    return res;
}
 
} /* namespace factory */