void Decoder::decodeTags(ByteStream& strm, TagSet& tags) { //M_ASSERT(strm.remaining()); mstl::string name; mstl::string value; for (tag::ID id = tag::ID(strm.get()); id; id = tag::ID(strm.get())) { if (id == tag::ExtraTag) { name.clear(); value.clear(); strm.get(name); strm.get(value); tags.setExtra(name, value); } else { value.clear(); strm.get(value); tags.set(id, value); if (tag::isRatingTag(id)) tags.setSignificance(id, 0); } #define SCI_TAGS_FIX #ifdef SCI_TAGS_FIX if (strm.remaining() == 0) return; #endif } }
QValidator::State TagValidator::validate(QString& input, int &pos) const { Q_UNUSED(pos); QString str = input.trimmed(); if(str.length()==0) return Acceptable; TagSet ts = TagSet::parse(str); for(int i=0;i<=ts.sets();++i) { foreach(const QString& tag, ts.tags(i)) { // A tag name cannot start with ":" because that is reserved for // pseudo tags if(tag.at(0)==':') return Invalid; // A tag name cannot contain any of the separator characters for(int j=0;j<tag.length();++j) { QChar chr = tag.at(j); for(unsigned int k=0;k<sizeof(BADCHARS);++k) { if(chr==BADCHARS[k]) return Invalid; } } } } return Acceptable; }
save::State Decoder::doDecoding(db::Consumer& consumer, TagSet& tags) { uint16_t flags = m_strm.uint16(); uint16_t idn = flags & 0x0fff; if (idn) { m_position.setup(idn); } else { mstl::string fen; m_strm.get(fen); m_position.setup(fen); tags.set(tag::SetUp, "1"); // bad PGN design tags.set(tag::Fen, fen); } if (!consumer.startGame(tags, m_position.board())) return save::UnsupportedVariant; Byte* dataSection = m_strm.base() + m_strm.uint24(); ByteStream text, data; if (flags & 0x8000) { unsigned size = ByteStream::uint24(dataSection); text.setup(dataSection + 3, size); data.setup(text.end(), m_strm.end()); } else { data.setup(dataSection, m_strm.end()); } if (flags & 0x7000) { EngineList engines; decodeEngines(data, engines); consumer.swapEngines(engines); } consumer.startMoveSection(); decodeRun(m_strm.uint16(), consumer); decodeVariation(consumer, data, text); consumer.finishMoveSection(result::fromString(tags.value(tag::Result))); if (data.remaining()) decodeTags(data, tags); return consumer.finishGame(tags); }
void splitTags(const string &tagString, TagSet &tagSet) { stringstream ss(tagString); string tag; while(getline(ss, tag, ',')) { tagSet.insert(tag); } }
save::State Consumer::endGame(TagSet const& tags) { TagSet const* tagSet = &tags; TagSet* myTags = 0; if (m_text.tellp() > 0 && m_lastCommentPos == plyCount() && !tags.contains(tag::Termination)) { result::ID result = result::fromString(tags.value(tag::Result)); if (result == result::White || result == result::Black) { Byte const* s = m_text.data() + m_text.tellp() - 1; while (s > m_text.base() && s[-1]) --s; if ( ::strcasecmp(reinterpret_cast<char const*>(s), "time") == 0 || ::strcasecmp(reinterpret_cast<char const*>(s), "time/") == 0 || ::strcasecmp(reinterpret_cast<char const*>(s), "time!") == 0 || ::strcasecmp(reinterpret_cast<char const*>(s), "time forfeit") == 0) { myTags = new TagSet(tags); myTags->set(tag::Termination, termination::toString(termination::TimeForfeit)); tagSet = myTags; } } } unsigned dataOffset = m_strm.tellp(); encodeTextSection(); encodeDataSection(engines()); encodeTags(*tagSet, allowedTags(), allowExtraTags()); ByteStream::set(m_strm.base() + m_streamPos, uint24_t(dataOffset)); m_stream.provide(); save::State state = m_codec.addGame(m_stream, *tagSet, *this); if (myTags) delete myTags; return state; }
void BooksUtil::collectTagsFromLibrary(TagList &tags) { const TagList &lTags = Library::Instance().tags(); TagSet tagSet; for (TagList::const_iterator it = lTags.begin(); it != lTags.end(); ++it) { shared_ptr<Tag> tag = *it; if (tag.isNull()) { tagSet.insert(tag); tags.push_back(tag); } else { TagList tagStack; do { tagStack.push_back(tag); tag = tag->parent(); } while (!tag.isNull() && tagSet.find(tag) == tagSet.end()); tagSet.insert(tagStack.begin(), tagStack.end()); tags.insert(tags.end(), tagStack.rbegin(), tagStack.rend()); } } }
void Node::visit(Visitor& visitor, List const& nodes, TagSet const& tags) { result::ID result = result::fromString(tags.value(tag::Result)); visitor.start(result); for (unsigned i = 0; i < nodes.size(); ++i) nodes[i]->visit(visitor); visitor.finish(result); }
bool ClassHandler::init(Core::BaseObject *obj, void *n, TagSet &mandatory) { xmlNodePtr node = reinterpret_cast<xmlNodePtr>(n); // Fill in mandatory tags for ( MemberList::iterator it = attributes.begin(); it != attributes.end(); ++it ) { if ( !it->optional ) mandatory.insert(it->tag); } for ( MemberList::iterator it = elements.begin(); it != elements.end(); ++it ) { if ( !it->optional && !it->tag.empty() ) mandatory.insert(it->tag); } for ( MemberList::iterator it = childs.begin(); it != childs.end(); ++it ) { if ( !it->optional && !it->tag.empty() ) mandatory.insert(it->tag); } if ( cdataUsed ) cdata.get(obj, n, this); if ( attributes.empty() ) return true; for ( xmlAttrPtr attr = node->properties; attr != NULL; attr = attr->next ) { if ( attr->children ) { for ( MemberList::iterator it = attributes.begin(); it != attributes.end(); ++it ) { if ( equalsTag(attr, it->tag.c_str(), it->nameSpace.c_str()) ) { if ( it->get(obj, attr, this) && !it->optional ) { mandatory.erase(it->tag); break; } } } } } return true; }
// Disabled because Baloo does not work like Nepomuk: it does not create tags // independently of files. void SemanticInfoBackEndTest::testTagForLabel() { QSignalSpy spy(mBackEnd, SIGNAL(tagAdded(SemanticInfoTag,QString))); TagSet oldAllTags = mBackEnd->allTags(); QString label = "testTagForLabel-" + KRandom::randomString(5); SemanticInfoTag tag1 = mBackEnd->tagForLabel(label); QVERIFY(!tag1.isEmpty()); QVERIFY(!oldAllTags.contains(tag1)); QVERIFY(mBackEnd->allTags().contains(tag1)); // This is a new tag, we should receive a signal QCOMPARE(spy.count(), 1); SemanticInfoTag tag2 = mBackEnd->tagForLabel(label); QCOMPARE(tag1, tag2); // This is not a new tag, we should not receive a signal QCOMPARE(spy.count(), 1); QString label2 = mBackEnd->labelForTag(tag2); QCOMPARE(label, label2); }
DatabaseCodec::InfoData::InfoData(TagSet const& tags) :whiteCountry(country::Unknown) ,blackCountry(country::Unknown) ,eventCountry(country::Unknown) ,whiteTitle(title::None) ,blackTitle(title::None) ,whiteType(species::Unspecified) ,blackType(species::Unspecified) ,whiteSex(sex::Unspecified) ,blackSex(sex::Unspecified) ,whiteFideID(0) ,blackFideID(0) ,eventType(event::Unknown) ,timeMode(time::Unknown) ,eventMode(event::Undetermined) { if (tags.contains(tag::WhiteCountry)) whiteCountry = country::fromString(tags.value(tag::WhiteCountry)); if (tags.contains(tag::WhiteTitle)) whiteTitle = title::fromString(tags.value(tag::WhiteTitle)); if (tags.contains(tag::WhiteType)) whiteType = species::fromString(tags.value(tag::WhiteType)); if (tags.contains(tag::WhiteSex)) whiteSex = sex::fromChar(*tags.value(tag::WhiteSex)); if (tags.contains(tag::BlackCountry)) blackCountry = country::fromString(tags.value(tag::BlackCountry)); if (tags.contains(tag::BlackTitle)) blackTitle = title::fromString(tags.value(tag::BlackTitle)); if (tags.contains(tag::BlackType)) blackType = species::fromString(tags.value(tag::BlackType)); if (tags.contains(tag::BlackSex)) blackSex = sex::fromChar(*tags.value(tag::BlackSex)); if (tags.contains(tag::WhiteFideId)) whiteFideID = tags.asInt(tag::WhiteFideId); if (tags.contains(tag::BlackFideId)) blackFideID = tags.asInt(tag::BlackFideId); if (tags.contains(tag::EventType)) eventType = event::typeFromString(tags.value(tag::EventType)); if (tags.contains(tag::Mode)) eventMode = event::modeFromString(tags.value(tag::Mode)); if (tags.contains(tag::TimeMode)) timeMode = time::fromString(tags.value(tag::TimeMode)); if (tags.contains(tag::EventType)) eventType = event::typeFromString(tags.value(tag::EventType)); if (tags.contains(tag::EventCountry)) eventCountry = country::fromString(tags.value(tag::EventCountry)); if (tags.contains(tag::EventDate)) eventDate.fromString(tags.value(tag::EventDate)); }
save::State DatabaseCodec::saveGame(ByteStream const& gameData, TagSet const& tags, Provider const& provider) { //M_REQUIRE(isOpen()); typedef Namebase::PlayerEntry* Player; typedef Namebase::EventEntry* Event; typedef Namebase::SiteEntry* Site; typedef Namebase::Entry* Entry; if (gameData.size() > maxGameRecordLength()) return save::GameTooLong; if (provider.plyCount() > maxGameLength()) return save::GameTooLong; GameInfo* info = 0; unsigned index; if (provider.index() >= 0) { index = provider.index(); info = m_db->m_gameInfoList[index]; *m_storedInfo = *info; info->reset(m_db->m_namebases); } else if (m_db->size() == maxGameCount()) { return save::TooManyGames; } else { index = m_db->m_gameInfoList.size(); } unsigned maxAnnotatorCount = this->maxAnnotatorCount(); unsigned maxPlayerCount = this->maxPlayerCount(); InfoData data(tags); Player whiteEntry; Player blackEntry; Site siteEntry; switch (provider.sourceFormat()) { case format::Scid3: case format::Scid4: { mstl::string name; whiteEntry = namebase(Namebase::Player).insertPlayer( ::normalizePlayerName(tags.value(tag::White), name), data.whiteCountry, data.whiteTitle, data.whiteType, data.whiteSex, data.whiteFideID, maxPlayerCount); blackEntry = namebase(Namebase::Player).insertPlayer( ::normalizePlayerName(tags.value(tag::Black), name), data.blackCountry, data.blackTitle, data.blackType, data.blackSex, data.blackFideID, maxPlayerCount); siteEntry = namebase(Namebase::Site).insertSite( ::normalizeSiteName(tags.value(tag::Site), name), data.eventCountry, maxSiteCount()); } break; default: whiteEntry = namebase(Namebase::Player).insertPlayer( tags.value(tag::White), data.whiteCountry, data.whiteTitle, data.whiteType, data.whiteSex, data.whiteFideID, maxPlayerCount); blackEntry = namebase(Namebase::Player).insertPlayer( tags.value(tag::Black), data.blackCountry, data.blackTitle, data.blackType, data.blackSex, data.blackFideID, maxPlayerCount); siteEntry = namebase(Namebase::Site).insertSite( tags.value(tag::Site), data.eventCountry, maxSiteCount()); } Event eventEntry = namebase(Namebase::Event).insertEvent( tags.value(tag::Event), data.eventDate, data.eventType, data.timeMode, data.eventMode, maxEventCount(), siteEntry ? siteEntry : NamebaseEvent::emptySite()); Entry annotatorEntry = NamebaseEntry::emptyEntry(); if (maxAnnotatorCount) { annotatorEntry = namebase(Namebase::Annotator).insert(tags.value(tag::Annotator), maxAnnotatorCount); } save::State state = save::Ok; bool failed = whiteEntry == 0 || blackEntry == 0 || eventEntry == 0 || siteEntry == 0 || annotatorEntry == 0; unsigned gameOffset = 0; // shut up compiler if (!failed) { if (info) gameOffset = putGame(gameData, info->gameOffset(), info->gameRecordLength()); else gameOffset = putGame(gameData); } if (failed || int(gameOffset) < 0) { if (info) info->restore(*m_storedInfo, m_db->m_namebases); namebases().update(); switch (gameOffset) { /*case util::BlockFile::MaxFileSizeExceeded: IO_RAISE(Game, Max_File_Size_Exceeded, "maximal file size (2 GB) exceeded"); case util::BlockFile::SyncFailed: IO_RAISE(Game, Write_Failed, "sync failed"); case util::BlockFile::ReadError: IO_RAISE(Game, Read_Error, "read error"); case util::BlockFile::IllegalOffset: IO_RAISE(Game, Write_Failed, "offset failure (internal error)");*/ } if (!whiteEntry) return save::TooManyPlayerNames; if (!blackEntry) return save::TooManyPlayerNames; if (!eventEntry) return save::TooManyEventNames; if (!siteEntry) return save::TooManySiteNames; return save::TooManyAnnotatorNames; } if (info == 0) { info = allocGameInfo(); m_db->m_gameInfoList.push_back(info); } info->setup(gameOffset, gameData.size(), whiteEntry, blackEntry, eventEntry, annotatorEntry, tags, provider, m_db->m_namebases); return state; }
save::State DatabaseCodec::updateCharacteristics(unsigned index, TagSet const& tags) { //M_REQUIRE(isOpen()); typedef Namebase::PlayerEntry* Player; typedef Namebase::EventEntry* Event; typedef Namebase::SiteEntry* Site; typedef Namebase::Entry* Entry; GameInfo* info = m_db->m_gameInfoList[index]; *m_storedInfo = *info; info->resetCharacteristics(m_db->m_namebases); unsigned maxAnnotatorCount = this->maxAnnotatorCount(); unsigned maxPlayerCount = this->maxPlayerCount(); InfoData data(tags); Player whiteEntry = namebase(Namebase::Player).insertPlayer( tags.value(tag::White), data.whiteCountry, data.whiteTitle, data.whiteType, data.whiteSex, data.whiteFideID, maxPlayerCount); Player blackEntry = namebase(Namebase::Player).insertPlayer( tags.value(tag::Black), data.blackCountry, data.blackTitle, data.blackType, data.blackSex, data.blackFideID, maxPlayerCount); Site siteEntry = namebase(Namebase::Site).insertSite( tags.value(tag::Site), data.eventCountry, maxSiteCount()); Event eventEntry = namebase(Namebase::Event).insertEvent( tags.value(tag::Event), data.eventDate, data.eventType, data.timeMode, data.eventMode, maxEventCount(), siteEntry ? siteEntry : NamebaseEvent::emptySite()); Entry annotatorEntry = NamebaseEntry::emptyEntry(); if (maxAnnotatorCount) { annotatorEntry = namebase(Namebase::Annotator). insert(tags.value(tag::Annotator), maxAnnotatorCount); } bool failed = whiteEntry == 0 || blackEntry == 0 || eventEntry == 0 || siteEntry == 0 || annotatorEntry == 0; save::State state = save::Ok; if (!failed && format() != format::Scidb) { } if (failed) { info->restore(*m_storedInfo, m_db->m_namebases); namebases().update(); if (!whiteEntry) return save::TooManyPlayerNames; if (!blackEntry) return save::TooManyPlayerNames; if (!eventEntry) return save::TooManyEventNames; if (!siteEntry) return save::TooManySiteNames; return save::TooManyAnnotatorNames; } info->update( whiteEntry, blackEntry, eventEntry, annotatorEntry, tags, m_db->m_namebases); return state; }
bool TagSet::includes(const TagSet& t) const { //return !empty() && std::includes( this->begin(), this->end(), t.begin(), t.end()); if (t.empty()) return true; if (empty()) { // An empty TagSet satisfies the conditions only if either : // t is also empty (already handled) // t only includes negative tags if (*t.rbegin() <= Tag(0)) return true; // t includes the "0" tag if (t.count(Tag(0)) > 0) return true; // otherwise the TagSet t does not "include" empty sets return false; } #if 1 // Simple but not optimal version for (sofa::helper::set<Tag>::const_iterator first2 = t.begin(), last2 = t.end(); first2 != last2; ++first2) { Tag t2 = *first2; if (t2 == Tag(0)) continue; // tag "0" is used to indicate that we should include objects without any tag if (!t2.negative()) { if (this->count(t2) == 0) return false; // tag not found in this } else { if (this->count(-t2) > 0) return false; // tag found in this } } return true; #else // First test : no negative tag from t should appear as positive in this if (t.begin()->negative()) { sofa::helper::set<Tag>::const_reverse_iterator first1, last1; sofa::helper::set<Tag>::const_iterator first2, last2; first1 = this->rbegin(); last1 = this->rend(); first2 = t.begin(); last2 = t.end(); for (; first2 != last2; ++first1) { if (first1 == last1) break; // no more tags in this Tag t1 = *first1; if (t1.negative()) break; // no more positive tags in this Tag t2 = *first2; if (!t2.negative()) break; // no more negative tags in t if (-t1 == t2) return false; // found an excluded tag if (!(-t1 < t2)) ++first2; } } // Second test : all positive tags from t should appear as positive in this if (!t.rbegin()->negative()) { sofa::helper::set<Tag>::const_iterator first1, last1; sofa::helper::set<Tag>::const_iterator first2, last2; first1 = this->lower_bound(Tag(0)); last1 = this->end(); first2 = t.lower_bound(Tag(0)); last2 = t.end(); //for(; first1 != last1 && first1->negative(); ++first1); // skip negative tags in this //for(; first2 != last2 && first2->negative(); ++first2); // skip negative tags in t for (; first2 != last2; ++first1) { if (first1 == last1) return false; // no more positive tags in this Tag t1 = *first1; Tag t2 = *first2; if (t2 < t1) return false; // tag not found if (!(t1 < t2)) ++first2; } } return true; // all tests passed #endif }
bool Importer::traverse(NodeHandler *handler, void *n, void *c, Core::BaseObject *target) { xmlNodePtr node = reinterpret_cast<xmlNodePtr>(n); xmlNodePtr childs = reinterpret_cast<xmlNodePtr>(c); ChildList remaining; TagSet mandatory; handler->init(target, n, mandatory); bool result = true; for ( xmlNodePtr child = childs; child != NULL; child = child->next ) { if ( child->type != XML_ELEMENT_NODE ) continue; handler->propagate(NULL, false, true); try { handler->get(target, child); } catch ( std::exception &e ) { if ( handler->isOptional ) SEISCOMP_WARNING("(optional) %s.%s: %s", node->name, child->name, e.what()); else throw e; } if ( !handler->isOptional ) mandatory.erase((const char*)child->name); if ( handler->object == NULL && handler->isAnyType ) { if ( _any.get(target, child) ) { handler->object = _any.object; handler->childHandler = _any.childHandler; handler->newInstance = _any.newInstance; } } Core::BaseObject *newTarget = handler->object; MemberNodeHandler *memberHandler = handler->memberHandler; NodeHandler *childHandler = handler->childHandler; bool newInstance = handler->newInstance; bool optional = handler->isOptional; if ( newTarget ) { if ( childHandler == NULL ) { childHandler = _typemap->getHandler(newTarget->className()); if ( childHandler == NULL ) { SEISCOMP_WARNING("No class handler for %s", newTarget->className()); if ( newInstance ) delete newTarget; handler->object = NULL; newTarget = NULL; childHandler = &_none; } } } else childHandler = &_none; try { if ( traverse(childHandler, child, child->children, handler->object) ) { if ( newTarget && newInstance && !memberHandler ) remaining.push_back(newTarget); } else { if ( newTarget && newInstance ) delete newTarget; newTarget = NULL; if ( optional ) SEISCOMP_INFO("Invalid %s element: ignoring", child->name); else { SEISCOMP_WARNING("%s is not optional within %s", child->name, node->name); result = false; } } } catch ( std::exception &e ) { SEISCOMP_WARNING("%s: %s", child->name, e.what()); if ( newTarget ) { if ( newInstance ) delete newTarget; if ( !optional ) { SEISCOMP_WARNING("%s is not optional within %s", child->name, node->name); result = false; } else SEISCOMP_WARNING("%s: ignoring optional member %s: invalid", node->name, child->name); newTarget = NULL; } } if ( memberHandler ) { if ( !memberHandler->finalize(target, newTarget) ) { if ( newTarget && newInstance ) remaining.push_back(newTarget); } } } handler->finalize(target, &remaining); if ( target != NULL ) { for ( ChildList::iterator it = remaining.begin(); it != remaining.end(); ++it ) if ( *it != NULL ) delete *it; } else { for ( ChildList::iterator it = remaining.begin(); it != remaining.end(); ++it ) { if ( *it != NULL ) { if ( _result == NULL ) _result = *it; else delete *it; } } } if ( !mandatory.empty() ) { std::string attribs; for ( TagSet::iterator it = mandatory.begin(); it != mandatory.end(); ++it ) { if ( it != mandatory.begin() ) attribs += ", "; attribs += *it; } SEISCOMP_WARNING("%s: missing mandatory attribute%s: %s", node->name, mandatory.size() == 1?"":"s", attribs.c_str()); return false; } return result; }
QDebug operator<<(QDebug dbg, const TagSet &ts) { dbg.nospace() << "Tagset " << ts.uri() << " [" << ts.title() << "]" <<"\n"; dbg.nospace() << " DiscId " << ts.diskTag(TAG_DISCID) << "\n"; dbg.nospace() << " Genre " << ts.diskTag(TAG_GENRE) << "\n"; dbg.nospace() << " Artist " << ts.diskTag(TAG_PERFORMER) << "\n"; dbg.nospace() << " Album " << ts.diskTag(TAG_ALBUM) << "\n"; dbg.nospace() << " Date " << ts.diskTag(TAG_DATE) << "\n"; for (int i=0; i < ts.tracksCount(); ++i) { dbg.nospace() << " Track " << i << "-=-=-=-=-" << "\n"; dbg.nospace() << " * Album " << ts.trackTag(i, TAG_ALBUM) << "\n"; dbg.nospace() << " * Artist " << ts.trackTag(i, TAG_PERFORMER) << "\n"; dbg.nospace() << " * Title " << ts.trackTag(i, TAG_TITLE) << "\n"; dbg.nospace() << " * Genre " << ts.trackTag(i, TAG_GENRE) << "\n"; } return dbg.space(); }
bool TagSet::includes(const TagSet& t) const { return !empty() && std::includes( this->begin(), this->end(), t.begin(), t.end()); }