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());
    }
}

void MatSerializableAdapter::writeTo(Writer& writer) const {
    assert(_cmat);
    writer.write("type", _cmat->type());
    writer.write("cols", _cmat->cols);
    writer.write("rows", _cmat->rows);
    std::vector<double> data(_cmat->begin<double>(), _cmat->end<double>());
    writer.write("data", data);
}

bool XSPF::write(const Entries &list)
{
	Writer *writer = ioCtrl.rawPtr<Writer>();
	const QString playlistPath = getPlaylistPath(writer->getUrl());

	QByteArray buffer;
	QXmlStreamWriter xmlWriter(&buffer);
	xmlWriter.setAutoFormatting(true);
	xmlWriter.setAutoFormattingIndent(-1);

	xmlWriter.writeStartDocument();
	xmlWriter.writeStartElement("playlist");
	xmlWriter.writeStartElement("trackList");

	for (const Entry &entry : list)
	{
		xmlWriter.writeStartElement("track");

		if (entry.GID)
			startExtension(xmlWriter);

		QString url = entry.url;
		if (url.startsWith("file://") && url.mid(7, playlistPath.length()) == playlistPath)
			url.remove(0, playlistPath.length() + 7);
		xmlWriter.writeTextElement("location", url);

		if (!entry.name.isEmpty())
			xmlWriter.writeTextElement("title", entry.name);
		if (entry.length >= 0.0)
			xmlWriter.writeTextElement("duration", QString::number(1000.0 * entry.length, 'f', 0));

		if (entry.flags || entry.queue || entry.GID || entry.parent)
		{
			if (!entry.GID)
				startExtension(xmlWriter);

			if (entry.flags)
				xmlWriter.writeTextElement("f", QString::number(entry.flags));
			if (entry.queue)
				xmlWriter.writeTextElement("q", QString::number(entry.queue));
			if (entry.GID)
				xmlWriter.writeTextElement("g", QString::number(entry.GID));
			if (entry.parent)
				xmlWriter.writeTextElement("p", QString::number(entry.parent));

			xmlWriter.writeEndElement(); // extension
		}

		xmlWriter.writeEndElement(); // track
	}

	xmlWriter.writeEndElement(); // trackList
	xmlWriter.writeEndElement(); // playlist
	xmlWriter.writeEndDocument();

	writer->write(buffer);
	return true;
}

void TemplateParameterNodeList::Write(Writer& writer)
{
    uint32_t n = static_cast<uint32_t>(templateParameterNodes.size());
    writer.Write(n);
    for (uint32_t i = 0; i < n; ++i)
    {
        writer.Write(templateParameterNodes[i].get());
    }
}

void Skin::save (const gdx_cpp::files::FileHandle& skinFile) {
    String text = getJsonLoader(null).prettyPrint(this, true);
    Writer writer = skinFile.writer(false);
    try {
        writer.write(text);
        writer.close();
    } catch (IOException ex) {
    }
}

bool medDataReaderWriter::write(const QString& path,medAbstractData* data) {
    Writer dwriter = writer(path,data);
    if (!dwriter.isNull()) {
        dwriter->setData(data);
        dwriter->write(path);
        return true;
    }
    return false;
}