Trying to reuse code, but can't extend two classes, alternative?

Question

I know I cannot extend from two classes, but what is the alternative for my case?

I am using a base class, parser, that parser the page of my CMS. This class contains all the basic functions needed to filter the data retrieved from the database and rendering it into a HTML page.

All the other classes NEED the parser, because without it they don't work.

I have 2 modes:

1. Inside the CMS
2. Outside the CMS

Inside CMS

If inside the CMS, userdata and other additional data is loaded into the class.

Outside CMS

If outside the CMS, only the necessary data to render the page is loaded, this is the default way for displaying pages to people who visit the site.

---

Modules

A page can be used to display default data/elements, but it can also be used to display data from a module (e.g. a calender page). If this is the case, additional data needs to be loaded into the parser object, and thus I have 4 different use cases:

1. parser mode
2. cmsParser mode (inside CMS)
3. moduleParser mode (parser with module data loaded)
4. cmsModuleParser mode (both)

I have the following [extremely simplified] classes:

class parser {
   protected $oDataSource1;
   protected $oDataSource2;
   protected $oDataSource3;

   //... 
   public function filterData() {
       //.. Search through the data sources and return filtered data
   }
}

class cmsParser extends parser {
   protected $sUser_name;
   protected $iUser_id;
   protected $sUserLanguage;

   ///.. some functions here that are called only within the CMS
}

class moduleParser extends parser {
    protected $mModuleData;
    //.. Do something with this moduleData;
}

class cmsModuleParser extends ?? {
    //... Get functions from the cmsParser + module functions
}

The only solution I can come up with is using a trait that the moduleParser and the cmsModuleParser both use? This is not optimal IMO, because I still have to add duplicate variables etc.

I don't want duplicate code, of course, so how do I solve this puzzle?

Answer 1

Have you heard the phrase favor composition over inheritance? Sometimes, Composition would pay more than Inheritance. In this case, the cmsModuleParser extends cmsParser and then injects the moduleParser via the constructor as a Dependency. However, you also have a getter and a setter for the $moduleParser Property. So if you don't need it to be injected via the Constructor, you may still remove it from the constructor and use the setModuleParser() Accessor Method instead. Alternatively, you may also Program To Interface. Below is a code that would illustrate both concepts:

COMPOSITION

    <?php
        class parser {
            protected $mData;

            //...
            public function filterData() {
                //.. filter the data here and return it
            }
        }

        class cmsParser extends parser {
            protected $sUser_name;
            protected $iUser_id;
            protected $sUserLanguage;

            ///.. some functions here that are called only within the CMS
        }

        class moduleParser extends parser {
            protected $mModuleData;
            //.. Do something with this moduleData;
        }

        // HERE YOU EXTEND THE cmsParser 
        // AND THEN USING DI, INCLUDE THE moduleParser
        class cmsModuleParser extends cmsParser {
            /**
             * @var ModuleParser
             */
            protected $moduleParser;
            //... Get functions from the cmsParser + module functions

            public function __construct(moduleParser $moduleParser) {
            }

            /**
             * @return moduleParser
             */
            public function getModuleParser() {
                return $this->moduleParser;
            }

            /**
             * @param moduleParser $moduleParser
             * @return cmsModuleParser
             */
            public function setModuleParser($moduleParser) {
                $this->moduleParser = $moduleParser;

                return $this;
            }

        }

PROGRAMMING TO INTERFACE

    <?php
        interface iParser{
            public function filterData();
            public function renderView();
            public function saveData();

        }

        class parser implements iParser{
            protected $mData;

            //...
            public function filterData() {
                //.. filter the data here and return it
            }

            public function renderView(){}
            public function saveData(){}
        }

        class cmsParser extends parser {
            protected $sUser_name;
            protected $iUser_id;
            protected $sUserLanguage;

            ///.. some functions here that are called only within the CMS
        }

        class moduleParser extends parser {
            protected $mModuleData;
            //.. Do something with this moduleData;
        }


        class cmsModuleParser implements iParser {
            //... Get functions from the cmsParser + module functions

            public function __construct() {
            }

            public function filterData(){}
            public function renderView(){}
            public function saveData(){}

        }

Answer 2

First of all you have to Know the fact that all classes extends a single class considered as a bad design and indicated that you have bad understanding about OO concepts.

Inheritence is somethig like A is a B. That is, all your classes IS A cmsParser. This of course is wrong and will cause problems like these you are reffering to. There are many examples where inheritence is usefull like

• Woman is a human
• Toyota is a Car
• PageController is a Controller (more common scenario at MVC applications)

But inheritance like

• Car is an Engine
• Womans is a Leg
• cmsModuleParser is Parser

is not a good design and the issue is obvious.

So how you adress your problem? Lets stick to Car case. First define the Car class

class Car extends Engine{

    public function reverse(){
    $this->startEngine();//Parent's method.
    .....
    }

instead of the above you can do something like this

class Car{
protected $Engine;
protected $Driver;

public function __construct($Engine, $Driver){
$this->Engine = $Engine;
$this->Driver = $Driver;
}

public function reverse(){
$this->Engine->start();
$this->Driver->LookBehindYou();
...
}

} 

With that way using contstructor injection you have loose coupling between your depedencies and you have a better design.

Search at google about Depedency Injection and Composition over inheritance consepts.