src/exceptions.h

   1 /*
   2     Copyright (C) 2012-2021 Carl Hetherington <cth@carlh.net>
   3
   4     This file is part of libdcp.
   5
   6     libdcp is free software; you can redistribute it and/or modify
   7     it under the terms of the GNU General Public License as published by
   8     the Free Software Foundation; either version 2 of the License, or
   9     (at your option) any later version.
  10
  11     libdcp is distributed in the hope that it will be useful,
  12     but WITHOUT ANY WARRANTY; without even the implied warranty of
  13     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14     GNU General Public License for more details.
  15
  16     You should have received a copy of the GNU General Public License
  17     along with libdcp.  If not, see <http://www.gnu.org/licenses/>.
  18
  19     In addition, as a special exception, the copyright holders give
  20     permission to link the code of portions of this program with the
  21     OpenSSL library under certain conditions as described in each
  22     individual source file, and distribute linked combinations
  23     including the two.
  24
  25     You must obey the GNU General Public License in all respects
  26     for all of the code used other than OpenSSL.  If you modify
  27     file(s) with this exception, you may extend this exception to your
  28     version of the file(s), but you are not obligated to do so.  If you
  29     do not wish to do so, delete this exception statement from your
  30     version.  If you delete this exception statement from all source
  31     files in the program, then also delete it here.
  32 */
  33
  34
  35 /** @file  src/exceptions.h
  36  *  @brief Exceptions thrown by libdcp
  37  */
  38
  39
  40 #ifndef LIBDCP_EXCEPTIONS_H
  41 #define LIBDCP_EXCEPTIONS_H
  42
  43
  44 #include <boost/filesystem.hpp>
  45 #include <boost/optional.hpp>
  46
  47
  48 namespace dcp
  49 {
  50
  51
  52 /** @class FileError
  53  *  @brief An exception related to a file
  54  */
  55 class FileError : public std::runtime_error
  56 {
  57 public:
  58         FileError (std::string message, boost::filesystem::path filename, int number);
  59         ~FileError () throw () {}
  60
  61         /** @return filename of file that was involved */
  62         boost::filesystem::path filename () const {
  63                 return _filename;
  64         }
  65
  66         /** @return error number of the error */
  67         int number () const {
  68                 return _number;
  69         }
  70
  71 private:
  72         /** filename of file that was involved */
  73         boost::filesystem::path _filename;
  74         int _number;
  75 };
  76
  77
  78 /** @class MXFFileError
  79  *  @brief An exception related to an MXF file
  80  */
  81 class MXFFileError : public FileError
  82 {
  83 public:
  84         MXFFileError (std::string message, boost::filesystem::path filename, int number)
  85                 : FileError (message, filename, number)
  86         {}
  87 };
  88
  89
  90 /** @class MiscError
  91  *  @brief A miscellaneous exception
  92  */
  93 class MiscError : public std::runtime_error
  94 {
  95 public:
  96         explicit MiscError (std::string message)
  97                 : std::runtime_error (message)
  98         {}
  99 };
 100
 101
 102 /** @class ReadError
 103  *  @brief Any error that occurs when reading data from a DCP
 104  */
 105 class ReadError : public std::runtime_error
 106 {
 107 public:
 108         explicit ReadError (std::string message)
 109                 : std::runtime_error(message)
 110                 , _message(message)
 111         {}
 112
 113         ReadError (std::string message, std::string detail);
 114
 115         ~ReadError() throw () {}
 116
 117         std::string message () const {
 118                 return _message;
 119         }
 120
 121         boost::optional<std::string> detail () const {
 122                 return _detail;
 123         }
 124
 125 private:
 126         std::string _message;
 127         boost::optional<std::string> _detail;
 128 };
 129
 130
 131 /** @class J2KDecompressionError
 132  *  @brief An error that occurs during decompression of JPEG2000 data
 133  */
 134 class J2KDecompressionError : public ReadError
 135 {
 136 public:
 137         explicit J2KDecompressionError (std::string message)
 138                 : ReadError (message)
 139         {}
 140 };
 141
 142
 143 class MPEG2CodecError : public MiscError
 144 {
 145 public:
 146         explicit MPEG2CodecError(std::string message)
 147                 : MiscError(message)
 148         {}
 149 };
 150
 151
 152 class MPEG2DecompressionError : public ReadError
 153 {
 154 public:
 155         explicit MPEG2DecompressionError(std::string message)
 156                 : ReadError(message)
 157         {}
 158 };
 159
 160
 161 class BadContentKindError : public ReadError
 162 {
 163 public:
 164         BadContentKindError (std::string content_kind);
 165 };
 166
 167
 168 /** @class MissingAssetmapError
 169  *  @brief Thrown when no ASSETMAP was found when trying to read a DCP
 170  */
 171 class MissingAssetmapError : public ReadError
 172 {
 173 public:
 174         explicit MissingAssetmapError (boost::filesystem::path dir);
 175 };
 176
 177
 178 /** @class XMLError
 179  *  @brief An XML error
 180  */
 181 class XMLError : public std::runtime_error
 182 {
 183 public:
 184         explicit XMLError (std::string message)
 185                 : std::runtime_error (message)
 186         {}
 187 };
 188
 189
 190 /** @class UnresolvedRefError
 191  *  @brief An exception caused by a reference (by UUID) to something which is not known
 192  */
 193 class UnresolvedRefError : public std::runtime_error
 194 {
 195 public:
 196         explicit UnresolvedRefError (std::string id);
 197 };
 198
 199
 200 /** @class TimeFormatError
 201  *  @brief A an error with a string passed to LocalTime
 202  */
 203 class TimeFormatError : public std::runtime_error
 204 {
 205 public:
 206         explicit TimeFormatError (std::string bad_time);
 207 };
 208
 209
 210 /** @class NotEncryptedError
 211  *  @brief An error raised when creating a DecryptedKDM object for assets that are not
 212  *  encrypted
 213  */
 214 class NotEncryptedError : public std::runtime_error
 215 {
 216 public:
 217         explicit NotEncryptedError (std::string const & what);
 218         ~NotEncryptedError () throw () {}
 219 };
 220
 221
 222 /** @class ProgrammingError
 223  *  @brief An exception thrown when a DCP_ASSERT fails; something that should not happen
 224  */
 225 class ProgrammingError : public std::runtime_error
 226 {
 227 public:
 228         ProgrammingError (std::string file, int line);
 229 };
 230
 231
 232 class KDMDecryptionError : public std::runtime_error
 233 {
 234 public:
 235         KDMDecryptionError (std::string message, int cipher_length, int modulus_dmax);
 236 };
 237
 238
 239 class KDMFormatError : public std::runtime_error
 240 {
 241 public:
 242         KDMFormatError (std::string message);
 243 };
 244
 245
 246 class CertificateChainError : public std::runtime_error
 247 {
 248 public:
 249         CertificateChainError (std::string message);
 250 };
 251
 252
 253 class MissingSubtitleImageError : public std::runtime_error
 254 {
 255 public:
 256         MissingSubtitleImageError (std::string id);
 257 };
 258
 259
 260 class BadKDMDateError : public std::runtime_error
 261 {
 262 public:
 263         BadKDMDateError (bool starts_too_early);
 264
 265         bool starts_too_early () const {
 266                 return _starts_too_early;
 267         }
 268
 269 private:
 270         bool _starts_too_early;
 271 };
 272
 273
 274 class StartCompressionError : public std::runtime_error
 275 {
 276 public:
 277         explicit StartCompressionError (boost::optional<int> code = boost::optional<int>());
 278         ~StartCompressionError () throw () {}
 279
 280         boost::optional<int> code () const {
 281                 return _code;
 282         }
 283
 284 private:
 285         boost::optional<int> _code;
 286 };
 287
 288
 289 class CombineError : public std::runtime_error
 290 {
 291 public:
 292         explicit CombineError (std::string message);
 293 };
 294
 295
 296 class LanguageTagError : public std::runtime_error
 297 {
 298 public:
 299         LanguageTagError (std::string message);
 300 };
 301
 302
 303 class BadSettingError : public std::runtime_error
 304 {
 305 public:
 306         BadSettingError (std::string message);
 307 };
 308
 309
 310 class DuplicateIdError : public std::runtime_error
 311 {
 312 public:
 313         DuplicateIdError (std::string message);
 314 };
 315
 316
 317 class MainSoundConfigurationError : public std::runtime_error
 318 {
 319 public:
 320         MainSoundConfigurationError (std::string s);
 321 };
 322
 323
 324 class UnknownChannelIdError : public std::runtime_error
 325 {
 326 public:
 327         UnknownChannelIdError (std::string s);
 328 };
 329
 330
 331 class NoReelsError : public std::runtime_error
 332 {
 333 public:
 334         NoReelsError ();
 335 };
 336
 337
 338 class InconsistentValidityPeriodError : public std::runtime_error
 339 {
 340 public:
 341         InconsistentValidityPeriodError();
 342 };
 343
 344
 345 class BadURNUUIDError : public std::runtime_error
 346 {
 347 public:
 348         BadURNUUIDError(std::string bad_id);
 349 };
 350
 351
 352 }
 353
 354
 355 #endif