C++ Writer类代码示例

Trace::Trace(
  Writer &dout,
  const char *function_name,
  int line_mask,
  bool do_trace)
  : Traceback(function_name),
    m_diagWriter(dout),
    m_startCpuTime(0.0),
    m_startMemAlloc(0),
    m_lineMask(line_mask),
    m_do_trace(do_trace),
    m_flags((dout.isTracing()
             || (dout.shouldTrace(m_lineMask)
                 && (s_traceListExists && (s_traceList.empty() || prefix_find(s_traceList, m_functionSpec))))) ? IN_TRACE_LIST : 0)
{
  if (m_do_trace && (m_flags & IN_TRACE_LIST)) {
    m_diagWriter.incTraceDepth();

    m_diagWriter.m(m_lineMask) << m_functionSpec
                               << (std::uncaught_exception() ? " (throw unwinding) " : "")
                               << push << dendl;

    if (dout.shouldPrint(LOG_TRACE_STATS)) {
      m_startCpuTime = sierra::Env::cpu_now();
      m_startMemAlloc = stk::get_heap_used();
    }
  }
}

void ConsoleTools::listTypes(bool load, bool useNames){
  Writer *writer = null;
  try{
    writer = new StreamWriter(stdout, outputEncodingIndex, bomOutput);
    ParserFactory pf(catalogPath);
    HRCParser *hrcParser = pf.getHRCParser();
    fprintf(stderr, "\nloading file types...\n");
    for(int idx = 0;; idx++){
      FileType *type = hrcParser->enumerateFileTypes(idx);
      if (type == null) break;
      if (useNames){
        writer->write(StringBuffer(type->getName())+"\n");
      }else{
        if (type->getGroup() != null){
          writer->write(StringBuffer(type->getGroup()) + ": ");
        }
        writer->write(type->getDescription());
        writer->write(DString("\n"));
      }

      if (load) type->getBaseScheme();
    }
    delete writer;
  }catch(Exception &e){
    delete writer;
    fprintf(stderr, "%s\n", e.getMessage()->getChars());
  }
}

 virtual StringResultBase* Stringify(const ParseResultBase* parseResult) const {
     const JzonParseResult* pr = static_cast<const JzonParseResult*>(parseResult);
     JzonStringResult* sr = new JzonStringResult;
     Writer writer;
     writer.writeString(pr->root, sr->s);
     return sr;
 }

void Command::Save (Writer &writer) const
{
    // this will only get used if saved as XML (probably never)
    writer.Stream() << writer.ind() << "<Command "
                    << "gcode=\"" << toGCode() << "\" />";
    writer.Stream()<< std::endl;
}

void Constraint::Save (Writer &writer) const
{
    std::string encodeName = encodeAttribute(Name);
    writer.Stream() << writer.ind()     << "<Constrain "
    << "Name=\""                        <<  encodeName              << "\" "
    << "Type=\""                        <<  (int)Type               << "\" ";
    if(this->Type==InternalAlignment)
        writer.Stream()
        << "InternalAlignmentType=\""   <<  (int)AlignmentType      << "\" "
        << "InternalAlignmentIndex=\""  <<  InternalAlignmentIndex  << "\" ";
    writer.Stream()
    << "Value=\""                       <<  Value                   << "\" "
    << "First=\""                       <<  First                   << "\" "
    << "FirstPos=\""                    <<  (int)  FirstPos         << "\" "
    << "Second=\""                      <<  Second                  << "\" "
    << "SecondPos=\""                   <<  (int) SecondPos         << "\" "
    << "Third=\""                       <<  Third                   << "\" "
    << "ThirdPos=\""                    <<  (int) ThirdPos          << "\" "
    << "LabelDistance=\""               <<  LabelDistance           << "\" "
    << "LabelPosition=\""               <<  LabelPosition           << "\" "
    << "IsDriving=\""                   <<  (int)isDriving          << "\" "
    << "IsInVirtualSpace=\""            <<  (int)isInVirtualSpace   << "\" />"

    << std::endl;
}

void stringify(Writer& writer, const std::vector<T>& v) {
    writer.StartArray();
    for (const auto& e : v) {
        stringify(writer, e);
    }
    writer.EndArray();
}

int main(void) {

	char data = ' ';
	int id = 0;

	cout << "pid: " << getpid() << endl;

	cout << "digite id do reader: ";
	cin >> id;
	cout << "id =  " << id << endl;

	Writer *wr = new Writer(id);

	signal(SIGCONT, sigusr);
	kill(id, SIGCONT);

	while (data != '.') {

		cout << "digite o char: ";
		cin >> data;
		wr->Write(data);
	}

	wr->~Writer();
}

 bool write(Writer &w) const
 {
     MSS_BEGIN(bool);
     auto fix = 0u;
     //Copy of field is intentional
     for (Range field: fields)
     {
         auto write_field = [&](Writer &w1){
             MSS_BEGIN(bool);
             if (!field.empty())
             {
                 w.text(field.front());
                 field.pop_front();
                 while (!field.empty())
                 {
                     w.text(' ');
                     w.text(field.front());
                     field.pop_front();
                 }
             }
             MSS_END();
         };
         MSS(w(fix, write_field));
         ++fix;
     }
     MSS_END();
 }

