xml_stream_policy.h

Go to the documentation of this file.

// Common Text Transformation Library
// Copyright (C) 1997-2006 by Igor Kholodov. 
//
// This library is free software; you can redistribute it and/or
// modify it under the terms of the GNU Lesser General Public
// License as published by the Free Software Foundation; either
// version 2.1 of the License, or (at your option) any later version.
//
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
// Lesser General Public License for more details.
//
// You should have received a copy of the GNU Lesser General Public
// License along with this library; if not, write to the
// Free Software Foundation, Inc.,
// 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
//
// mailto:cttl@users.sourceforge.net
// http://sourceforge.net/projects/cttl/

// xml_stream_policy.h

#ifndef _XML_STREAM_POLICY_H_INCLUDED_
#define _XML_STREAM_POLICY_H_INCLUDED_

class policy_strict_stream : public policy_default
{
public:
    // how many bytes to read: anywhere from 1 byte and up...
    static const size_t item_count = 1024*16;

    // input buffer size
    static const size_t max_buffer_size = item_count + 1024;

    // read items of 1 byte in size
    static const size_t item_size = 1;

protected:
    char line_buffer[ max_buffer_size ];

    FILE *file_stream;

    edge<>& consumed_data;

public:
    policy_strict_stream( edge<>& consumed_data_ )
        :
        file_stream( NULL ),
        consumed_data( consumed_data_ )
    {
    }

    void operator=( policy_strict_stream const& ) const
    {
    }

public:
    bool init( char* file_ )
    {
        assert( file_stream == NULL );
        return( ( file_stream = fopen( file_, "r" ) ) != NULL );
    }

    template< typename UniverseT >
    size_t match( UniverseT& universe_ )
    {
        if ( file_stream && !universe_.length() ) {
            size_t numread = 0;
            if ( ( numread = fread( line_buffer, item_size, item_count, file_stream ) ) ) {
                line_buffer[ numread ] = 0x00;

#ifdef DISPOSE_CONSUMED_DATA
                assert( !consumed_data.first.offset() );
                if ( consumed_data.length() )
                    consumed_data.text( "" );
#endif // DISPOSE_CONSUMED_DATA

                // inject new data into the universe
                universe_.first.insert_stay( line_buffer );
                universe_.second.go_eof();
                assert( universe_.length() );

            } else {
                // feof returns 0 if the current position is not end of file
                assert( feof( file_stream ) );
                fclose( file_stream );
                file_stream = NULL;
            }
        }

        return universe_.first.offset();
    }
};  // struct policy_strict_stream


class policy_relaxed_stream : public policy_strict_stream
{
public:
    policy_relaxed_stream( edge<>& consumed_data_ )
        :
        policy_strict_stream( consumed_data_ )
    {
    }

    template< typename UniverseT >
    size_t match( UniverseT& universe_ )
    {
        ( true ^ ( entity( isspace ) | true ) ).match( universe_ );

        if ( this->file_stream && !universe_.length() ) {
            size_t numread = 0;
            if ( ( numread = fread( this->line_buffer, this->item_size, this->item_count, this->file_stream ) ) ) {
                this->line_buffer[ numread ] = 0x00;

#ifdef DISPOSE_CONSUMED_DATA
                assert( !consumed_data.first.offset() );
                if ( consumed_data.length() )
                    consumed_data.text( "" );
#endif // DISPOSE_CONSUMED_DATA

                // inject new data into the universe
                universe_.first.insert_stay( this->line_buffer );
                universe_.second.go_eof();
                assert( universe_.length() );

            } else {
                // feof returns 0 if the current position is not end of file
                assert( feof( file_stream ) );
                fclose( this->file_stream );
                this->file_stream = NULL;
            }
            return match( universe_ );
        }

        return universe_.first.offset();
    }
};  // struct policy_relaxed_stream


#endif //_XML_STREAM_POLICY_H_INCLUDED_

---