C++ 다중 쓰기 포인트 스트림

Question

여러 쓰기 포인트를 지원하는 C++ (호환 가능 stl) 호환 스트림을 찾고 구현하고 싶습니다. 다음 예를 통해 여러 개의 쓰기 포인트를 설명하는 것이 쉽습니다. 자바 언어로 된 소스 코드 파일을 생성하고 싶다고하자. 당신은 당신이 특정 패키지에 대한 종속성이 한 줄의 코드를 작성하려는 지점에 도착하면 - 당신은 쓸 수 : 이미 정의 된 다른 클래스를 가질 수있다

stream << "import java.applet.*;"; 

stream << "public class MyApplet extends Applet {"; 
stream << "..."; 
stream << "}"; 

참고. 새로운 계층은 맨 아래로 가야하지만 가져 오기는 맨 위로 가야합니다.

다른 방법으로이 문제를 해결할 수 있음을 알고 있습니다. 비록 내가 몇 가지 stl 패턴으로 해결할 수 있다면 멋지다고 생각한다.

부스트 티를 사용할 수있는 필터링 기능이 있습니까?

참고 : 위치는 입력을 분석하거나 문자열을 가져 오기 시작하면 내가 체크를 가질 수 또는 내가 가져 오기는 클래스입니다

stream << Import("java.applet.*); 

를 작성,이 경우 전용 유형을 지정에 따라 수 그에 따라 직렬화된다.

기분이 어떨까요? 노력할만한 가치가있는 것입니까? 증가하는 복잡성 위해

Answer 1

:

첫째, 당신이 기록 할 수있는 장소의 각각 다른 변수를 사용합니다. 완료되면 각 스트림에 넣은 데이터를 결합하십시오.

두 번째 수준의 복잡성으로는 std::tuple< std::ofstream, std::ofstream, std::ofstream > straems을 저장하고 std::get<0>(streams)을 사용하여 첫 번째 레벨을 얻습니다. 이름을 원하면 enum { first_stream, second_stream_name, third_stream_name }을 사용하고 std::get으로 전달하십시오.

가장 복잡한 대답은 ... 엉망입니다.

첫 번째 템플릿 메타 프로그래밍의 상용구 : 이제

template<typename T, typename Tags, typename=void> 
struct index_of {}; 
template<typename T, template<typename...>class Pack, typename Tag0, typename... Tags> 
struct index_of<T, Pack<Tag0, Tags...>, typename std::enable_if< std::is_same<T, Tag0>::value >::type > 
: std::integral_constant< int, 0 > {}; 
template<typename T, template<typename...>class Pack, typename Tag0, typename... Tags> 
struct index_of<T, Pack<Tag0, Tags...>, typename std::enable_if< !std::is_same<T, Tag0>::value >::type > 
: std::integral_constant< int, index_of<T, Pack<Tags...> >::value + 1 > {}; 

template<typename Src, template<typename...>class Pack> 
struct copy_types {}; 

template<template<typename...>class Lhs, typename... Ts, template<typename...>class Target> 
struct copy_types< Lhs<Ts...>, Target > { 
    typedef Target<Ts...> type; 
}; 
template<typename Src, template<typename...>class Pack> 
using CopyTypes = typename copy_types<Src, Pack>::type; 

template<typename Pack, typename T> 
struct append {}; 
template<template<typename...>class Pack, typename... Ts, typename T> 
struct append<Pack<Ts...>, T> { 
    typedef Pack<Ts..., T> type; 
}; 
template<typename Pack, typename T> 
struct Append = typename append<Pack, T>::type; 

template<template<typename...>class Pack, typename T, std::size_t N> 
struct repeat { 
    typedef Append< repeat< Pack, T, N-1 >::type, T > type; 
}; 
template<template<typename...>class Pack, typename T> 
struct repeat< Pack, T, 0 > { 
    typedef Pack<> type; 
}; 
template<template<typename...>class Pack, typename T, std::size_t N> 
using Repeat = typename repeat<Pack, T, N>::type; 

, 재미 있기 때문에, 태그가 튜플 :

template<typename T, typename Tags> 
struct type_based_map; 

template<typename T, template<typename...>class Pack, typename... Tags> 
struct type_based_map< T, Pack<Tags...> > { 
    Repeat< std::tuple, T, sizeof...(Tags) > data; 
    template<typename Tag> 
    T& get() { 
    return std::get< index_of< Tag, std::tuple<Tags...> >::value >(data); 
    } 
    template<typename Tag> 
    T& get() const { 
    return std::get< index_of< Tag, std::tuple<Tags...> >::value >(data); 
    } 
    template<typename... Args, typename=typename std::enable_if< sizeof...(Args) == sizeof...(Tags) >::type > 
    explicit type_based_map(Args&&... args):data(std::forward<Args>(args)...) {} 
    type_based_map(type_based_map&&) = default; 
    type_based_map(type_based_map const&) = default; 
    type_based_map(type_based_map&) = default; 
}; 

이제, 아래 고기와 감자합니다. 폴리 스트림 :

버그가 제거되면, 당신이 구문을 제공

template<typename Tag, typename U> 
struct TaggedData { 
    U&& data; 
    explicit TaggedData(U&& u):data(std::forward<U>(u)) {} 
    TaggedData(TaggedData &&) = default; 
    TaggedData(TaggedData const&) = default; 
    TaggedData(TaggedData &) = default; 
}; 
template<typename Tag> 
struct DataTagger { 
    template<typename U> 
    TaggedData<U> operator()(U&& u) const { 
    return {std::forward<U>(u)}; 
    } 
}; 

template<typename base_stream, typename Tags> 
struct tagged_stream: type_based_map< base_stream, Tags > 
{ 
    using type_based_map< base_stream, Tags >::type_based_map< base_stream, Tags >; 
}; 
template<typename base_stream, typename Tags, typename Tag, typename U> 
auto operator<<(tagged_stream<base_stream, Tags>& stream, TaggedData<Tag, U> data) 
    ->declval(stream.get<Tag>() << std::forward<U>(data.u)) 
    { return (stream.get<Tag>() << std::forward<U>(data.u)); } 

: 또는 당신이 찾고있는 무엇을하지 않을 수 있습니다

struct bob {}; 
struct harry {}; 
struct alice {}; 
static DataTagger<bob> Bob; 
static DataTagger<harry> Harry; 
static DataTagger<alice> Alice; 

typedef tagged_stream< std::ofstream, std::tuple<bob, harry, alice> > multi_out; 

multi_out os; 
os.get<bob>().open("bob.txt"); 
os.get<harry>().open("harry.txt"); 
os.get<alice>().open("alice.txt"); 
os << Bob(7) << " is seven in Bob\n"; 
os << Harry("hello") << " in Harry\n"; 
os << Alice(3.14) << " is baked by Alice\n"; 

.

이것은 디버깅과 거리가 멀고 아직 컴파일되지 않은 것 같습니다.

솔직히? 하위 스트림마다 다른 변수 만 있으면됩니다. 아무 래도 수동으로 다시 통합 할 수 있습니다.