void MultipleAvroFileWriter::commit() {
RMF_TRACE("Writing frame " << frame_.index);
for (unsigned int i = 0; i < categories_.size(); ++i) {
if (categories_[i].dirty) {
if (!categories_[i].writer) {
std::string name = get_category_dynamic_file_path(Category(i));
try {
categories_[i].writer.reset(
new internal_avro::DataFileWriter<RMF_avro_backend::Data>(
name.c_str(), internal_avro::compileJsonSchemaFromString(
data_deprecated_avro::data_json)));
}
catch (const std::exception& e) {
RMF_THROW(Message(e.what()) << Component(name), IOException);
}
}
// show(categories_[i].data);
RMF_INTERNAL_CHECK(categories_[i].data.frame == frame_.index,
"Trying to write category that is at wrong frame.");
categories_[i].writer->write(categories_[i].data);
categories_[i].writer->flush();
}
categories_[i].data = RMF_avro_backend::Data();
// go to the about to be added frame
categories_[i].data.frame = frame_.index + 1;
}
for (unsigned int i = 0; i < static_categories_.size(); ++i) {
if (static_categories_dirty_[i]) {
std::string name = get_category_static_file_path(Category(i));
try {
internal_avro::DataFileWriter<RMF_avro_backend::Data> writer(
name.c_str(), internal_avro::compileJsonSchemaFromString(
data_deprecated_avro::data_json));
writer.write(static_categories_[i]);
writer.flush();
}
catch (const std::exception& e) {
RMF_THROW(Message(e.what()) << Component(name), IOException);
}
// std::cout << "Writing data for " << get_category_name(Category(i)) <<
// std::endl;
// show(static_categories_[i]);
static_categories_dirty_[i] = false;
}
}
RMF_COMMIT(File, file);
RMF_COMMIT(Nodes, nodes);
if (frames_dirty_) {
if (!frame_writer_) {
frame_writer_.reset(
new internal_avro::DataFileWriter<RMF_avro_backend::Frame>(
get_frames_file_path().c_str(),
internal_avro::compileJsonSchemaFromString(
data_deprecated_avro::frame_json)));
}
frame_writer_->write(frame_);
frames_dirty_ = false;
}
}
CategoriesModel::CategoriesModel(QObject* parent): QAbstractItemModel(parent)
{
m_categories.append(Category("All Songs", "audio", Category::AllMusic));
m_categories.append(Category("Artists", "user-identity", Category::Artists));
m_categories.append(Category("Albums", "tools-media-optical-copy", Category::Albums));
setRoleNames(MediaCenter::appendAdditionalMediaRoles(roleNames()));
}
Category Categories::get(const QString &name) {
const QString path = QSettings(APP_CONFIG_PATH + "categories", QSettings::IniFormat).value(name).toString();
if (path.isEmpty()) {
return Category();
}
return Category(name, path.endsWith("/") ? path : path + "/");
}
// -----------------------------------------------------------------------------
// CMmMtpDpMetadataAccessWrapper::AddObjectL
// Add object (music, video, playlist and abstract media) info to DB
// -----------------------------------------------------------------------------
//
EXPORT_C void CMmMtpDpMetadataAccessWrapper::AddObjectL( const CMTPObjectMetaData& aObject )
{
PRINT( _L( "MM MTP => CMmMtpDpMetadataAccessWrapper::AddObjectL" ) );
TMPXGeneralCategory category = Category( aObject );
TPtrC fullFileName( aObject.DesC( CMTPObjectMetaData::ESuid ) );
if ( category == EMPXVideo )
{
PRINT( _L( "MM MTP => CMmMtpDpMetadataAccessWrapper::AddObjectL Addvideo" ) );
iMmMtpDpMetadataVideoAccess->AddVideoL( fullFileName );
}
else if ( category == EMPXPlaylist || category == EMPXAbstractAlbum )
{
PRINT( _L( "MM MTP => CMmMtpDpMetadataAccessWrapper::AddObjectL AddPlaylist/AbstractAlbum" ) );
iMmMtpDpMetadataMpxAccess->AddAbstractMediaL( fullFileName,
category );
}
else if ( category == EMPXSong )
{
PRINT( _L( "MM MTP => CMmMtpDpMetadataAccessWrapper::AddObjectL AddSong" ) );
iMmMtpDpMetadataMpxAccess->AddSongL( fullFileName );
}
PRINT( _L( "MM MTP <= CMmMtpDpMetadataAccessWrapper::AddObjectL" ) );
}
// ---------------------------------------------------------------------------
// CMmMtpDpMetadataAccessWrapper::DeleteObjectL
// Deletes metadata information associated with the object
// ---------------------------------------------------------------------------
//
EXPORT_C void CMmMtpDpMetadataAccessWrapper::DeleteObjectL( const CMTPObjectMetaData& aObject )
{
TPtrC fileName( aObject.DesC( CMTPObjectMetaData::ESuid ) );
PRINT1( _L( "MM MTP => CMmMtpDpMetadataAccessWrapper::DeleteObjectL name = %S" ), &fileName );
TMPXGeneralCategory category = Category( aObject );
switch ( category )
{
case EMPXSong:
case EMPXAbstractAlbum:
case EMPXPlaylist:
{
iMmMtpDpMetadataMpxAccess->DeleteObjectL( fileName, category );
}
break;
case EMPXVideo:
{
iMmMtpDpMetadataVideoAccess->DeleteRecordL( fileName );
}
break;
default:
PRINT( _L( "MM MTP <> CMmMtpDpMetadataAccessWrapper::DeleteObjectL default" ) );
break;
}
PRINT( _L( "MM MTP <= CMmMtpDpMetadataAccessWrapper::DeleteObjectL" ) );
}
// ---------------------------------------------------------------------------
// CMmMtpDpMetadataAccessWrapper::RenameObjectL
// Renames the file part of a record in the collection database
// ---------------------------------------------------------------------------
//
EXPORT_C void CMmMtpDpMetadataAccessWrapper::RenameObjectL( const CMTPObjectMetaData& aOldObject,
const TDesC& aNewFileName )
{
TPtrC oldFileName( aOldObject.DesC( CMTPObjectMetaData::ESuid ) );
PRINT2( _L( "MM MTP => CMmMtpDpMetadataAccessWrapper::RenameObjectL old = %S, new = %S" ),
&oldFileName,
&aNewFileName );
TMPXGeneralCategory category = Category( aOldObject );
switch ( category )
{
case EMPXSong:
case EMPXAbstractAlbum:
case EMPXPlaylist:
{
iMmMtpDpMetadataMpxAccess->RenameObjectL( oldFileName,
aNewFileName,
category );
}
break;
case EMPXVideo:
iMmMtpDpMetadataVideoAccess->RenameRecordL( oldFileName, aNewFileName );
break;
default:
break;
}
PRINT( _L( "MM MTP <= CMmMtpDpMetadataAccessWrapper::RenameObjectL" ) );
}
// ---------------------------------------------------------------------------
// CMmMtpDpMetadataAccessWrapper::SetObjectMetadataValueL
// Sets a piece of metadata in the collection
// ---------------------------------------------------------------------------
//
void CMmMtpDpMetadataAccessWrapper::SetObjectMetadataValueL( const TUint16 aPropCode,
const MMTPType& aNewData,
const CMTPObjectMetaData& aObjectMetaData )
{
PRINT( _L( "MM MTP => CMmMtpDpMetadataAccessWrapper::SetObjectMetadataValueL" ) );
TMPXGeneralCategory category = Category( aObjectMetaData );
switch ( category )
{
case EMPXAbstractAlbum:
case EMPXSong:
case EMPXPlaylist:
iMmMtpDpMetadataMpxAccess->SetObjectMetadataValueL( aPropCode,
aNewData,
aObjectMetaData.DesC( CMTPObjectMetaData::ESuid ),
category );
break;
case EMPXVideo:
iMmMtpDpMetadataVideoAccess->SetObjectMetadataValueL( aPropCode,
aNewData,
aObjectMetaData );
break;
default:
break;
}
PRINT( _L( "MM MTP <= CMmMtpDpMetadataAccessWrapper::SetObjectMetadataValueL" ) );
}
TIntegrationEvent::TIntegrationEvent( char *name,
char *short_name,
INT_TIME time,
long code,
int priority,
TIntegrationEventCategory category)
/* --------------------------
* Author : Bruno Orsier : Original Delphi code
Diego Segura / Gilles Orazi : C++ translation
* Created : 06/2002
* Purpose :
* History :
* -------------------------- */
{
assert(strlen(name) < INT_MAX_STRING_LENGTH);
assert(strlen(short_name) < INT_MAX_SHORT_STRING_LENGTH);
Name(name);
Time(time);
Code(code);
m_priority = priority;
ShortName(short_name);
Category(category);
#ifdef INTEGR_DEBUG
++Glob_InEventsCount;
++Glob_InEventsTotal;
#endif
}
static void CompressBlock(JPEGCompressor *self,int comp,
const JPEGBlock *current,const JPEGBlock *north,const JPEGBlock *west,
const JPEGQuantizationTable *quantization)
{
// Calculate EOB context.
int average;
if(!north&&!west) average=0;
else if(!north) average=Sum(0,west);
else if(!west) average=Sum(0,north);
else average=(Sum(0,north)+Sum(0,west)+1)/2;
int eobcontext=Min(Category(average),12);
// Write EOB bits using binary tree.
WriteBitString(&self->encoder,current->eob,6,
self->eobbins[comp][eobcontext],
self->eobshift);
// Compress AC components in decreasing order, if any.
for(unsigned int k=current->eob;k>=1;k--)
{
CompressACComponent(self,comp,k,k!=current->eob,current,north,west,quantization);
}
// Compress DC component.
CompressDCComponent(self,comp,current,north,west,quantization);
}
void CSkinManager::RefreshAllSkins(bool bReload)
{
Combo()->Refresh();
MainFrame()->Refresh();
FavorBar()->Refresh();
MenuBar()->Refresh();
Tab()->Refresh();
Category()->Refresh();
Toolbar()->Refresh();
HelpButton()->Refresh();
LoadButton()->Refresh();
LoginButton()->Refresh();
SepButton()->Refresh();
SettingButton()->Refresh();
BigButton()->Refresh();
SSLLockButton()->Refresh();
StatusBar()->Refresh();
Tooltip()->Refresh();
MenuButton()->Refresh();
LogoButton()->Refresh();
Common()->Refresh(bReload);
BackButton()->Refresh();
ForwardButton()->Refresh();
RefreshButton()->Refresh();
CoolMenuSkin()->Refresh();
}
int Stick::Worth() const
{
int worth = Category()->worth();
worth += 20 * charges();
if (!is_known())
worth /= 2;
return worth;
}
// ---------------------------------------------------------------------------
// CMmMtpDpMetadataAccessWrapper::GetObjectMetadataValueL
// Gets a piece of metadata from the collection
// ---------------------------------------------------------------------------
//
EXPORT_C void CMmMtpDpMetadataAccessWrapper::GetObjectMetadataValueL( const TUint16 aPropCode,
MMTPType& aNewData,
const CMTPObjectMetaData& aObjectMetaData )
{
PRINT( _L( "MM MTP => CMmMtpDpMetadataAccessWrapper::GetObjectMetadataValueL" ) );
TMPXGeneralCategory category = Category( aObjectMetaData );
switch ( category )
{
case EMPXAbstractAlbum:
if ( aPropCode == EMTPObjectPropCodeDateAdded && EMTPTypeString == aNewData.Type() )
{
TBuf<KMtpMaxDateTimeStringLength> timeStr;
MmMtpDpUtility::GetObjectDateModifiedL( iFs,
aObjectMetaData.DesC( CMTPObjectMetaData::ESuid ),
timeStr );
PRINT1( _L( "MM MTP <> CGetObjectPropList::ServiceOneObjectPropertyL Date time %S" ), &timeStr );
( ( CMTPTypeString & ) aNewData ).SetL( timeStr );
break;
}
// else
// Fall through on purpoe to get from mpx
case EMPXPlaylist:
case EMPXSong:
{
iMmMtpDpMetadataMpxAccess->GetObjectMetadataValueL( aPropCode,
aNewData,
aObjectMetaData.DesC( CMTPObjectMetaData::ESuid ),
category );
}
break;
case EMPXVideo:
if ( aPropCode == EMTPObjectPropCodeDateAdded && EMTPTypeString == aNewData.Type() )
{
TBuf<KMtpMaxDateTimeStringLength> timeStr;
MmMtpDpUtility::GetObjectDateModifiedL( iFs,
aObjectMetaData.DesC( CMTPObjectMetaData::ESuid ),
timeStr );
PRINT1( _L( "MM MTP <> CGetObjectPropList::ServiceOneObjectPropertyL Date time %S" ), &timeStr );
( ( CMTPTypeString & ) aNewData ).SetL( timeStr );
}
else
{
iMmMtpDpMetadataVideoAccess->GetObjectMetadataValueL( aPropCode,
aNewData,
aObjectMetaData );
}
break;
default:
// do nothing
break;
}
PRINT( _L( "MM MTP <= CMmMtpDpMetadataAccessWrapper::GetObjectMetadataValueL" ) );
}
bool Parser::categoryFromNode(const XMLNode& categoryNode, Category& categoryInfo)
{
if (!categoryNode.isElementNode()
or (categoryNode.getNameAsString() != "category"))
return false;
const auto attributes = categoryNode.getAttributes();
if (attributes.empty())
{
std::cout << "Category element should have at least one attribute!" << std::endl;
return false;
} //if not enough attributes
//initialize element with empty values
categoryInfo = Category();
for (const auto& a : attributes)
{
const std::string attrName = a.first;
if (attrName == "term")
{
if (!categoryInfo.term().empty())
{
std::cout << "Category element already has a term!" << std::endl;
return false;
} //if term was already specified
categoryInfo.setTerm(a.second);
} //if term
else if (attrName == "scheme")
{
if (!categoryInfo.scheme().empty())
{
std::cout << "Category element already has a scheme!" << std::endl;
return false;
} //if scheme was already specified
categoryInfo.setScheme(a.second);
} //if scheme
else if (attrName == "label")
{
if (!categoryInfo.label().empty())
{
std::cout << "Category element already has a label!" << std::endl;
return false;
} //if label was already specified
categoryInfo.setLabel(a.second);
} //if label
else
{
std::cout << "Error: found unknown attribute " << a.first
<< " in <category> element of Atom 1.0 feed!" << std::endl;
return false;
}
} //for
//Category should not be empty.
return (!categoryInfo.empty());
}
void Pet::fromJson(nlohmann::json& val)
{
if(val.find("id") != val.end())
{
setId(val.at("id"));
}
if(val.find("category") != val.end())
{
if(!val["category"].is_null())
{
Category newItem(Category());
newItem.fromJson(val["category"]);
setCategory( newItem );
}
}
setName(val.at("name"));
{
m_PhotoUrls.clear();
nlohmann::json jsonArray;
for( auto& item : val["photoUrls"] )
{
m_PhotoUrls.push_back(item);
}
}
{
m_Tags.clear();
nlohmann::json jsonArray;
if(val.find("tags") != val.end())
{
for( auto& item : val["tags"] )
{
if(item.is_null())
{
m_Tags.push_back( Tag(nullptr) );
}
else
{
Tag newItem(Tag());
newItem.fromJson(item);
m_Tags.push_back( newItem );
}
}
}
}
if(val.find("status") != val.end())
{
setStatus(val.at("status"));
}
}
CategoryList Categories::get() {
QSettings categories(APP_CONFIG_PATH + "categories", QSettings::IniFormat);
CategoryList list;
foreach (const QString &name, categories.childKeys()) {
const QString path = categories.value(name).toString();
list << Category(name, path.endsWith("/") ? path : path + "/");
}
return list;
}
// -----------------------------------------------------------------------------
// CMmMtpDpMetadataMpxAccess::GetImageObjPropL
// get image specific properties specific to videos
// -----------------------------------------------------------------------------
//
void CMmMtpDpMetadataAccessWrapper::GetImageObjPropL( const CMTPObjectMetaData& aObject,
TUint32& aWidth,
TUint32& aHeight )
{
TMPXGeneralCategory category = Category( aObject );
if ( category == EMPXVideo )
{
TPtrC fullFileName( aObject.DesC( CMTPObjectMetaData::ESuid ) );
iMmMtpDpMetadataVideoAccess->SetStorageRootL( fullFileName );
iMmMtpDpMetadataVideoAccess->GetImageObjPropL( fullFileName, aWidth, aHeight );
}
}
FConfigVariableCategory* FConfigVariableManager::GetVariablesCategory(const std::string& CategoryName, bool bCreateIfNotExisting)
{
FFindCategoryByName SearchFunctor(CategoryName);
FConfigVariableCategory* Result = Categories.Find(SearchFunctor);
if (Result == nullptr && bCreateIfNotExisting)
{
FConfigVariableCategory Category(CategoryName);
Categories.Add(Category);
return &Categories.Last();
}
return Result;
}
/*!
\internal
*/
int QDesignerWidgetBoxInterface::findOrInsertCategory(const QString &categoryName)
{
int count = categoryCount();
for (int index=0; index<count; ++index) {
Category c = category(index);
if (c.name() == categoryName)
return index;
}
addCategory(Category(categoryName));
return count;
}
DtPrinterContainer *DtPrinterIcon::CreateContainer()
{
if (!container)
{
container = new DtPrinterContainer((char *)Category(), this,
queue->DisplayName());
mainw->RegisterPopup(container);
container->dnd = new DtDND(container, DndCB);
container->ApplicationData = queue;
ApplicationData = container;
}
return container;
}
int Ring::Worth() const
{
int worth = Category()->worth();
if (UsesBonuses()) {
if (get_ring_level() > 0)
worth += get_ring_level() * 100;
else
worth = 10;
}
if (!is_known())
worth /= 2;
return worth;
}
/**
Récupère tous les "objets" catégorie et retourne une QList, ces objets category
chargent a leurs instanciation les snippet et le langage qu'elles contiennent
**/
QList<Category> Category::loadAll(){
Log::put("Recuperation des objets de catégories",2);
QList<Category> categories = QList<Category>();
QStringList categoriesName = Category::getAll();
foreach(QString categoryName,categoriesName){
QStringList catInfos = categoryName.split(CATEGORY_LANGAGE_SEPARATOR);
Category category = Category();
category.setName(catInfos.at(0));
category.setLangage((catInfos.size()>1?catInfos.at(1):"Default"));
Log::put("Catégorie "+categoryName,3);
category.loadLangage();
category.loadSnippet();
categories.append(category);
}
void CSMPrefs::State::declareCategory (const std::string& key)
{
std::map<std::string, Category>::iterator iter = mCategories.find (key);
if (iter!=mCategories.end())
{
mCurrentCategory = iter;
}
else
{
mCurrentCategory =
mCategories.insert (std::make_pair (key, Category (this, key))).first;
}
}
QList<Category> Item::categories() const
{
QList<QDomElement> cats = elementsByTagNameNS(QString(),
QLatin1String("category"));
QList<Category> categories;
QList<QDomElement>::ConstIterator it = cats.constBegin();
for ( ; it != cats.constEnd(); ++it)
{
categories.append(Category(*it));
}
return categories;
}
// -----------------------------------------------------------------------------
// CMmMtpDpMetadataAccessWrapper::SetReferenceL
// Set abstract media to DB
// -----------------------------------------------------------------------------
//
EXPORT_C void CMmMtpDpMetadataAccessWrapper::SetReferenceL( const CMTPObjectMetaData& aObject,
CDesCArray& aRefFileArray )
{
TPtrC refOwner( aObject.DesC( CMTPObjectMetaData::ESuid ) );
PRINT1( _L( "MM MTP => CMmMtpDpMetadataAccessWrapper::SetReferenceL reference owner = %S" ),
&refOwner );
TMPXGeneralCategory category = Category( aObject );
if ( category == EMPXPlaylist || category == EMPXAbstractAlbum )
{
iMmMtpDpMetadataMpxAccess->SetReferenceL( refOwner, aRefFileArray, category );
}
PRINT( _L( "MM MTP <= CMmMtpDpMetadataAccessWrapper::SetReferenceL" ) );
}
bool JSONModel::dropMimeData(
const QMimeData *data,
Qt::DropAction action,
int row,
int column,
const QModelIndex &parent)
{
beginInsertRows(parent, elements.size(), elements.size());
elements.push_back(
LibraryElement
{"Name me!",
categoryMimeTypeMap().key(data->formats().first(), Category(-1)),
{"no tags"},
QJsonObject{}});
endInsertRows();
return false;
}
QList<Category> Source::categories() const
{
QList<QDomElement> a =
elementsByTagNameNS(atom1Namespace(),
QLatin1String("category"));
QList<Category> list;
QList<QDomElement>::ConstIterator it = a.constBegin();
QList<QDomElement>::ConstIterator end = a.constEnd();
for ( ; it != end; ++it)
{
list.append(Category(*it));
}
return list;
}
TIntegrationEvent::TIntegrationEvent( const TIntegrationEvent &source )
/* --------------------------
* Author : Bruno Orsier : Original Delphi code
Diego Segura / Gilles Orazi : C++ translation
* Created : 06/2002
* Purpose :
* History :
* -------------------------- */
{
Name(source.Name());
Time(source.Time());
Code(source.Code());
m_priority = source.Priority();
ShortName(source.ShortName());
Category(source.Category());
#ifdef INTEGR_DEBUG
++Glob_InEventsCount;
++Glob_InEventsTotal;
#endif
}
TIntegrationEvent& TIntegrationEvent::operator=(const TIntegrationEvent& source)
/* --------------------------
* Author : Bruno Orsier : Original Delphi code
Diego Segura / Gilles Orazi : C++ translation
* Created : 06/2002
* Purpose :
* History :
* -------------------------- */
{
if( this != &source )
{
Name(source.Name());
Time(source.Time());
Code(source.Code());
m_priority = source.Priority();
ShortName(source.ShortName());
Category(source.Category());
}
return *this;
}
std::string Stick::InventoryName() const
{
std::ostringstream ss;
ItemCategory& info = *Category();
if (info.is_discovered() || game->wizard().reveal_items()) {
ss << "A " << info.kind() << " of " << info.name() << get_charge_string(this);
if (!short_msgs())
ss << "(" << info.identifier() << ")";
}
else if (!info.guess().empty()) {
ss << "A " << info.kind() << " called " << info.guess();
if (!short_msgs())
ss << "(" << info.identifier() << ")";
}
else
ss << "A " << info.identifier() << " " << info.kind();
return ss.str();
}
bool DbNote::selectCategories(string where = "")
{
sqlite3_stmt *statement;
clearCategoryCache();
string stmnt = "select KatKey,KatDesc from KatTable ";
if (where.length() > 0)
stmnt += where;
if (!openDB())
{
throw SQLError("Can't open the DB-Connection");
return false;
}
int req = sqlite3_prepare_v2(db, stmnt.c_str(), stmnt.length(), &statement,
0);
if (req == SQLITE_ERROR)
{
throw SQLError("Can't select data of the given table");
return false;
}
sqlite3_column_count(statement);
do
{
req = sqlite3_step(statement);
Category cat = Category();
if (req == SQLITE_ROW)
{
cat.setKatKey((int) sqlite3_column_int(statement, 0));
char * str = (char *) sqlite3_column_text(statement, 1);
if (str != NULL)
cat.setKatDesc(str);
categories.push_back(cat);
}
//std::cout << cat.getDesc() << "\n";
}
while (req == SQLITE_ROW);
sqlite3_finalize(statement);
sqlite3_close(db);
return true;
}
