## リファレンス

### Header <hamigaki/iostreams/device/file.hpp>

    namespace hamigaki {
      namespace iostreams {
        class file_source;
        class file_sink;
      }
    }

### Header <hamigaki/iostreams/device/tmp_file.hpp>

    namespace hamigaki {
      namespace iostreams {
        class tmp_file;
      }
    }

### Header <hamigaki/iostreams/device/zero.hpp>

    namespace hamigaki {
      namespace iostreams {
        template<typename Ch> class basic_zero_source;

        typedef basic_zero_source<char> zero_source;
        typedef basic_zero_source<wchar_t> wzero_source;
      }
    }

### Header <hamigaki/iostreams/filter/base64.hpp>

    namespace hamigaki {
      namespace iostreams {
        class base64_encoder;
        class base64_decoder;
        class urlsafe_base64_encoder;
        class urlsafe_base64_decoder;
      }
    }

### Header <hamigaki/iostreams/background_copy.hpp>

    namespace hamigaki {
      namespace iostreams {
        template<typename ExceptionStorage = hamigaki::thread::exception_storage>
          class basic_background_copy;

        typedef basic_background_copy<> background_copy;
      }
    }

### Header <hamigaki/iostreams/catable.hpp>

    HAMIGAKI_IOSTREAMS_CATABLE(source, arity)

### Header <hamigaki/iostreams/concatenate.hpp>

    namespace hamigaki {
      namespace iostreams {
        template<typename Source1, typename Source2> class concatenation;
        template<typename Source1, typename Source2>
          concatenation<Source1, Source2>
          concatenate(const Source1&, const Source2&);
      }
    }

### Header <hamigaki/iostreams/demultiplexer.hpp>

    namespace hamigaki {
      namespace iostreams {
        template<typename CharT> class basic_demultiplexer;
      }
    }

### Header <hamigaki/iostreams/dont_close.hpp>

    namespace hamigaki {
      namespace iostreams {
        template<typename Device> class dont_close_device;
        template<typename Device>
          dont_close_device<Device> dont_close(const Device&);
      }
    }

### Header <hamigaki/iostreams/lazy_restrict.hpp>

    namespace hamigaki {
      namespace iostreams {
        template<typename Device> class lazy_restriction;
        template<typename Device>
          lazy_restriction<Device>
          lazy_restrict(Device&, boost::iostreams::stream_offset,
                        boost::iostreams::stream_offset = -1);
      }
    }

### Header <hamigaki/iostreams/multiplexer.hpp>

    namespace hamigaki {
      namespace iostreams {
        template<typename CharT> class basic_multiplexer;
      }
    }

### Header <hamigaki/iostreams/relative_restrict.hpp>

    namespace hamigaki {
      namespace iostreams {
        template<typename Device> class relative_restriction;
        template<typename Device>
          relative_restriction<Device>
          relative_restrict(Device&, boost::iostreams::stream_offset,
                            boost::iostreams::stream_offset = -1);
      }
    }

### Header <hamigaki/iostreams/repeat.hpp>

    namespace hamigaki {
      namespace iostreams {
        template<typename SeekableSource> class repetition;
        template<typename SeekableSource>
          repetition<SeekableSource> repeat(const SeekableSource&, int);
      }
    }

### Header <hamigaki/iostreams/tiny_restrict.hpp>

    namespace hamigaki {
      namespace iostreams {
        template<typename Device> class tiny_restriction;
        template<typename Device>
          tiny_restriction<Device>
          tiny_restrict(const Device&, boost::iostreams::stream_offset = -1);
      }
    }

### Header <hamigaki/iostreams/traits.hpp>

    namespace hamigaki {
      namespace iostreams {
        template<typename T> struct is_input_seekable;
        template<typename T> struct is_output_seekable;
      }
    }

| 製作著作 © 2006, 2007 Takeshi Mouri