kworship/archive/KwArchive.cpp

   1 /***************************************************************************
   2  *   This file is part of KWorship.                                        *
   3  *   Copyright 2008 James Hogan <james@albanarts.com>                      *
   4  *                                                                         *
   5  *   KWorship is free software: you can redistribute it and/or modify      *
   6  *   it under the terms of the GNU General Public License as published by  *
   7  *   the Free Software Foundation, either version 2 of the License, or     *
   8  *   (at your option) any later version.                                   *
   9  *                                                                         *
  10  *   KWorship is distributed in the hope that it will be useful,           *
  11  *   but WITHOUT ANY WARRANTY; without even the implied warranty of        *
  12  *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the         *
  13  *   GNU General Public License for more details.                          *
  14  *                                                                         *
  15  *   You should have received a copy of the GNU General Public License     *
  16  *   along with KWorship.  If not, write to the Free Software Foundation,  *
  17  *   Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.   *
  18  ***************************************************************************/
  19
  20 /**
  21  * @file KwArchive.cpp
  22  * @brief A KWorship data archive file.
  23  * @author James Hogan <james@albanarts.com>
  24  */
  25
  26 #include "KwArchive.h"
  27 #include "KwDataFile.h"
  28
  29 #include <KTar>
  30 #include <KFilterDev>
  31
  32 #include <QFile>
  33 #include <QTextStream>
  34
  35 /*
  36  * Constructors + destructor
  37  */
  38
  39 /// Primary constructor.
  40 KwArchive::KwArchive(QIODevice* dev, bool writing)
  41 : KwResourceManager()
  42 , m_writing(writing)
  43 , m_compressor(0)
  44 , m_archive(0)
  45 , m_index(0)
  46 , m_numPlaylists(-1)
  47 {
  48   // Compression
  49   m_compressor = KFilterDev::device(dev, "application/x-bzip2", true);
  50   m_compressor->open(writing ? QFile::WriteOnly : QFile::ReadOnly);
  51
  52   // Archiving
  53   m_archive = new KTar(m_compressor);
  54   m_archive->open(writing ? QFile::WriteOnly : QFile::ReadOnly);
  55
  56   if (!writing)
  57   {
  58     m_index = loadDataFile("index.kw");
  59   }
  60   else
  61   {
  62     m_index = new KwDataFile();
  63   }
  64 }
  65
  66 /// Primary constructor.
  67 KwArchive::KwArchive(const QString& fileName, bool writing)
  68 : KwResourceManager()
  69 , m_writing(writing)
  70 , m_compressor(0)
  71 , m_archive(0)
  72 , m_index(0)
  73 , m_numPlaylists(-1)
  74 {
  75   // Archiving
  76   m_archive = new KTar(fileName, "application/x-bzip2");
  77   m_archive->open(writing ? QFile::WriteOnly : QFile::ReadOnly);
  78
  79   if (!writing)
  80   {
  81     m_index = loadDataFile("index.kw");
  82   }
  83   else
  84   {
  85     m_index = new KwDataFile();
  86   }
  87 }
  88
  89 /// Destructor.
  90 KwArchive::~KwArchive()
  91 {
  92   if (m_writing)
  93   {
  94     // Finally we need to write out the index file
  95     writeDataFile("index.kw", m_index);
  96   }
  97   delete m_index;
  98
  99   // Now its safe to close the archive
 100   m_archive->close();
 101   if (0 != m_compressor)
 102   {
 103     m_compressor->close();
 104   }
 105   delete m_archive;
 106 }
 107
 108 /*
 109  * Accessors
 110  */
 111
 112 /// Get whether the archive is being written.
 113 bool KwArchive::isWriting() const
 114 {
 115   return m_writing;
 116 }
 117
 118 /// Get whether the archive is being read.
 119 bool KwArchive::isReading() const
 120 {
 121   return !m_writing;
 122 }
 123
 124 /*
 125  * Main resource interface
 126  */
 127
 128 void KwArchive::addResource(const KwResourceLink* link)
 129 {
 130 }
 131
 132 /*
 133  * Playlist data
 134  */
 135
 136 /// Find how many playlists are in this archive.
 137 int KwArchive::numPlaylists()
 138 {
 139   return 0;
 140 }
 141
 142 /// Get a list of playlist names in this archive.
 143 QStringList KwArchive::playlists()
 144 {
 145   return QStringList();
 146 }
 147
 148 /// Create a new playlist from the archive.
 149 KwPlaylistList* KwArchive::extractPlaylist(QString name)
 150 {
 151   Q_ASSERT(isReading());
 152
 153   KwDataFile* playlistFile = loadDataFile("playlist/"+name+".kw");
 154   if (0 != playlistFile)
 155   {
 156     return playlistFile->extractPlaylist(this);
 157   }
 158   return 0;
 159 }
 160
 161 /// Add a playlist to the archive.
 162 void KwArchive::addPlaylist(KwPlaylistList* playlist)
 163 {
 164   Q_ASSERT(isWriting());
 165
 166   KwDataFile* playlistFile = new KwDataFile();
 167   playlistFile->insertPlaylist(playlist, this);
 168   writeDataFile(QString("playlist/%1.kw").arg(++m_numPlaylists),
 169                 playlistFile);
 170   delete playlistFile;
 171 }
 172
 173 /*
 174  * Access to song data
 175  */
 176
 177 /// Find how many songs are in this archive.
 178 int KwArchive::numSongs()
 179 {
 180   return 0;
 181 }
 182
 183 /// Get a list of song names in this archive.
 184 QStringList KwArchive::songs()
 185 {
 186   return QStringList();
 187 }
 188
 189 /*
 190  * Access to generic resources
 191  */
 192
 193 /// Find how many resources are in this archive.
 194 int KwArchive::numResources()
 195 {
 196   return 0;
 197 }
 198
 199 /// Get a list of resource names in this archive.
 200 QStringList KwArchive::resources()
 201 {
 202   return QStringList();
 203 }
 204
 205 /*
 206  * Data files
 207  */
 208
 209 /// Load a data file from the archive.
 210 KwDataFile* KwArchive::loadDataFile(QString path)
 211 {
 212   Q_ASSERT(isReading());
 213
 214   // Look for the entry
 215   const KArchiveEntry* entry = m_archive->directory()->entry(path);
 216   if (0 == entry || !entry->isFile())
 217   {
 218     return 0;
 219   }
 220
 221   // Turn entry into a file
 222   const KArchiveFile* fileEntry = dynamic_cast<const KArchiveFile*>(entry);
 223   Q_ASSERT(0 != fileEntry); // isFile() should mean entry is a KArchiveFile
 224
 225   QIODevice* fileDevice = fileEntry->createDevice();
 226   KwDataFile* dataFile = new KwDataFile();
 227   dataFile->readFrom(fileDevice);
 228   delete fileDevice;
 229
 230   return dataFile;
 231 }
 232
 233 /// Write a data file to the archive.
 234 void KwArchive::writeDataFile(QString path, const KwDataFile* data)
 235 {
 236   Q_ASSERT(isWriting());
 237
 238   // Get the raw xml data
 239   QByteArray xmlData;
 240   {
 241     QTextStream stream(&xmlData);
 242     data->writeTo(stream);
 243   }
 244
 245   // Write this to the archive
 246   time_t now = time(0);
 247   m_archive->writeFile(path, "user", "group", xmlData, xmlData.size(),
 248                        0100644, now, now, now);
 249 }
 250