* make read non-static so you have to create a PackageStructure first; better symetry with write and prevents some unecessary object copies between methods (e.g. load -> read)

* provide a load method

svn path=/trunk/KDE/kdebase/workspace/libs/plasma/; revision=779402

packagestructure.cpp

@@ -20,7 +20,11 @@
 #include "packagestructure.h"
 
 #include <QMap>
+
 #include <KConfigGroup>
+#include <KStandardDirs>
+
+#include "packages_p.h"
 
 namespace Plasma
 {
@@ -75,6 +79,25 @@ PackageStructure::~PackageStructure()
     delete d;
 }
 
+PackageStructure PackageStructure::load(const QString &packageFormat)
+{
+    PackageStructure ps;
+
+    if (packageFormat.isEmpty()) {
+        return ps;
+    }
+
+    QString configPath("plasma/packageformats/%1rc");
+    configPath = KStandardDirs::locate("data", configPath.arg(packageFormat));
+
+    if (!configPath.isEmpty()) {
+        KConfig config(configPath);
+        ps.read(&config);
+    }
+
+    return ps;
+}
+
 PackageStructure& PackageStructure::operator=(const PackageStructure& rhs)
 {
     if (this == &rhs) {
@@ -232,40 +255,38 @@ QStringList PackageStructure::mimetypes(const char* key) const
     return it.value().mimetypes;
 }
 
-PackageStructure PackageStructure::read(const KConfigBase *config)
+void PackageStructure::read(const KConfigBase *config)
 {
-    QString type = config->group("").readEntry("Type", "");
-    PackageStructure structure(type);
-    
+    d->contents.clear();
+    d->mimetypes.clear();
+    d->type = config->group("").readEntry("Type", QString()); 
+
     QStringList groups = config->groupList();
-    foreach (QString groupName, groups) {
-        QByteArray key = groupName.toAscii();
-        KConfigGroup entry = config->group(key);
-        
+    foreach (QString group, groups) {
+        QByteArray key = group.toAscii();
+        KConfigGroup entry = config->group(group);
+
         QString path = entry.readEntry("Path", QString());
         QString name = entry.readEntry("Name", QString());
         QStringList mimetypes = entry.readEntry("Mimetypes", QStringList());
         bool directory = entry.readEntry("Directory", false);
         bool required = entry.readEntry("Required", false);
-        
+
         if (directory) {
-            structure.addDirectoryDefinition(key, path, name);
+            addDirectoryDefinition(key, path, name);
+        } else {
+            addFileDefinition(key, path, name);
         }
-        else {
-            structure.addFileDefinition(key, path, name);
-        }
-        
-        structure.setMimetypes(key, mimetypes);
-        structure.setRequired(key, required);
+
+        setMimetypes(key, mimetypes);
+        setRequired(key, required);
     }
-    
-    return structure;
 }
 
 void PackageStructure::write(KConfigBase *config) const
 {
     config->group("").writeEntry("Type", type());
-    
+
     QMap<QByteArray, ContentStructure>::const_iterator it = d->contents.constBegin();
     while (it != d->contents.constEnd()) {
         KConfigGroup group = config->group(it.key());
@@ -280,7 +301,7 @@ void PackageStructure::write(KConfigBase *config) const
         if (it.value().required) {
             group.writeEntry("Required", true);
         }
-        
+
         ++it;
     }
 }

packagestructure.h

@@ -22,6 +22,8 @@
 
 #include <QtCore/QStringList>
 
+#include <KLocale>
+
 #include <plasma/plasma_export.h>
 
 class KConfigBase;
@@ -67,7 +69,32 @@ public:
      *
      * @arg type the type of package. This is often application specific.
      **/
-    PackageStructure(const QString &type);
+    explicit PackageStructure(const QString &type = i18n("Invalid"));
+
+    /**
+     * Copy constructor
+     **/
+    PackageStructure(const PackageStructure& rhs);
+
+    /**
+     * Destructor
+     **/
+    virtual ~PackageStructure();
+
+    /**
+     * Assignment operator
+     **/
+    PackageStructure& operator=(const PackageStructure& rhs);
+
+    /**
+     * Loads a package format by name.
+     *
+     * @arg format If not empty, attempts to locate the given format, either
+     *             from built-ins or via plugins.
+     * @return a package that matches the format, if available. The caller
+     *         is responsible for deleting the object.
+     */
+    static PackageStructure load(const QString &package);
 
     /**
      * Type of package this structure describes
@@ -163,26 +190,11 @@ public:
      **/
     QStringList mimetypes(const char* key) const;
 
-    /**
-     * Copy constructor
-     **/
-    PackageStructure(const PackageStructure& rhs);
-
-    /**
-     * Destructor
-     **/
-    virtual ~PackageStructure();
-
-    /**
-     * Assignment operator
-     **/
-    PackageStructure& operator=(const PackageStructure& rhs);
-    
     /**
       * Read a package structure from a config file.
       */
-    static PackageStructure read(const KConfigBase *config);
-    
+    void read(const KConfigBase *config);
+
     /**
       * Write this package structure to a config file.
       */