kfile-plugins/torrent/blist.cpp

   1 /*
   2  * Copyright (c) 2003, 2004 Michael Pyne <michael.pyne@kdemail.net>
   3  *
   4  * This software is free software; you can redistribute it and/or
   5  * modify it under the terms of the GNU General Public License as
   6  * published by the Free Software Foundation; either version 2 of
   7  * the License, or (at your option) any later version.
   8  *
   9  * This software is distributed in the hope that it will be useful,
  10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12  * GNU General Public License for more details.
  13  *
  14  * You should have received a copy of the GNU General Public
  15  * License along with this library; see the file COPYING.
  16  * If not, write to the Free Software Foundation, Inc.,
  17  * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  18  */
  19 #include <qiodevice.h>
  20
  21 #include "bytetape.h"
  22 #include "blist.h"
  23 #include "bdict.h"
  24 #include "bstring.h"
  25 #include "bint.h"
  26
  27 BList::BList (ByteTape &tape)
  28     : m_valid(false), m_array()
  29 {
  30     init (tape);
  31 }
  32
  33 BList::BList (QByteArray &dict, unsigned int start)
  34     : m_valid(false), m_array()
  35 {
  36     ByteTape tape (dict, start);
  37
  38     init (tape);
  39 }
  40
  41 void BList::init (ByteTape &tape)
  42 {
  43     BBase *temp;
  44
  45     if (*tape != 'l')
  46         return;
  47
  48     tape++;
  49
  50     /* Repeat circling over the string until the list is over */
  51     while (*tape != 'e')
  52     {
  53         switch (*tape)
  54         {
  55             case 'd':
  56                 temp = new BDict (tape);
  57             break;
  58
  59             case 'l': /* This element is a list */
  60                 temp = new BList (tape);
  61             break;
  62
  63             case 'i': /* This element is an int */
  64                 temp = new BInt (tape);
  65             break;
  66
  67             default: /* Maybe a string? */
  68                 temp = new BString (tape);
  69         }
  70
  71         if (!temp || !temp->isValid())
  72             return;  // Invalid list element
  73
  74         m_array.append (temp);
  75     }
  76
  77     m_valid = true;
  78
  79     // Only way out is to detect 'e', so we need to increment tape past that.
  80     tape++;
  81 }
  82
  83 BList::~BList()
  84 {
  85     BBaseVectorIterator iter;
  86
  87     for (iter = begin(); iter != end(); ++iter)
  88         delete *iter;
  89 }
  90
  91 BBase* BList::index (unsigned int i)
  92 {
  93     if (i >= count())
  94         return 0;
  95     else
  96         return m_array[i];
  97 }
  98
  99 BList * BList::indexList (unsigned int i)
 100 {
 101     BBase *base = index(i);
 102
 103     if (base && base->type_id() == bList)
 104         return dynamic_cast<BList*>(base);
 105
 106     return 0;
 107 }
 108
 109 BInt * BList::indexInt (unsigned int i)
 110 {
 111     BBase *base = index(i);
 112
 113     if (base && base->type_id() == bInt)
 114         return dynamic_cast<BInt*>(base);
 115
 116     return 0;
 117 }
 118
 119 BDict * BList::indexDict (unsigned int i)
 120 {
 121     BBase *base = index(i);
 122
 123     if (base && base->type_id() == bDict)
 124         return dynamic_cast<BDict*>(base);
 125
 126     return 0;
 127 }
 128
 129 BString * BList::indexStr (unsigned int i)
 130 {
 131     BBase *base = index(i);
 132
 133     if (base && base->type_id() == bString)
 134         return dynamic_cast<BString*>(base);
 135
 136     return 0;
 137 }
 138
 139 bool BList::writeToDevice(QIODevice &device)
 140 {
 141     if (!m_valid)
 142         return false;
 143
 144     const char *l_str = "l";
 145     const char *e_str = "e";
 146     Q_LONG written = 0, result = 0;
 147
 148     written = device.write (l_str, 1);
 149     while (written < 1)
 150     {
 151         if (written < 0 || result < 0)
 152             return false;
 153
 154         result = device.write (l_str, 1);
 155         written += result;
 156     }
 157
 158     BBaseVectorIterator iter;
 159     for (iter = begin(); iter != end(); ++iter)
 160     {
 161         if (!((*iter)->writeToDevice (device)))
 162             return false;
 163     }
 164
 165     written = device.write (e_str, 1);
 166     while (written < 1)
 167     {
 168         if (written < 0 || result < 0)
 169             return false;
 170
 171         result = device.write (e_str, 1);
 172         written += result;
 173     }
 174
 175     return true;
 176 }
 177
 178 // vim: set et sw=4 ts=4: