|  | @@ 226-245 (lines=20) @@ | 
                                                            
                                    | 223 |  |      * | 
                                                            
                                    | 224 |  |      * @param string $endMultiLine the regexp that will match the ending block directives | 
                                                            
                                    | 225 |  |      */ | 
                                                            
                                    | 226 |  |     public function setEndMultiLine($endMultiLine) | 
                                                            
                                    | 227 |  |     { | 
                                                            
                                    | 228 |  |         if (!$this->checker->setString($endMultiLine)->getString()) { | 
                                                            
                                    | 229 |  |             throw ServerException::forInvalidMatcher( | 
                                                            
                                    | 230 |  |                 $endMultiLine, | 
                                                            
                                    | 231 |  |                 'The ending block directive matcher is expected to be a string. Got: %s' | 
                                                            
                                    | 232 |  |             ); | 
                                                            
                                    | 233 |  |         } | 
                                                            
                                    | 234 |  |  | 
                                                            
                                    | 235 |  |         if (!$this->checker->isValidRegex()) { | 
                                                            
                                    | 236 |  |             throw ServerException::forInvalidMatcher( | 
                                                            
                                    | 237 |  |                 $endMultiLine, | 
                                                            
                                    | 238 |  |                 'The ending block directive matcher is expected to be a regexp.' | 
                                                            
                                    | 239 |  |             ); | 
                                                            
                                    | 240 |  |         } | 
                                                            
                                    | 241 |  |  | 
                                                            
                                    | 242 |  |         $this->endMultiLine = $endMultiLine; | 
                                                            
                                    | 243 |  |  | 
                                                            
                                    | 244 |  |         return $this; | 
                                                            
                                    | 245 |  |     } | 
                                                            
                                    | 246 |  |  | 
                                                            
                                    | 247 |  |     /** | 
                                                            
                                    | 248 |  |      * Gets the regexp that will match the simple directives. | 
                                                                                
                                |  | @@ 291-310 (lines=20) @@ | 
                                                            
                                    | 288 |  |      * | 
                                                            
                                    | 289 |  |      * @param string $inclusionDirective the regexp that will match the inclusion directives | 
                                                            
                                    | 290 |  |      */ | 
                                                            
                                    | 291 |  |     public function setInclusionDirective($inclusionDirective) | 
                                                            
                                    | 292 |  |     { | 
                                                            
                                    | 293 |  |         if (!$this->checker->setString($inclusionDirective)->getString()) { | 
                                                            
                                    | 294 |  |             throw ServerException::forInvalidMatcher( | 
                                                            
                                    | 295 |  |                 $inclusionDirective, | 
                                                            
                                    | 296 |  |                 'The inclusion directive matcher is expected to be a string. Got: %s' | 
                                                            
                                    | 297 |  |             ); | 
                                                            
                                    | 298 |  |         } | 
                                                            
                                    | 299 |  |  | 
                                                            
                                    | 300 |  |         if (!$this->checker->isValidRegex()) { | 
                                                            
                                    | 301 |  |             throw ServerException::forInvalidMatcher( | 
                                                            
                                    | 302 |  |                 $inclusionDirective, | 
                                                            
                                    | 303 |  |                 'The inclusion directive matcher is expected to be a regexp.' | 
                                                            
                                    | 304 |  |             ); | 
                                                            
                                    | 305 |  |         } | 
                                                            
                                    | 306 |  |  | 
                                                            
                                    | 307 |  |         $this->inclusionDirective = $inclusionDirective; | 
                                                            
                                    | 308 |  |  | 
                                                            
                                    | 309 |  |         return $this; | 
                                                            
                                    | 310 |  |     } | 
                                                            
                                    | 311 |  |  | 
                                                            
                                    | 312 |  |     /** | 
                                                            
                                    | 313 |  |      * Confirms if a directive matcher is a valid regex. |