xref: /third_party/boost/libs/iostreams/test/detail/closable.hpp

/*
 * Distributed under the Boost Software License, Version 1.0.(See accompanying
 * file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt.)
 *
 * See http://www.boost.org/libs/iostreams for documentation.
 *
 * Defines a large collection of closable filters and devices that
 * execute instances of boost::iostreams::test::operation upon
 * closre(). Used to verify that filters and devices are closed
 * correctly by the iostreams library
 *
 * File:        libs/iostreams/test/detail/closable.hpp
 * Date:        Sun Dec 09 16:12:23 MST 2007
 * Copyright:   2007-2008 CodeRage, LLC
 * Author:      Jonathan Turkanis
 * Contact:     turkanis at coderage dot com
 */

#ifndef BOOST_IOSTREAMS_TEST_CLOSABLE_HPP_INCLUDED
#define BOOST_IOSTREAMS_TEST_CLOSABLE_HPP_INCLUDED

#include <boost/iostreams/categories.hpp>
#include <boost/iostreams/char_traits.hpp>  // EOF
#include <boost/iostreams/concepts.hpp>
#include <boost/iostreams/detail/ios.hpp>
#include "./operation_sequence.hpp"

namespace boost { namespace iostreams { namespace test {

template<typename Category>
class closable_device { };

// Source
template<>
class closable_device<input> : public source {
public:
    closable_device(operation close) : close_(close) { }
    std::streamsize read(char*, std::streamsize) { return -1; }
    void close() { close_.execute(); }
private:
    operation close_;
};

// Sink
template<>
class closable_device<output> : public sink {
public:
    closable_device(operation close) : close_(close) { }
    std::streamsize write(const char*, std::streamsize) { return 0; }
    void close() { close_.execute(); }
private:
    operation close_;
};

struct borland_output { };

// Copy of closable_device<output>, for Borland <= 5.8.2
template<>
class closable_device<borland_output> : public sink {
public:
    closable_device(operation close) : close_(close) { }
    std::streamsize write(const char*, std::streamsize) { return 0; }
    void close() { close_.execute(); }
private:
    operation close_;
};

// Bidirectional device
template<>
class closable_device<bidirectional> : public device<bidirectional> {
public:
    closable_device(operation close_input, operation close_output)
        : close_input_(close_input), close_output_(close_output)
        { }
    std::streamsize read(char*, std::streamsize) { return -1; }
    std::streamsize write(const char*, std::streamsize) { return 0; }
    void close(BOOST_IOS::openmode which)
    {
        switch (which) {
        case BOOST_IOS::in:
            close_input_.execute();
            break;
        case BOOST_IOS::out:
            close_output_.execute();
            break;
        default:
            break;
        }
    }
private:
    operation close_input_;
    operation close_output_;
};

// Seekable device
template<>
class closable_device<seekable> : public device<seekable> {
public:
    closable_device(operation close) : close_(close) { }
    std::streamsize read(char*, std::streamsize) { return -1; }
    std::streamsize write(const char*, std::streamsize) { return 0; }
    stream_offset seek(stream_offset, BOOST_IOS::seekdir) { return 0; }
    void close() { close_.execute(); }
private:
    operation close_;
};

struct direct_input
    : input, device_tag, closable_tag, direct_tag
    { };
struct direct_output
    : output, device_tag, closable_tag, direct_tag
    { };
struct direct_bidirectional
    : bidirectional, device_tag, closable_tag, direct_tag
    { };
struct direct_seekable
    : seekable, device_tag, closable_tag, direct_tag
    { };

// Direct source
template<>
class closable_device<direct_input> {
public:
    typedef char          char_type;
    typedef direct_input  category;
    closable_device(operation close) : close_(close) { }
    std::pair<char*, char*> input_sequence()
    { return std::pair<char*, char*>(static_cast<char*>(0), static_cast<char*>(0)); }
    void close() { close_.execute(); }
private:
    operation close_;
};

// Direct sink
template<>
class closable_device<direct_output> {
public:
    typedef char           char_type;
    typedef direct_output  category;
    closable_device(operation close) : close_(close) { }
    std::pair<char*, char*> output_sequence()
    { return std::pair<char*, char*>(static_cast<char*>(0), static_cast<char*>(0)); }
    void close() { close_.execute(); }
private:
    operation close_;
};

// Direct bidirectional device
template<>
class closable_device<direct_bidirectional> {
public:
    typedef char                  char_type;
    typedef direct_bidirectional  category;
    closable_device(operation close_input, operation close_output)
        : close_input_(close_input), close_output_(close_output)
        { }
    std::pair<char*, char*> input_sequence()
    { return std::pair<char*, char*>(static_cast<char*>(0), static_cast<char*>(0)); }
    std::pair<char*, char*> output_sequence()
    { return std::pair<char*, char*>(static_cast<char*>(0), static_cast<char*>(0)); }
    void close(BOOST_IOS::openmode which)
    {
        switch (which) {
        case BOOST_IOS::in:
            close_input_.execute();
            break;
        case BOOST_IOS::out:
            close_output_.execute();
            break;
        default:
            break;
        }
    }
private:
    operation close_input_;
    operation close_output_;
};

// Direct seekable device
template<>
class closable_device<direct_seekable> {
public:
    typedef char             char_type;
    typedef direct_seekable  category;
    closable_device(operation close) : close_(close) { }
    std::pair<char*, char*> input_sequence()
    { return std::pair<char*, char*>(static_cast<char*>(0), static_cast<char*>(0)); }
    std::pair<char*, char*> output_sequence()
    { return std::pair<char*, char*>(static_cast<char*>(0), static_cast<char*>(0)); }
    void close() { close_.execute(); }
private:
    operation close_;
};

template<typename Mode>
class closable_filter { };

// Input filter
template<>
class closable_filter<input> : public input_filter {
public:
    closable_filter(operation close) : close_(close) { }

