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; otherwise raises an exception.
 162                  *
 163                  * \param key Key of the object to return.
 164                  */
 165                 BEncode &operator[](const String &key);
 166
 167                 /** If this object is MAP then it returns constant reference to BEncode
 168                  * object belonging to given key; otherwise raises an exception.
 169                  *
 170                  * \param key Key of the object to return.
 171                  */
 172                 const BEncode &operator[](const String &key) const;
 173
 174                 /** Loads encoded data from stream and stores them to object.
 175                  *
 176                  * \param s Input stream to read from.
 177                  * \param b BEncode object to store data into.
 178                  */
 179                 friend std::istream &operator>>(std::istream &s, BEncode &b);
 180
 181                 /** Stores given object to stream.
 182                  *
 183                  * \param s Output stream to write to.
 184                  * \param b Object to store.
 185                  */
 186                 friend std::ostream &operator<<(std::ostream &s, const BEncode &b);
 187
 188         private:
 189                 /** Reads a string from a stream.
 190                  *
 191                  * \param s Input stream from which the data will be read.
 192                  * \param str String object in which the data will be stored.
 193                  */
 194                 static bool readString(std::istream &s, String &str);
 195
 196         private:
 197                 /** Type of this BEnocde.
 198                  */
 199                 Type type;
 200
 201                 /** Value of this BEncode.
 202                  */
 203                 union {
 204                         /** Integer value.
 205                          */
 206                         int64_t value;
 207
 208                         /** String value.
 209                          */
 210                         String *string;
 211
 212                         /** List value.
 213                          */
 214                         BEncode::List *list;
 215
 216                         /** Dictionary value.
 217                          */
 218                         BEncode::Map *map;
 219                 };
 220 };
 221
 222 /** \brief Exception that is raised by BEncode class.
 223  */
 224 class BEncodeException : public Tairon::Core::Exception
 225 {
 226         public:
 227                 /** Standard constructor.
 228                  */
 229                 BEncodeException(const String &desc) : Tairon::Core::Exception(desc) {};
 230
 231                 /** Default destructor.
 232                  */
 233                 ~BEncodeException() {};
 234 };
 235
 236 }; // namespace Core
 237
 238 }; // namespace Tairent
 239
 240 #endif
 241
 242 // vim: ai sw=4 ts=4 noet fdm=marker