Source for file exceptions.php

Documentation is available at exceptions.php

1. 1: <?php
2. 2:  
3. 3: /**
4. 4:  * Nette Framework
5. 5:  *
6. 6:  * Copyright (c) 2004, 2009 David Grudl (http://davidgrudl.com)
7. 7:  *
8. 8:  * This source file is subject to the "Nette license" that is bundled
9. 9:  * with this package in the file license.txt.
10. 10:  *
11. 11:  * For more information please see https://nette.org
12. 12:  *
13. 13:  * @copyright  Copyright (c) 2004, 2009 David Grudl
14. 14:  * @license    https://nette.org/license  Nette license
15. 15:  * @link       https://nette.org
16. 16:  * @category   Nette
17. 17:  * @package    Nette
18. 18:  * @version    $Id$
19. 19:  */
20. 20:  
21. 21: // no namespace
22. 22:  
23. 23:  
24. 24:  
25. 25: /*
26. 26: some useful SPL exception:
27. 27:  
28. 28: - LogicException
29. 29:     - InvalidArgumentException
30. 30:     - LengthException
31. 31: - RuntimeException
32. 32:     - OutOfBoundsException
33. 33:     - UnexpectedValueException
34. 34:  
35. 35: other SPL exceptions are ambiguous; do not use them
36. 36:  
37. 37: ErrorException is corrupted in PHP < 5.3
38. 38: */
39. 39:  
40. 40:  
41. 41:  
42. 42: /**
43. 43:  * The exception that is thrown when the value of an argument is
44. 44:  * outside the allowable range of values as defined by the invoked method.
45. 45:  * @package    Nette
46. 46:  */
47. 47: class ArgumentOutOfRangeException extends InvalidArgumentException
48. 48: {
49. 49: }
50. 50:  
51. 51:  
52. 52:  
53. 53: /**
54. 54:  * The exception that is thrown when a method call is invalid for the object's
55. 55:  * current state, method has been invoked at an illegal or inappropriate time.
56. 56:  * @package    Nette
57. 57:  */
58. 58: class InvalidStateException extends RuntimeException
59. 59: {
60. 60:     
61. 61:     function __construct($message = '', $code = 0, Exception $previous = NULL)
62. 62:     {
63. 63:         if (version_compare(PHP_VERSION , '5.3', '<')) {
64. 64:             $this->previous = $previous;
65. 65:             parent::__construct($message, $code);
66. 66:         } else {
67. 67:             parent::__construct($message, $code, $previous);
68. 68:         }
69. 69:     }
70. 70:     
71. 71: }
72. 72:  
73. 73:  
74. 74:  
75. 75: /**
76. 76:  * The exception that is thrown when a requested method or operation is not implemented.
77. 77:  * @package    Nette
78. 78:  */
79. 79: class NotImplementedException extends LogicException
80. 80: {
81. 81: }
82. 82:  
83. 83:  
84. 84:  
85. 85: /**
86. 86:  * The exception that is thrown when an invoked method is not supported. For scenarios where
87. 87:  * it is sometimes possible to perform the requested operation, see InvalidStateException.
88. 88:  * @package    Nette
89. 89:  */
90. 90: class NotSupportedException extends LogicException
91. 91: {
92. 92: }
93. 93:  
94. 94:  
95. 95:  
96. 96: /**
97. 97:  * The exception that is thrown when a requested method or operation is deprecated.
98. 98:  * @package    Nette
99. 99:  */
100. 100: class DeprecatedException extends NotSupportedException
101. 101: {
102. 102: }
103. 103:  
104. 104:  
105. 105:  
106. 106: /**
107. 107:  * The exception that is thrown when accessing a class member (property or method) fails.
108. 108:  * @package    Nette
109. 109:  */
110. 110: class MemberAccessException extends LogicException
111. 111: {
112. 112: }
113. 113:  
114. 114:  
115. 115:  
116. 116: /**
117. 117:  * The exception that is thrown when an I/O error occurs.
118. 118:  * @package    Nette
119. 119:  */
120. 120: class IOException extends RuntimeException
121. 121: {
122. 122: }
123. 123:  
124. 124:  
125. 125:  
126. 126: /**
127. 127:  * The exception that is thrown when accessing a file that does not exist on disk.
128. 128:  * @package    Nette
129. 129:  */
130. 130: class FileNotFoundException extends IOException
131. 131: {
132. 132: }
133. 133:  
134. 134:  
135. 135:  
136. 136: /**
137. 137:  * The exception that is thrown when part of a file or directory cannot be found.
138. 138:  * @package    Nette
139. 139:  */
140. 140: class DirectoryNotFoundException extends IOException
141. 141: {
142. 142: }
143. 143:  
144. 144:  
145. 145:  
146. 146: /**
147. 147:  * The exception that indicates errors that can not be recovered from. Execution of
148. 148:  * the script should be halted.
149. 149:  * @package    Nette
150. 150:  */
151. 151: class FatalErrorException extends Exception
152. 152: {
153. 153:     /** @var int */
154. 154:     private $severity;
155. 155:     
156. 156:  
157. 157:     public function __construct($message, $code, $severity, $file, $line, $context)
158. 158:     {
159. 159:         
160. 160:         parent::__construct($message, $code);
161. 161:         $this->severity = $severity;
162. 162:         $this->file = $file;
163. 163:         $this->line = $line;
164. 164:         $this->context = $context;
165. 165:     }
166. 166:  
167. 167:  
168. 168:     
169. 169:     public function getSeverity()
170. 170:     {
171. 171:         return $this->severity;
172. 172:     }
173. 173:     
174. 174:  
175. 175: }