src/core/bencode.h

   1 /***************************************************************************
   2  *                                                                         *
   3  *   Copyright (C) <year>  <author>                                        *
   4  *                                                                         *
   5  *   This program is free software; you can redistribute it and/or         *
   6  *   modify it under the terms of the GNU General Public License as        *
   7  *   published by the Free Software Foundation and appearing               *
   8  *   in the file LICENSE.GPL included in the packaging of this file.       *
   9  *                                                                         *
  10  *   This program 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 GNU      *
  13  *   General Public License for more details.                              *
  14  *                                                                         *
  15  ***************************************************************************/
  16
  17 #ifndef _core_bencode_h
  18 #define _core_bencode_h
  19
  20 #include <stdint.h>
  21 #include <list>
  22 #include <map>
  23
  24 #include <tairon/core/exceptions.h>
  25
  26 using Tairon::Core::String;
  27
  28 namespace Tairent
  29 {
  30
  31 namespace Core
  32 {
  33
  34 /** \brief Class that is used to hold bencoded informations.
  35  */
  36 class BEncode
  37 {
  38         public:
  39                 /** List type.
  40                  */
  41                 typedef std::list<BEncode> List;
  42
  43                 /** Dictionary type.
  44                  */
  45                 typedef std::map<String, BEncode> Map;
  46
  47                 /** BEncode types.
  48                  */
  49                 enum Type {
  50                         NONE, VALUE, STRING, LIST, MAP
  51                 };
  52
  53         public:
  54                 /** Constructs BEncode object of type NONE.
  55                  */
  56                 BEncode();
  57
  58                 /** Constructs BEncode object of type VALUE.
  59                  *
  60                  * \param v Value to store in object.
  61                  */
  62                 BEncode(const int64_t v);
  63
  64                 /** Constructs BEncode object of type STRING.
  65                  *
  66                  * \param s String to store in object.
  67                  */
  68                 BEncode(const String &s);
  69
  70                 /** Copy constructor.
  71                  *
  72                  * \param b BEncode object to copy.
  73                  */
  74                 BEncode(const BEncode &b);
  75
  76                 /** Explicitly constructs BEncode object of given type.
  77                  *
  78                  * \param t Type of the object to construct.
  79                  */
  80                 explicit BEncode(Type t);
  81
  82                 /** Destroys the object.
  83                  */
  84                 ~BEncode();
  85
  86                 /** Converts this BEncode object to LIST and returns it as a reference.
  87                  */
  88                 BEncode::List &asList();
  89
  90                 /** Converts this BEncode object to MAP and returns it as a reference.
  91                  */
  92                 BEncode::Map &asMap();
  93
  94                 /** Converts this BEncode object to STRING and returns it as a
  95                  * reference.
  96                  */
  97                 String &asString();
  98
  99                 /** Converts this BEncode object to VALUE and returns it as a
 100                  * reference.
 101                  */
 102                 int64_t &asValue();
 103
 104                 /** Converts this BEncode object to LIST and returns a constant
 105                  * reference to it.
 106                  */
 107                 const BEncode::List &asList() const;
 108
 109                 /** Converts this BEncode object to MAP and returns a constant
 110                  * reference to it.
 111                  */
 112                 const BEncode::Map &asMap() const;
 113
 114                 /** Converts this BEncode object to STRING and returns a constant
 115                  * reference to it.
 116                  */
 117                 const String &asString() const;
 118
 119                 /** Converts this BEncode object to VALUE and returns a constant
 120                  * reference to it.
 121                  */
 122                 const int64_t &asValue() const;
 123
 124                 /** Clears all data from this object and its type sets to NONE.
 125                  */
 126                 void clear();
 127
 128                 /** Returns true if this object is LIST; otherwise returns false.
 129                  */
 130                 bool isList() const;
 131
 132                 /** Returns true if this object is MAP; otherwise returns false.
 133                  */
 134                 bool isMap() const;
 135
 136                 /** Returns true if this object is STRING; otheriwse returns false.
 137                  */
 138                 bool isString() const;
 139
 140                 /** Returns true if this object is VALUE; otherwise returns false.
 141                  */
 142                 bool isValue() const;
 143
 144                 /** Returns type of this object.
 145                  */
 146                 Type getType() const;
 147
 148                 /** Computes SHA1 hash of string representing this object.
 149                  */
 150                 String computeSHA1() const;
 151
 152                 /** Assigns value of given object to this object and returns a
 153                  * reference to
 154                  * it.
 155                  *
 156                  * \param b Object to set the value of this object to.
 157                  */
 158                 BEncode &operator=(const BEncode &b);
 159
 160                 /** If this object is MAP then it returns reference to BEncode object
 161                  * belonging to given key. If there is no such object then new one is
 162                  * created with type BEncode::NONE.
 163                  *
 164                  * \param key Key of the object to return.
 165                  */
 166                 BEncode &operator[](const String &key);
 167
 168                 /** If this object is MAP then it returns constant reference to BEncode
 169                  * object belonging to given key; otherwise raises an exception.
 170                  *
 171                  * \param key Key of the object to return.
 172                  */
 173                 const BEncode &operator[](const String &key) const;
 174
 175                 /** Loads encoded data from stream and stores them to object.
 176                  *
 177                  * \param s Input stream to read from.
 178                  * \param b BEncode object to store data into.
 179                  */
 180                 friend std::istream &operator>>(std::istream &s, BEncode &b);
 181
 182                 /** Stores given object to stream.
 183                  *
 184                  * \param s Output stream to write to.
 185                  * \param b Object to store.
 186                  */
 187                 friend std::ostream &operator<<(std::ostream &s, const BEncode &b);
 188
 189         private:
 190                 /** Reads a string from a stream.
 191                  *
 192                  * \param s Input stream from which the data will be read.
 193                  * \param str String object in which the data will be stored.
 194                  */
 195                 static bool readString(std::istream &s, String &str);
 196
 197         private:
 198                 /** Type of this BEnocde.
 199                  */
 200                 Type type;
 201
 202                 /** Value of this BEncode.
 203                  */
 204                 union {
 205                         /** Integer value.
 206                          */
 207                         int64_t value;
 208
 209                         /** String value.
 210                          */
 211                         String *string;
 212
 213                         /** List value.
 214                          */
 215                         BEncode::List *list;
 216
 217                         /** Dictionary value.
 218                          */
 219                         BEncode::Map *map;
 220                 };
 221 };
 222
 223 /** \brief Exception that is raised by BEncode class.
 224  */
 225 class BEncodeException : public Tairon::Core::Exception
 226 {
 227         public:
 228                 /** Standard constructor.
 229                  */
 230                 BEncodeException(const String &desc) : Tairon::Core::Exception(desc) {};
 231
 232                 /** Default destructor.
 233                  */
 234                 ~BEncodeException() {};
 235 };
 236
 237 }; // namespace Core
 238
 239 }; // namespace Tairent
 240
 241 #endif
 242
 243 // vim: ai sw=4 ts=4 noet fdm=marker