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();
}
unsigned int id(Tracked const & t) { return entry(&t) - &entries.front(); }
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)
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();
}
}
} leakReporter; // Must come after entries, so it will be destructed first.
unsigned int id(Tracked const & t) { return entry(&t) - &entries.front(); }
} // namespace detail
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)
{
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 fhstdout, fhstderr;
if (ctx.stdout_behavior.get_type() == stream_behavior::capture)
{
fhstdout = detail::posix_info_locate_pipe(infoout, STDOUT_FILENO, true);
BOOST_ASSERT(fhstdout.valid());
}
if (ctx.stderr_behavior.get_type() == stream_behavior::capture)
{
fhstderr = detail::posix_info_locate_pipe(infoout, STDERR_FILENO, true);
BOOST_ASSERT(fhstderr.valid());
}
cs.push_back(child(pid, fhinvalid, fhstdout, fhstderr));
}
#elif defined(BOOST_WINDOWS_API)
STARTUPINFOA si;
detail::win32_setup s;
s.startupinfo = &si;
{
typename Entries::size_type i = 0;
const typename Entries::value_type::context_type &ctx = entries[i].context;
detail::stream_info sii = detail::stream_info(ctx.stdin_behavior, false);
detail::file_handle fhstdin;
if (sii.type_ == detail::stream_info::use_pipe)
fhstdin = sii.pipe_->wend();
BOOST_ASSERT(ctx.stdout_behavior.get_type() == stream_behavior::close);
detail::stream_info sio(close_stream(), true);
sio.type_ = detail::stream_info::use_handle;
sio.handle_ = pipes[i].wend().release();
detail::stream_info sie(ctx.stderr_behavior, true);
s.work_directory = ctx.work_directory;
::ZeroMemory(&si, sizeof(si));
si.cb = sizeof(si);
PROCESS_INFORMATION pi = detail::win32_start(entries[i].executable, entries[i].arguments, ctx.environment, sii, sio, sie, s);
if (!::CloseHandle(pi.hThread))
boost::throw_exception(boost::system::system_error(boost::system::error_code(::GetLastError(), boost::system::get_system_category()), "boost::process::launch_pipeline: CloseHandle failed"));
cs.push_back(child(pi.dwProcessId, fhstdin, fhinvalid, fhinvalid, detail::file_handle(pi.hProcess)));
}
for (typename Entries::size_type i = 1; i < entries.size() - 1; ++i)
{
const typename Entries::value_type::context_type &ctx = entries[i].context;
BOOST_ASSERT(ctx.stdin_behavior.get_type() == stream_behavior::close);
detail::stream_info sii(close_stream(), false);
sii.type_ = detail::stream_info::use_handle;
sii.handle_ = pipes[i - 1].rend().release();
detail::stream_info sio(close_stream(), true);
sio.type_ = detail::stream_info::use_handle;
sio.handle_ = pipes[i].wend().release();
detail::stream_info sie(ctx.stderr_behavior, true);
s.work_directory = ctx.work_directory;
::ZeroMemory(&si, sizeof(si));
si.cb = sizeof(si);
PROCESS_INFORMATION pi = detail::win32_start(entries[i].executable, entries[i].arguments, ctx.environment, sii, sio, sie, s);
if (!::CloseHandle(pi.hThread))
boost::throw_exception(boost::system::system_error(boost::system::error_code(::GetLastError(), boost::system::get_system_category()), "boost::process::launch_pipeline: CloseHandle failed"));
cs.push_back(child(pi.dwProcessId, fhinvalid, fhinvalid, fhinvalid, detail::file_handle(pi.hProcess)));
}
{
typename Entries::size_type i = entries.size() - 1;
const typename Entries::value_type::context_type &ctx = entries[i].context;
BOOST_ASSERT(ctx.stdin_behavior.get_type() == stream_behavior::close);
detail::stream_info sii(close_stream(), false);
sii.type_ = detail::stream_info::use_handle;
sii.handle_ = pipes[i - 1].rend().release();
detail::file_handle fhstdout, fhstderr;
detail::stream_info sio(ctx.stdout_behavior, true);
if (sio.type_ == detail::stream_info::use_pipe)
fhstdout = sio.pipe_->rend();
detail::stream_info sie(ctx.stderr_behavior, true);
if (sie.type_ == detail::stream_info::use_pipe)
fhstderr = sie.pipe_->rend();
s.work_directory = ctx.work_directory;
::ZeroMemory(&si, sizeof(si));
si.cb = sizeof(si);
PROCESS_INFORMATION pi = detail::win32_start(entries[i].executable, entries[i].arguments, ctx.environment, sii, sio, sie, s);
if (!::CloseHandle(pi.hThread))
boost::throw_exception(boost::system::system_error(boost::system::error_code(::GetLastError(), boost::system::get_system_category()), "boost::process::launch_pipeline: CloseHandle failed"));
cs.push_back(child(pi.dwProcessId, fhinvalid, fhstdout, fhstderr, detail::file_handle(pi.hProcess)));
}
#endif
return cs;
}
void Set(Entries& entries)
{
Set( entries.Ptr(), entries.Size() );
}
void ArchiveTestCase<ClassFactoryT>::ExtractArchive(wxInputStream& in)
{
typedef Ptr<EntryT> EntryPtr;
typedef std::list<EntryPtr> Entries;
typedef typename Entries::iterator EntryIter;
auto_ptr<InputStreamT> arc(m_factory->NewStream(in));
int expectedTotal = m_testEntries.size();
EntryPtr entry;
Entries entries;
if ((m_options & PipeIn) == 0)
OnArchiveExtracted(*arc, expectedTotal);
while (entry = EntryPtr(arc->GetNextEntry()), entry.get() != NULL) {
wxString name = entry->GetName(wxPATH_UNIX);
// provide some context for the error message so that we know which
// iteration of the loop we were on
string error_entry((_T(" '") + name + _T("'")).mb_str());
string error_context(" failed for entry" + error_entry);
TestEntries::iterator it = m_testEntries.find(name);
CPPUNIT_ASSERT_MESSAGE(
"archive contains an entry that shouldn't be there" + error_entry,
it != m_testEntries.end());
const TestEntry& testEntry = *it->second;
wxDateTime dt = testEntry.GetDateTime();
if (dt.IsValid())
CPPUNIT_ASSERT_MESSAGE("timestamp check" + error_context,
dt == entry->GetDateTime());
// non-seekable entries are allowed to have GetSize == wxInvalidOffset
// until the end of the entry's data has been read past
CPPUNIT_ASSERT_MESSAGE("entry size check" + error_context,
testEntry.GetLength() == entry->GetSize() ||
((m_options & PipeIn) != 0 && entry->GetSize() == wxInvalidOffset));
CPPUNIT_ASSERT_MESSAGE(
"arc->GetLength() == entry->GetSize()" + error_context,
arc->GetLength() == entry->GetSize());
if (name.Last() != _T('/'))
{
CPPUNIT_ASSERT_MESSAGE("!IsDir" + error_context,
!entry->IsDir());
wxCharBuffer buf(testEntry.GetSize() + 1);
CPPUNIT_ASSERT_MESSAGE("Read until Eof" + error_context,
arc->Read(buf.data(), testEntry.GetSize() + 1).Eof());
CPPUNIT_ASSERT_MESSAGE("LastRead check" + error_context,
arc->LastRead() == testEntry.GetSize());
CPPUNIT_ASSERT_MESSAGE("data compare" + error_context,
!memcmp(buf.data(), testEntry.GetData(), testEntry.GetSize()));
} else {
CPPUNIT_ASSERT_MESSAGE("IsDir" + error_context, entry->IsDir());
}
// GetSize() must return the right result in all cases after all the
// data has been read
CPPUNIT_ASSERT_MESSAGE("entry size check" + error_context,
testEntry.GetLength() == entry->GetSize());
CPPUNIT_ASSERT_MESSAGE(
"arc->GetLength() == entry->GetSize()" + error_context,
arc->GetLength() == entry->GetSize());
if ((m_options & PipeIn) == 0) {
OnEntryExtracted(*entry, testEntry, arc.get());
delete it->second;
m_testEntries.erase(it);
} else {
entries.push_back(entry);
}
}
// check that the end of the input archive was reached without error
CPPUNIT_ASSERT(arc->Eof());
// for non-seekable streams these data are only guaranteed to be
// available once the end of the archive has been reached
if (m_options & PipeIn) {
for (EntryIter i = entries.begin(); i != entries.end(); ++i) {
wxString name = (*i)->GetName(wxPATH_UNIX);
TestEntries::iterator j = m_testEntries.find(name);
OnEntryExtracted(**i, *j->second);
delete j->second;
m_testEntries.erase(j);
}
OnArchiveExtracted(*arc, expectedTotal);
}
}
std::ostream & operator<<(std::ostream & o, Entry const & e)
{ return o << e.name << &e - &entries.front(); }
Playlist::Entries PLS::_read()
{
Reader *reader = ioCtrl.rawPtr< Reader >();
Entries list;
QString playlistPath = filePath(reader->getUrl());
if (playlistPath.startsWith("file://"))
playlistPath.remove(0, 7);
else
playlistPath.clear();
const QList< QByteArray > playlistLines = readLines();
for (int i = 0; i < playlistLines.count(); ++i)
{
const QByteArray &line = playlistLines[i];
if (line.isEmpty())
continue;
int idx = line.indexOf('=');
if (idx < 0)
continue;
int number_idx = -1;
for (int i = 0; i < line.length(); ++i)
{
if (line[i] == '=')
break;
if (line[i] >= '0' && line[i] <= '9')
{
number_idx = i;
break;
}
}
if (number_idx == -1)
continue;
QByteArray key = line.left(number_idx);
QByteArray value = line.mid(idx+1);
int entry_idx = line.mid(number_idx, idx - number_idx).toInt() - 1;
prepareList(&list, entry_idx);
if (entry_idx < 0 || entry_idx > list.size() - 1)
continue;
if (key == "File")
list[entry_idx].url = Url(value, playlistPath);
else if (key == "Title")
list[entry_idx].name = value.replace('\001', '\n');
else if (key == "Length")
list[entry_idx].length = value.toInt();
else if (key == "QMPlay_sel")
list[entry_idx].selected = value.toInt();
else if (key == "QMPlay_queue")
list[entry_idx].queue = value.toInt();
else if (key == "QMPlay_GID")
list[entry_idx].GID = value.toInt();
else if (key == "QMPlay_parent")
list[entry_idx].parent = value.toInt();
}
return list;
}
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);
}