1

我想找到/实现一个支持多个写入点的 c++（希望是 stl）兼容流。我用多个写作点的意思很容易用下面的例子来解释。假设您想以 java 语言生成源代码文件。当您想要编写一行依赖于特定包的代码时，您可以编写：

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

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

请注意，您可能已经定义了其他类。新类需要到底部，但导入需要到顶部。

我知道我可以通过其他方式解决这个问题。我认为如果我能用一些 stl 流模式来解决它会很酷。

带有一些过滤功能的 boost tee 是否可行？

注意：该位置可以基于分析输入或指定专用类型，在这种情况下，我可以检查字符串是否以 import 开头或者我要编写

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

其中 Import 是一个相应序列化的类。

你感觉如何——这值得付出努力吗？

4

1 回答 1

0

按照复杂度递增的顺序：

首先，只需为您可能要编写的每个位置使用不同的变量。然后在完成后将您放入每个流中的数据缝合在一起。

作为第二级复杂性，存储 a std::tuple< std::ofstream, std::ofstream, std::ofstream > straems，然后用于std::get<0>(streams)获取第一个。如果您想要名称，请使用 anenum { 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";

这可能是也可能不是您正在寻找的东西。

这远未调试，可能还没有编译。

诚实地？每个子流只有一个不同的变量。无论如何，您最终都希望手动将它们重新集成在一起。

于 2013-06-22T02:04:13.263 回答