use Special class if available, base class if not

Question

I am useing a class in my code from the base framework. But it might not be available yet:

use BaseFramework\Libs\SpecialException;

So this use-Statement will result in an error. I.e. for frameworks, where this SpecialException is not available I would like to do:

use Exception as SpecialException;

so that I do not need to change my code.

I learned that the use is only creating an alias to the full named class.

I would like to use the originial SpecialException, if this is not possible I would like to use Exception. I am wondering, what is the best practice or recommended way in PHP to solve this?

Answer 1

You can decide which one to throw using class_exists, it's going to be pretty nasty to actually use though.

Example:

try {
   // do something
} catch (\Exception $e) {
    // you'd still need to catch a common exception to all your custom types
    if (class_exists('SomeCustomException')) {
        throw new SomeCustomException; // or whatever
    }
}

But you'd need to do that or something equally awful everywhere.

Your question suggests the actual answer here is to implement your own custom exception and throw that instead, as you have full control over it then.

Sometimes frameworks get around this kind of issue by having shared interoperability packages, so they can conform to common interfaces, throw the same exceptions and so on.

Answer 2

Since SpecialException might contains methods, variables and stuff that Exception doesn't contain, there is no rock-solid way to achieve what you need. Just replacing a class with a more generic one, might lead to trouble once you use some of the more dedicated methods.

You can see this post for working with class-aliases to achieve your desired behaviour, but for the reason meantioned above I wouldn't recommend it: Why use class alisases?

You rather should use the factory-Pattern, just import the super-type of your eventually-custom-class and work with that super-type.

As soon, as you need to call a method on an instance, where you are not sure if that method is present (due to up-casting) - your class definition (or at least the method required) is placed into the wrong level inside the inheritance tree.

Answer 3

Why not just extend Exception? Something like this ...

namespace ProjectName\Exceptions\SpecialException;

class SpecialException extends Exception
{
    // Implement custom properties and methods if required. Optional.
}

Here we have a custom class that uses SpecialException:

use \ProjectName\Exceptions\SpecialException;

class DocumentRepository
{
    public static function fetchByID($docID)
    {
        throw new SpecialException("Document does not exist");
    }
}

And now you don't need to worry about whether or not SpecialException exists or not. If calling code throws a regular Exception it will get caught, but if it throws a SpecialException it will still get caught as the new exceptions base class is Exception.

try
{
    $doc = DocumentRepository::fetchByID(12);
}
catch(Exception $e)
{
    die($e->getMessage());
}

Or, if you want to catch the SpecialException you can do (and I highly recommend this):

try
{
    $doc = DocumentRepository::fetchByID(12);
}
catch(SpecialException $e)
{
    die($e->getMessage());
}

Update to answer the problem in your comment

As a developer using a framework you have a location where you store your custom classes, files etc. right? Let me assume that this location is ProjectName/lib. And lets assume the framework you're using lives in the directory ProjectName/BaseFramework.

Your custom SpecialException will live in ProjectName/lib/Exceptions/SpecialException.php.

Currently, the framework doesn't include this exception. So in the files you wish to use SpecialException you use the following use line:

use \ProjectName\Exceptions\SpecialException

When the framework finally does implement this SpecialException you simply replace that use line with this one:

use \BaseProject\Exceptions\SpecialException

It's as simple as that.

If you try to do this in the way other users have suggested you will have dead code in your system. When SpecialException is finally implemented the checks on which type of Exception to use will be redundant.

This assumes you're using something like composer or something else that handles autoloading.

Answer 4

OK, thanks to some clues by @dognose and @bcmcfc this works for me:

 use BaseFramework\Libs\SpecialException;
 if (!class_exists("SpecialException")) {
     class_alias("Exception", "SpecialException");
 }