    template<typename Source>
    int get(Source&) { return EOF; }

    template<typename Source>
    void close(Source&) { close_.execute(); }
private:
    operation close_;
};

// Output filter
template<>
class closable_filter<output> : public output_filter {
public:
    closable_filter(operation close) : close_(close) { }

    template<typename Sink>
    bool put(Sink&, char) { return true; }

    template<typename Sink>
    void close(Sink&) { close_.execute(); }
private:
    operation close_;
};

// Bidirectional filter
template<>
class closable_filter<bidirectional> : public filter<bidirectional> {
public:
    closable_filter(operation close_input, operation close_output)
        : close_input_(close_input), close_output_(close_output)
        { }

    template<typename Source>
    int get(Source&) { return EOF; }

    template<typename Sink>
    bool put(Sink&, char) { return true; }

    template<typename Device>
    void close(Device&, BOOST_IOS::openmode which)
    {
        switch (which) {
        case BOOST_IOS::in:
            close_input_.execute();
            break;
        case BOOST_IOS::out:
            close_output_.execute();
            break;
        default:
            break;
        }
    }
private:
    operation close_input_;
    operation close_output_;
};

// Seekable filter
template<>
class closable_filter<seekable> : public filter<seekable> {
public:
    closable_filter(operation close) : close_(close) { }
    std::streamsize read(char*, std::streamsize) { return -1; }

    template<typename Source>
    int get(Source&) { return EOF; }

    template<typename Sink>
    bool put(Sink&, char) { return true; }

    template<typename Device>
    stream_offset seek(Device&, stream_offset, BOOST_IOS::seekdir)
    {
        return 0;
    }

    template<typename Device>
    void close(Device&) { close_.execute(); }
private:
    operation close_;
};

// Dual-use filter
template<>
class closable_filter<dual_use> {
public:
    typedef char char_type;
    struct category
        : filter_tag,
          dual_use,
          closable_tag
        { };
    closable_filter(operation close_input, operation close_output)
        : close_input_(close_input), close_output_(close_output)
        { }

    template<typename Source>
    int get(Source&) { return EOF; }

    template<typename Sink>
    bool put(Sink&, char) { return true; }

    template<typename Device>
    void close(Device&, BOOST_IOS::openmode which)
    {
        switch (which) {
        case BOOST_IOS::in:
            close_input_.execute();
            break;
        case BOOST_IOS::out:
            close_output_.execute();
            break;
        default:
            break;
        }
    }
private:
    operation close_input_;
    operation close_output_;
};

// Symmetric filter
class closable_symmetric_filter {
public:
    typedef char char_type;
    closable_symmetric_filter(operation close) : close_(close) { }
    bool filter( const char*&, const char*,
                 char*&, char*, bool )
    {
        return false;
    }
    void close() { close_.execute(); }
private:
    operation close_;
};

} } } // End namespaces test, iostreams, boost.

#endif // #ifndef BOOST_IOSTREAMS_TEST_CLOSABLE_HPP_INCLUDED