C++ Entries类代码示例

std::string
Dictionary::translate_plural(const Entries& dict, const std::string& msgid, const std::string& msgid_plural, int count)
{
  Entries::const_iterator i = dict.find(msgid);

  if (i != dict.end())
  {
    const std::vector<std::string>& msgstrs = i->second;
    unsigned int n = 0;
    n = plural_forms.get_plural(count);
    assert(/*n >= 0 &&*/ n < msgstrs.size());

    if (!msgstrs[n].empty())
      return msgstrs[n];
    else
      if (count == 1) // default to english rules
        return msgid;
      else
        return msgid_plural;
  }
  else
  {
    log_info << "Couldn't translate: " << msgid << std::endl;
    log_info << "Candidates: " << std::endl;
    for (i = dict.begin(); i != dict.end(); ++i)
      log_info << "'" << i->first << "'" << std::endl;

    if (count == 1) // default to english rules
      return msgid;
    else
      return msgid_plural;
  }
}

bool PLS::_write(const Entries &list)
{
	Writer *writer = ioCtrl.rawPtr< Writer >();
	writer->write(QString("[playlist]\r\nNumberOfEntries=" + QString::number(list.size()) + "\r\n").toUtf8());
	for (int i = 0; i < list.size(); i++)
	{
		const Playlist::Entry &entry = list[i];
		QString idx = QString::number(i+1);
		QString url = entry.url;
		const bool isFile = url.startsWith("file://");
		if (isFile)
			url.remove(0, 7);
#ifdef Q_OS_WIN
		if (isFile)
			url.replace("/", "\\");
#endif
		if (!url.isEmpty())
			writer->write(QString("File" + idx + "=" + url + "\r\n").toUtf8());
		if (!entry.name.isEmpty())
			writer->write(QString("Title" + idx + "=" + QString(entry.name).replace('\n', '\001') + "\r\n").toUtf8());
		if (entry.length >= 0)
			writer->write(QString("Length" + idx + "=" + QString::number(entry.length) + "\r\n").toUtf8());
		if (entry.selected)
			writer->write(QString("QMPlay_sel" + idx + "=" + QString::number(entry.selected) + "\r\n").toUtf8());
		if (entry.queue)
			writer->write(QString("QMPlay_queue" + idx + "=" + QString::number(entry.queue) + "\r\n").toUtf8());
		if (entry.GID)
			writer->write(QString("QMPlay_GID" + idx + "=" + QString::number(entry.GID) + "\r\n").toUtf8());
		if (entry.parent)
			writer->write(QString("QMPlay_parent" + idx + "=" + QString::number(entry.parent) + "\r\n").toUtf8());
	}
	return true;
}

 Func foreach(Func func)
 {
   for(Entries::iterator i = entries.begin(); i != entries.end(); ++i)
   {
     func(i->first, i->second);
   }
   return func;
 }

 void op_delete(void * const p, bool const array, std::size_t const s) {
   if (array) ::operator delete[](p);
   else ::operator delete(p);
   std::vector<boost::reference_wrapper<Entry const> > v;
   for (Entries::const_iterator j = entries.begin(); j != entries.end(); ++j)
     if (p <= j->p && boost::implicit_cast<void const *>(j->p) <= static_cast<char *>(p) + s)
       v.push_back(boost::cref(*j));
   if (array) { info i; i() << "delete["; more_ostreaming::delimit(i(), v); i() << ']'; }
   else { assert(v.size() == 1); info()() << "delete(" << v.front() << ")"; }
 }

