lepton_abstract_frontend.php

Go to the documentation of this file.

<?php
 
declare(strict_types=1);
 
abstract class LEPTON_abstract_frontend
{
 
    const NOT_SET_IN_INFO = "(unknown - not set in info.php)";
 
    public array $language = [];
 
    public array $parents = [];
 
    public string $module_description = "";
 
    public static $instance;
 
 
    public static function getInstance(mixed $value = null): object
    {
        if (null === static::$instance)
        {
            static::$instance = new static();
            static::$instance->getParents();
            static::$instance->getLanguageFile();
            static::$instance->initialize($value);
        }
        return static::$instance;
    }
 
    public static function getConstants(): array
    {
        // "static::class" here does the magic
        $reflectionClass = new ReflectionClass(static::class);
        return $reflectionClass->getConstants();
    }
 
    protected function getMainClassNames(string $anyClassname): array
    {
        $aElements = explode("_", $anyClassname);
 
        $sTempName = array_shift($aElements);
 
        $aReturnValue = [$sTempName];
 
        foreach ($aElements as $term)
        {
            $sTempName .= "_" . $term;
            $aReturnValue[] = $sTempName;
        }
 
        if (count($aReturnValue) > 1)
        {
            $aReturnValue = array_reverse($aReturnValue);
        }
 
        return $aReturnValue;
    }
 
    
    protected function getLanguageFile(): void
    {
        if(defined("LEPTON_PATH"))
        {
            $aLookUpFilenames = [
                LANGUAGE."_add.php",            
                LANGUAGE."_custom.php",
                LANGUAGE.".php",
                "EN_custom.php",
                "EN.php"
            ];
 
            foreach( static::$instance->parents as $sClassNameTop)
            {
                //  strip namespace
                $aTemp = explode("\\", $sClassNameTop);
                $bExitGraceful = false;
                foreach( $aTemp as $sClassName )
                {          
                    $aMainClassNames = $this->getMainClassNames( $sClassName );
 
                    foreach($aMainClassNames as $sTempModuleDirectory)
                    {
                        $lookUpPath = LEPTON_PATH."/modules/".$sTempModuleDirectory."/languages/";
 
                        $bFoundFile = false;
 
                        foreach($aLookUpFilenames as $sTempFilename)
                        {
                            if(true === file_exists( $lookUpPath.$sTempFilename ) )
                            {
                                require $lookUpPath.$sTempFilename;
                                $bFoundFile = true;
                                break;
                            }
                        }
 
                        if(false === $bFoundFile)
                        {
                            continue;
                        }
 
                        $tempName = "MOD_".strtoupper($sTempModuleDirectory);
                        if(isset(${$tempName}))
                        {
                            static::$instance->language = ${$tempName};
                            $bExitGraceful = true;
                            break;
                        }
                    }
                    
                    if(true === $bExitGraceful)
                    {
                        break;
                    }
                }
            }
        }
    }
 
 
    protected function getParents(): void
    {
        // First the class itself
        static::$instance->parents[] = get_class(static::$instance);
 
        // Now the parents
        $aTempParents = class_parents(static::$instance, true);
        foreach($aTempParents as $sParentName)
        {
            static::$instance->parents[] = $sParentName;
        }
    }
 
    abstract protected function initialize();
 
}