namespace boost {
  template<typename Input, typename Output> struct codecvt_in_converter;
  template<typename Input, typename Output> struct codecvt_out_converter;
}

BOOST_CONVERTER_DEF(converter_name, convert_name)
BOOST_CONVERTER_TPL_DEF(converter_name, convert_name)
BOOST_ONEMANYCONVERTER_DEF(converter_name, convert_name)
BOOST_ONEMANYCONVERTER_TPL_DEF(converter_name, convert_name)

namespace boost {
  template<typename OneManyConverter> struct one_many_converter;
  template<typename P1, typename P2> struct multi_converter;
  template<typename P1, typename P2> struct converted_converter;
  template<typename T> struct cast_converter;
  template<typename Range, typename Converter> struct converted_range;
  template<typename P1, typename P2> 
    multi_converter< P1, P2 > make_multi_converter(P1, P2);
  template<typename P1, typename P2> 
    converted_converter< P1, P2 > make_converted_converter(P1, P2);
  template<typename It, typename Converter> 
    convert_iterator< It, Converter > 
    make_convert_iterator(It, It, It, Converter);
  template<typename Range, typename Converter, typename OutputIterator> 
    OutputIterator convert(const Range &, Converter, OutputIterator);
  namespace adaptors {
    template<typename Range, typename Converter> 
      converted_range< const Range, Converter > 
      convert(const Range &, Converter);
    template<typename Range, typename Converter> 
      converted_range< Range, Converter > convert(Range &, Converter);
    template<typename OutputIterator, typename OneManyConverter> 
      convert_output_iterator< OutputIterator, OneManyConverter > 
      convert_output(OutputIterator, OneManyConverter);
  }
}

namespace boost {
  template<typename It, typename Converter> struct convert_iterator;
  template<typename OutputIterator, typename OneManyConverter> 
    struct convert_output_iterator;
}

namespace boost {
  template<typename InternT, typename B1, typename P1, typename B2, 
           typename P2> 
    struct converter_codecvt;
}

namespace boost {
  template<typename X> struct ConverterConcept;
  template<typename X> struct OneManyConverterConcept;
}

BOOST_SEGMENTER_DEF(segmenter_name, segment_name)

namespace boost {
  template<typename Converter> struct converter_segmenter;
  template<typename BoundaryChecker> struct boundary_segmenter;
  template<typename B1, typename Converter, typename B2> 
    struct multi_boundary;
  template<typename Converter, typename Segmenter> struct converted_segmenter;
  template<typename Range, typename Segmenter> struct segmented_range;
  template<typename Converter> 
    converter_segmenter< Converter > make_converter_segmenter(Converter);
  template<typename BoundaryChecker> 
    boundary_segmenter< BoundaryChecker > 
    make_boundary_segmenter(BoundaryChecker);
  template<typename B1, typename Converter, typename B2> 
    multi_boundary< B1, Converter, B2 > make_multi_boundary(B1, Converter, B2);
  template<typename Converter, typename Segmenter> 
    converted_segmenter< Converter, Segmenter > 
    make_converted_segmenter(Converter, Segmenter);
  template<typename It, typename Segmenter> 
    segment_iterator< It, Segmenter > 
    make_segment_iterator(It, It, It, Segmenter);
  namespace adaptors {
    template<typename Range, typename Segmenter> 
      segmented_range< const Range, Segmenter > 
      segment(const Range &, Segmenter);
    template<typename Range, typename Segmenter> 
      segmented_range< Range, Segmenter > segment(Range &, Segmenter);
  }
}

namespace boost {
  template<typename It, typename Segmenter> struct segment_iterator;
}

namespace boost {
  template<typename X> struct SegmenterConcept;
  template<typename X> struct BoundaryCheckerConcept;
}