void ViennaMiniForm::setMaterialLibrary(MaterialManager::Library& lib)
{
    typedef MaterialManager::Library::Entries          Entries;
    typedef MaterialManager::Library::EntryIterator    EntryIterator;

    Entries metals = lib.getMaterialsOfCategory("metal");
    for(EntryIterator iter = metals.begin(); iter != metals.end(); iter++)
    {
        list_metals << QString::fromStdString(vmat::id(*iter));
    }
    ui->comboBoxContactMaterial->addItems(list_metals);
    QObject::connect(ui->comboBoxContactMaterial, SIGNAL(activated(QString)), this, SLOT(setSegmentMaterial(QString)));

    Entries oxides = lib.getMaterialsOfCategory("oxide");
    for(EntryIterator iter = oxides.begin(); iter != oxides.end(); iter++)
    {
        list_oxides << QString::fromStdString(vmat::id(*iter));
    }
    ui->comboBoxOxideMaterial->addItems(list_oxides);
    QObject::connect(ui->comboBoxOxideMaterial, SIGNAL(activated(QString)), this, SLOT(setSegmentMaterial(QString)));

    Entries semiconductors = lib.getMaterialsOfCategory("semiconductor");
    for(EntryIterator iter = semiconductors.begin(); iter != semiconductors.end(); iter++)
    {
        list_semiconductors << QString::fromStdString(vmat::id(*iter));
    }
    ui->comboBoxSemiconductorMaterial->addItems(list_semiconductors);
    QObject::connect(ui->comboBoxSemiconductorMaterial, SIGNAL(activated(QString)), this, SLOT(setSegmentMaterial(QString)));
}

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

  if(argc < 3) {
    printf("Usage whateveryoujusttyped.exe readFileName writeFileName\n");
    return -1;
  }

  const char* readFilename = argv[1];
  const char* writeFilename = argv[2];

  std::ifstream readFile(readFilename);
  if(!readFile.is_open()) {
    printf("Couldn't open %s for reading\n", readFilename);
    return -1;
  }

  std::ofstream writeFile(writeFilename);
  if(!writeFile.is_open()) {
    printf("Couldn't open %s for writing\n", writeFilename);
    return -1;
  }

  typedef std::list<std::string> Entries;
  Entries entries;

  std::string currentEntry;
  std::string line;
  while(std::getline(readFile, line)) {
    if(strstr(line.c_str(), "===") != NULL) {
      if(!currentEntry.empty()) {
        entries.push_back(currentEntry);
      }
      currentEntry.clear();
    }

    currentEntry += line;
    currentEntry += "\n";
  }
  if(!currentEntry.empty()) {
    entries.push_back(currentEntry);
  }
  readFile.close();

  for(auto entryIt = entries.rbegin();
    entryIt != entries.rend();
    ++entryIt) {
    writeFile << (*entryIt);
  }
  writeFile.close();

  return 0;
}

 ~LeakReporter() {
   std::vector<boost::reference_wrapper<Entry const> > v;
   for (Entries::const_iterator i = entries.begin(); i != entries.end(); ++i)
     if (i->status != destructed) v.push_back(boost::cref(*i));
   if (!v.empty() && !muted)
   {
     std::ostringstream oss;
       // We don't use cout here because apparently it can be unavailable by the time this code runs (judging by the segfaults I observed when this code used cout).
     more_ostreaming::delimit(oss, v);
     std::printf("%sleaked: %s.", parsep, oss.str().c_str());
     abort();
   }
 }

std::string
Dictionary::translate(const Entries& dict, const std::string& msgid)
{
  Entries::const_iterator i = dict.find(msgid);
  if (i != dict.end() && !i->second.empty())
  {
    return i->second[0];
  }
  else
  {
    log_info << "Couldn't translate: " << msgid << std::endl;
    return msgid;
  } 
}

void CalendarCell::update(const dbo::ptr<UserAccount>& user, const WDate& date)
{
  date_ = date;
  user_ = user;

  clear();

  dbo::Session& session = PlannerApplication::plannerApplication()->session;
  dbo::Transaction transaction(session);
  
  WString day;
  day += boost::lexical_cast<std::string>(date.day());
  if (date.day() == 1)
    day += " " + WDate::longMonthName(date.month());
  WText* header = new WText(day);
  header->setStyleClass("cell-header");
  addWidget(header);

  typedef dbo::collection< dbo::ptr<Entry> > Entries;
  Entries entries = user->entriesInRange(date, date.addDays(1));

  const unsigned maxEntries = 4;
  unsigned counter = 0;
  for (Entries::const_iterator i = entries.begin();
       i != entries.end(); ++i, ++counter) {
    if (counter == maxEntries) {
      WText* extra = 
	new WText(tr("calendar.cell.extra")
		  .arg((int)(entries.size() - maxEntries)));
      extra->setStyleClass("cell-extra");
      addWidget(extra);

      extra->clicked().preventPropagation();
      extra->clicked().connect(this, &CalendarCell::showAllEntriesDialog);
      
      break;
    }

    WString format = EntryDialog::timeFormat;
    addWidget(new WText((*i)->start.toString(format) +
			"-" + 
			(*i)->stop.toString(format) + 
			": " + (*i)->summary));
  }

  transaction.commit();
}