void Peer::onConnection(Exception& ex, Writer& writer,DataReader& parameters,DataWriter& response) {
	if(!connected) {
		_pWriter = &writer;

		// reset default protocol parameters
		_parameters.clear();
		Parameters::ForEach forEach([this](const string& key,const string& value) {
			_parameters.setString(key,value);
		});
		string buffer;
		_handler.iterate(String::Format(buffer,protocol,"."), forEach);

		ParameterWriter parameterWriter(_parameters);
		SplitWriter parameterAndResponse(parameterWriter,response);

		_handler.onConnection(ex, *this,parameters,parameterAndResponse);
		if (!ex) {
			(bool&)connected = ((Entities<Client>&)_handler.clients).add(*this);
			if (!connected) {
				ex.set(Exception::PROTOCOL, "Client ", Util::FormatHex(id, ID_SIZE, buffer), " exists already");
				ERROR(ex.error());
				_handler.onDisconnection(*this);
			}
		}
		if (!connected) {
			writer.abort();
			_pWriter = NULL;
		} else {
			OnInitParameters::raise(_parameters);
			DEBUG("Client ",address.toString()," connection")
		}
		writer.open(); // open even if "ex" to send error messages!
	} else

static oc::result<void>
_mtk_header_update_size(Writer &writer, File &file,
                        uint64_t offset, uint32_t size)
{
    uint32_t le32_size = mb_htole32(size);

    if (offset > SIZE_MAX - offsetof(MtkHeader, size)) {
        writer.set_fatal();
        return MtkError::MtkHeaderOffsetTooLarge;
    }

    auto seek_ret = file.seek(
            static_cast<int64_t>(offset + offsetof(MtkHeader, size)), SEEK_SET);
    if (!seek_ret) {
        if (file.is_fatal()) { writer.set_fatal(); }
        return seek_ret.as_failure();
    }

    auto ret = file_write_exact(file, &le32_size, sizeof(le32_size));
    if (!ret) {
        if (file.is_fatal()) { writer.set_fatal(); }
        return ret.as_failure();
    }

    return oc::success();
}

string
WKTWriter::writeFormatted(const Geometry* geometry)
{
    Writer sw;
    writeFormatted(geometry, true, &sw);
    return sw.toString();
}

int main(int argc, char* argv[])
{

  if (argc < 7) {
    usage(argv[0]);
  }

  std::string h5file = argv[1];
  std::string immfile = argv[2];
  std::string dataset = argv[3];
  unsigned int buffer_count = atoi(argv[4]);
  unsigned int frames = atoi(argv[5]);
  unsigned int frames_per_buffer = atoi(argv[6]);

  BufferPool *pool = new BufferPool(buffer_count, 1024, 1024, frames_per_buffer);
  Queue<FrameBuffer*> *readconvert = new Queue<FrameBuffer*>();
  Queue<FrameBuffer*> *convertwrite = new Queue<FrameBuffer*>();

  Reader *reader = new Reader(h5file, dataset, 1024, 1024, frames, frames_per_buffer, pool, readconvert);
  Converter *converter = new Converter(readconvert, convertwrite, frames);
  Writer *writer = new Writer(immfile, convertwrite, pool, frames);

  writer->start();
  converter->start();
  reader->start();


  reader->join();
  converter->join();
  writer->join();

  printf("Done\n");
}

 void produce_response(Writer& out, const int result) {
     out.write("{\"scans\":[");
     bool first = true;
     ScanEntry& entry = read_;
     while (!result && !wiced_rtos_pop_from_queue(&queue_, &entry, WICED_NEVER_TIMEOUT)) {
         if (entry.done)
             break;
         if (!*entry.ssid)
             continue;
         if (first)
             first = false;
         else
             write_char(out, ',');
         write_char(out, '{');
         write_json_string(out, "ssid", entry.ssid);
         write_char(out, ',');
         write_json_int(out, "rssi", entry.rssi);
         write_char(out, ',');
         write_json_int(out, "sec", entry.security);
         write_char(out, ',');
         write_json_int(out, "ch", entry.channel);
         write_char(out, ',');
         write_json_int(out, "mdr", entry.max_data_rate);
         write_char(out, '}');
     }
     out.write("]}");
     wiced_rtos_deinit_queue(&queue_);
 }

	void Serialize(Writer& writer) const {
		// This base class just write out name-value pairs, without wrapping within an object.
		writer.String("name");
		writer.String(name_.c_str(), (SizeType)name_.length());	// Suppling length of string is faster.

		writer.String("age");
		writer.Uint(age_);
	}

void MsgBuf::write_data(const std::vector<TradeMsg> messages, Writer& out) {
    for(std::vector<TradeMsg>::const_iterator it = messages.begin(); it != messages.end(); ++it) {
        out.save_binary((*it).get_type());
        out.save_binary((*it).get_time());
        out.save_binary((*it).get_len());
        out.save_string((*it).get_msg());
    }
}