C++ Sink类代码示例

unsigned qCreateSink(void)
{
	Sink *sink = new Sink();
	if (!sink) {
		qLog() << "qCreateSink(): failed to instantiate new sink" << flush;
		return 0;
	}
	g_Ticker.addTickee(sink->ptr());
	return sink->key();
}

void Dict::write(Sink &sink) const {
  sink.beginDict(isSimple());

  for (const_iterator it = begin(); it != end(); it++) {
    if (!it->second->canWrite(sink)) continue;
    sink.beginInsert(it->first);
    it->second->write(sink);
  }

  sink.endDict();
}

void _UnixDo(Source & so,Sink & si) {
  stringGB s;
  so >> s;
  so.shouldBeEnd();
  si.noOutput();
  system(s.value().chars());
};

void _SetWreathOrder(Source & so,Sink & si) {
  stringGB name;
  list<stringGB> L;
  so >> name;
  GBInputSpecial(L,so);
  T * p = Name2Instance<AdmissibleOrder>::s_find(name);
  if(!p) {
    vector<vector<Variable> > VARS;
    vector<AdmissibleOrder *> ORDS;
    typedef list<stringGB>::const_iterator LI;
    LI w = L.begin(), e = L.end();
    AdmissibleOrder * q;
    while(w!=e) {
      q = Name2Instance<AdmissibleOrder>::s_find((*w).value());
      ORDS.push_back(q);
      ++w;
    };
    DBG();
    p = new WreathOrder(VARS,ORDS);
    Name2Instance<AdmissibleOrder>::s_add(name,p);
  };
  GBInput(*p,so);
  so.shouldBeEnd();
  si.noOutput();
};

std::streamsize copy_impl( Source& src, Sink& snk, 
                           std::streamsize buffer_size,
                           mpl::false_, mpl::true_ )
{
    typedef typename char_type_of<Source>::type  char_type;
    typedef std::pair<char_type*, char_type*>    pair_type;
    detail::basic_buffer<char_type>  buf(buffer_size);
    pair_type                        p = snk.output_sequence();
    std::streamsize                  total = 0;
    std::ptrdiff_t                   capacity = p.second - p.first;
    while (true) {
        std::streamsize amt = 
            iostreams::read(
                src, 
                buf.data(),
                buffer_size < capacity - total ?
                    buffer_size :
                    static_cast<std::streamsize>(capacity - total)
            );
        if (amt == -1)
            break;
        std::copy(buf.data(), buf.data() + amt, p.first + total);
        total += amt;
    }
    return total;
}

void _GroebnerCutOffSum(Source & so,Sink & si) {
  int n;
  so >> n;
  so.shouldBeEnd();
  si.noOutput();
  run->setSumNumberCutOff(n);
};

void _GroebnerCutOffFlag(Source & so,Sink & si) {
  int n;
  so >> n;
  so.shouldBeEnd();
  run->setCutOffFlag(n!=0);
  si.noOutput();
};

void CollectionLinkHeaderItem::Dump_(Sink& sink) const
{
    Header hdr{};
    hdr.offset = ToFilePos(data->ptr);
    hdr.count = data->ptr.As0<CollectionLinkItem>().entries.size();
    sink.WriteGen(hdr);
}

		void add_slot(Sink& aSink, SinkFunction aSinkFunction)
		{
			typename LockingPolicy::scope_lock sl(*this);
			if (slots().find(&aSink) != slots().end())
				throw slot_already_added();
			detail::do_bind<ParameterCount>()(aSink, aSinkFunction, slots()[&aSink]);
			aSink.signal_created(*this);
		}

int main(void)
{
   File *aviFile = new File();
   Demux *aviDemux = new Demux();
   Codec *h264 = new Codec();
   Sink *imageSink = new Sink();

   Component *com = new Component();

   aviDemux->setProcessComponent(aviFile);
   h264->setProcessComponent(aviDemux);
   com->setProcessComponent(h264);
   imageSink->setProcessComponent(com);
   imageSink->dataProcess(NULL, NULL);

   return 0;
}

void OutputVisitor::s_put(const tRational<LINTEGER> & x,Sink & si) {
   if(x.denominator().zero()) {
    si << x.numerator().internal();
  } else {
    Sink sink(si.outputFunction("Divide",2L));
    sink << x.numerator().internal() << x.denominator().internal();
  };    
};

void _RunGBAlg(Source & source,Sink & sink) {
  asStringGB name;
  source >> name;
  source.shouldBeEnd();
  sink.noOutput();
  GBALG_STORAGE::const_iterator w = gbalg_storage.find(name.value());
  if(w==gbalg_storage.end()) DBG();
  (*w).second->perform();
};

  void Serialize(Sink & sink)
  {
    SortPostings();
    BuildDictionary();

    TextIndexHeader header;

    uint64_t const startPos = sink.Pos();
    // Will be filled in later.
    header.Serialize(sink);

    SerializeDictionary(sink, header, startPos);
    SerializePostingsLists(sink, header, startPos);

    uint64_t const finishPos = sink.Pos();
    sink.Seek(startPos);
    header.Serialize(sink);
    sink.Seek(finishPos);
  }

void _CppTeXTheFile(Source & so,Sink & si) {
  stringGB format;
  so >> format;
  StringAccumulator x;
  x.add(PlatformSpecific::s_latex_command());
  x.add(format.value().chars());
  so.shouldBeEnd();
  si.noOutput();
  system(x.chars());
};

void _ShowTeX(Source & so,Sink & si) {
  stringGB format;
  so >> format;
  StringAccumulator x;
  x.add(PlatformSpecific::s_dvi_viewer());
  x.add(format.value().chars());
  x.add(PlatformSpecific::s_background());
  so.shouldBeEnd();
  si.noOutput();
  system(x.chars());
};