std::string
Dictionary::translate_plural(const Entries& dict, const std::string& msgid, const std::string& msgid_plural, int count) const
{
	Entries::const_iterator it = dict.find(msgid);
	if (it != dict.end())
	{
		unsigned int                  n         = plural_forms.get_plural(count);
		const std::vector<std::string>& msgstrs = it->second;
		if (n >= msgstrs.size())
		{
			log_error << "Plural translation not available (and not set to empty): '" << msgid << "'" << std::endl;
			log_error << "Missing plural form: " << n << std::endl;
			return msgid;
		}

		if (!msgstrs[n].empty())
		{
			return msgstrs[n];
		}
		else
		if (count == 1) // default to english rules
		{
			return msgid;
		}
		else
		{
			return msgid_plural;
		}
	}
	else
	{
		log_info << "Couldn't translate: " << msgid << std::endl;
		log_info << "Candidates: " << std::endl;
		for (it = dict.begin(); it != dict.end(); ++it)
			log_info << "'" << it->first << "'" << std::endl;

		if (count == 1) // default to english rules
		{
			return msgid;
		}
		else
		{
			return msgid_plural;
		}
	}
}

Path Directory::find(const Path& fileName, SensType sens) const
{
  if( fileName.toString().empty() )
  {
    Logger::warning( "!!! WARNING: Directory: cannot try find zero lenght name" );
    return "";
  }

  Entries files = entries();
  files.setSensType( sens );
  int index = files.findFile( fileName.baseName() );
  if( index >= 0 )
  {
    return files.item( index ).fullpath;
  }

  return "";
}

void DefineEntry::accept()
{
#ifdef DEBUG
    qDebug("DefineEntry::accpet()");
#endif
    if (!EntryProperties->count())
    {
        QMessageBox::warning(this, "No properties", "Please, define some entry's\nproperties", 0, 0, 0);
        return;
    }

    if (EntryName->text() == "")
    {
        QMessageBox::warning(this, "No entry name", "Please, define entry name", 0, 0, 0);
        return;
    }

    Entries *entries = IQApp->entries();

    Entry *entry;

    if (editEntry)
    {
        if (EntryName->text() != editEntry->getName() && entries->isIn(EntryName->text()))
        {
            QMessageBox::warning(this, "Entry exists", "Entry with such name\nexists. Please, choose another.", 0, 0, 0);
            return;
        }

        entry = editEntry;
        entry->clear();
        entry->setName(EntryName->text());
    }
    else if ((entry = entries->isIn(EntryName->text())))
    {
        QMessageBox::warning(this, "Entry exists", "Entry with such name\nexists. Please, choose another.", 0, 0, 0);
        return;
    }
    else
        entry = new Entry(EntryName->text());

    for (uint i = 0; true; i++)
    {
        PropertyBoxItem *pbi;

        if ((pbi = static_cast<PropertyBoxItem *>(EntryProperties->item(i))))
        {
            entry->addProperty(new PropertyStruct(pbi));
        }
        else
            break;
    }
    
    entry->setDefaultPic(defaultPic);

    if (!editEntry)
        entries->addEntry(entry);

    entry->checkPropertiesID();

    DefineEntryBase::accept();
}

  namespace detail
  {
    using geordi::error;
    using geordi::parsep;

    bool muted = false;

    struct info: boost::noncopyable
    {
      info() { if(!muted) std::cout << parsep; }
      ~info() { if(!muted) std::cout << parsep; }
      std::ostream & operator()() const
      {
        static std::ostream s(0); // used as null sink
        return muted ? s : std::cout;
      }
    };

    enum Status { fresh, pillaged, destructed };

    struct Entry {
      Tracked const * p;
      char const * name;
      Status status;
    };

    typedef std::vector<Entry> Entries;
    Entries entries;
      // Keeping track of Trackeds outside of the objects themselves allows us to give nice diagnostics for operations on objects that have already perished.
      // Invariant: If multiple entries have identical p, then all but the last have status==destructed.

    std::ostream & operator<<(std::ostream & o, Entry const & e)
    { return o << e.name << &e - &entries.front(); }

    Entry * entry(Tracked const * const r) {
      for (Entries::reverse_iterator i(entries.rbegin()); i != entries.rend(); ++i) if (i->p == r) return &*i;
      return 0;
    }

    void make_entry(Tracked const * const r) {
      if (Entry * const e = entry(r)) if (e->status != destructed) error()() << "leaked: " << *e << '.';
      Entry const e = { r, "?", fresh };
      entries.push_back(e);
    }

    void assert_status_below(Tracked const * const r, Status const st, std::string const & s) {
      Entry * const e = entry(r);
      if(!e) error()() << "tried to " << s << " non-existent object.";
      if (e->status < st) return;
      error()() << "tried to " << s << (e->status == pillaged ? " pillaged " : " destructed ") << *e << '.';
    }

    void * op_new(std::size_t const s, bool const array, void * const r, char const * const name) {
      if (!r) return 0;
      info()() << "new(" << name << (array ? "[]" : "") << ")";
      return r;
    }

    void op_delete(void * const p, bool const array, std::size_t const s) {
      if (array) ::operator delete[](p);
      else ::operator delete(p);
      std::vector<boost::reference_wrapper<Entry const> > v;
      for (Entries::const_iterator j = entries.begin(); j != entries.end(); ++j)
        if (p <= j->p && boost::implicit_cast<void const *>(j->p) <= static_cast<char *>(p) + s)
          v.push_back(boost::cref(*j));
      if (array) { info i; i() << "delete["; more_ostreaming::delimit(i(), v); i() << ']'; }
      else { assert(v.size() == 1); info()() << "delete(" << v.front() << ")"; }
    }

    void Tracked::set_name(char const * const s) const { entry(this)->name = s; }

    Tracked::Tracked() { make_entry(this); }

    Tracked::Tracked(Tag const & t): tag(t) { make_entry(this); }

    Tracked::Tracked(Tracked const & i): tag((assert_status_below(&i, pillaged, "copy"), i.tag)) { make_entry(this); }

    void Tracked::operator=(Tracked const & r) {
      assert_status_below(this, destructed, "assign to");
      assert_status_below(&r, pillaged, "assign from");
      entry(this)->status = fresh;
    }

    Tracked::Tracked(Tracked && r)
    { assert_status_below(&r, pillaged, "move"); make_entry(this); entry(&r)->status = pillaged; }

    void Tracked::operator=(Tracked && r) {
      assert_status_below(this, destructed, "move-assign to");
      assert_status_below(&r, pillaged, "move");
      entry(this)->status = fresh;
      entry(&r)->status = pillaged;
    }

    Tracked::~Tracked()
    { assert_status_below(this, destructed, "re-destruct"); entry(this)->status = destructed; }

    struct LeakReporter {
      ~LeakReporter() {
        std::vector<boost::reference_wrapper<Entry const> > v;
        for (Entries::const_iterator i = entries.begin(); i != entries.end(); ++i)
//.........这里部分代码省略.........

inline children launch_pipeline(const Entries &entries) 
{ 
    BOOST_ASSERT(entries.size() >= 2); 

    children cs; 
    detail::file_handle fhinvalid; 

    boost::scoped_array<detail::pipe> pipes(new detail::pipe[entries.size() - 1]); 

#if defined(BOOST_POSIX_API) 
    { 
        typename Entries::size_type i = 0; 
        const typename Entries::value_type::context_type &ctx = entries[i].context; 

        detail::info_map infoin, infoout; 

        if (ctx.stdin_behavior.get_type() != stream_behavior::close) 
        { 
            detail::stream_info si = detail::stream_info(ctx.stdin_behavior, false); 
            infoin.insert(detail::info_map::value_type(STDIN_FILENO, si)); 
        } 

        BOOST_ASSERT(ctx.stdout_behavior.get_type() == stream_behavior::close); 
        detail::stream_info si2(close_stream(), true); 
        si2.type_ = detail::stream_info::use_handle; 
        si2.handle_ = pipes[i].wend().release(); 
        infoout.insert(detail::info_map::value_type(STDOUT_FILENO, si2)); 

        if (ctx.stderr_behavior.get_type() != stream_behavior::close) 
        { 
            detail::stream_info si = detail::stream_info(ctx.stderr_behavior, true); 
            infoout.insert(detail::info_map::value_type(STDERR_FILENO, si)); 
        } 

        detail::posix_setup s; 
        s.work_directory = ctx.work_directory; 

        pid_t pid = detail::posix_start(entries[i].executable, entries[i].arguments, ctx.environment, infoin, infoout, s); 

        detail::file_handle fhstdin; 

        if (ctx.stdin_behavior.get_type() == stream_behavior::capture) 
        { 
            fhstdin = detail::posix_info_locate_pipe(infoin, STDIN_FILENO, false); 
            BOOST_ASSERT(fhstdin.valid()); 
        } 

        cs.push_back(child(pid, fhstdin, fhinvalid, fhinvalid)); 
    } 

    for (typename Entries::size_type i = 1; i < entries.size() - 1; ++i) 
    { 
        const typename Entries::value_type::context_type &ctx = entries[i].context; 
        detail::info_map infoin, infoout; 

        BOOST_ASSERT(ctx.stdin_behavior.get_type() == stream_behavior::close); 
        detail::stream_info si1(close_stream(), false); 
        si1.type_ = detail::stream_info::use_handle; 
        si1.handle_ = pipes[i - 1].rend().release(); 
        infoin.insert(detail::info_map::value_type(STDIN_FILENO, si1)); 

        BOOST_ASSERT(ctx.stdout_behavior.get_type() == stream_behavior::close); 
        detail::stream_info si2(close_stream(), true); 
        si2.type_ = detail::stream_info::use_handle; 
        si2.handle_ = pipes[i].wend().release(); 
        infoout.insert(detail::info_map::value_type(STDOUT_FILENO, si2)); 

        if (ctx.stderr_behavior.get_type() != stream_behavior::close) 
        { 
            detail::stream_info si = detail::stream_info(ctx.stderr_behavior, true); 
            infoout.insert(detail::info_map::value_type(STDERR_FILENO, si)); 
        } 

        detail::posix_setup s; 
        s.work_directory = ctx.work_directory; 

        pid_t pid = detail::posix_start(entries[i].executable, entries[i].arguments, ctx.environment, infoin, infoout, s); 

        cs.push_back(child(pid, fhinvalid, fhinvalid, fhinvalid)); 
    } 

    { 
        typename Entries::size_type i = entries.size() - 1; 
        const typename Entries::value_type::context_type &ctx = entries[i].context; 

        detail::info_map infoin, infoout; 

        BOOST_ASSERT(ctx.stdin_behavior.get_type() == stream_behavior::close); 
        detail::stream_info si1(close_stream(), false); 
        si1.type_ = detail::stream_info::use_handle; 
        si1.handle_ = pipes[i - 1].rend().release(); 
        infoin.insert(detail::info_map::value_type(STDIN_FILENO, si1)); 

        if (ctx.stdout_behavior.get_type() != stream_behavior::close) 
        { 
            detail::stream_info si = detail::stream_info(ctx.stdout_behavior, true); 
            infoout.insert(detail::info_map::value_type(STDOUT_FILENO, si)); 
        } 

        if (ctx.stderr_behavior.get_type() != stream_behavior::close) 
//.........这里部分代码省略.........

 void Set(Entries& entries)
 {
     Set( entries.Ptr(), entries.Size() );
 }