AOOSException.php: Proper check of file and line

[AOOS.git] / AOOSCore.php

<?php

/**
 * AOOSCore
 *
 * The core class of AOOS
 *
 * @author Sebastian Skejø
 */

class AOOSCore
{
    private $_exceptions    = array();
    private $_modules       = null;
    private $_settings      = array();
    private $_transStrings  = array();
    private $_log           = array();

    /**
     * Default constructor. An AOOSException is thrown if the language defined in $settings["lang"] isn't found the the 
     * array keys of the translated strings defined in lang.php.
     */
    public function __construct()
    {
        // Settings
        require("settings.php");
        $this->_settings = $settings; /* Set in settings.php */
        $l = $this->getSetting("lang");

        // Translated strings
        require("lang.php");
        if (!in_array($l, array_keys($lang))) /* $lang set in lang.php */
        {
            throw new AOOSException($this, "Language not found in lang.php. You will not be able to translate strings");
        }
        else
        {
            $this->_transStrings = $lang[$l];
        }

        $m = new AOOSModel($this);
        $m->setColumnIndex(array(
            "ID",
            "NAME",
            "DEPS",
            "INSTANCE"
        ));
        $m->setProperty("ID",
            AOOSMODEL_TYPE_INTEGER,
            AOOSMODEL_PROP_FROM_DATABASE|
            AOOSMODEL_PROP_UNIQUE|
            AOOSMODEL_PROP_DATA_INCREASING);
        $m->setProperty("NAME",
            AOOSMODEL_TYPE_STRING,
            AOOSMODEL_PROP_FROM_DATABASE);
        $m->setProperty("DEPS",
            AOOSMODEL_TYPE_STRING,
            AOOSMODEL_PROP_FROM_DATABASE);
        $m->setProperty("INSTANCE",
            AOOSMODEL_TYPE_UNKNOWN,0);
        $m->setTable($this->getSetting("module_table"));
        $m->setSource($this->getSetting("default_storage_type"));
        $m->populate();
//        $m->populate();
        $this->_modules = $m;

        $this->log("Created AOOSCore");
    }

   /**
    * Logs the string with a timestamp
    * @param $str The string to log
    */
    public function log($str)
    {
        $this->_log[] = array(
            "STRING" => $str,
            "TIMESTAMP" => microtime()
        );
    }

    /**
     * Returns a string containing the log
     */
    public function log2str() {
        $str = "";
        foreach ($this->_log as $num => $entry) {
            $str .= "<strong>".$num.":</strong> ".$entry["STRING"]." at ".$entry["TIMESTAMP"]."<br />";
        }
        return $str;
    }

    /**
     * Sets an exception
     * @param $e The exception
     */
    public function setException($e)
    {
        $this->_exceptions[$e->getName()] = $e;
        if ($e->getEcode() == 0)
        {
            exit($e);
        }

        return true;
    }

    /**
     * Prints all exceptions
     */
    public function printExceptions()
    {
        $str = "<div class=\"Exceptions\">";
        foreach ($this->_exceptions as $e)
        {
            $str .= $e;
        }
        $str .= "</div>";
        print $str;
    }

    /**
     * Returns the value of the the given setting. Throws an AOOSException if the setting key isn't found.
     * @param $name Name of the setting
     * @param $module This is used to fetch per-module settings. If null is given a global setting is fetched.
     * @return string
     */
    public function getSetting($name, $module = null)
    {
        $a = $this->_settings;
        if ($module != null && $this->getModule($module))
        {
            $a = $a[$module];
        }
        if (!in_array($name, array_keys($a)))
        {
            throw new AOOSException($this, "Settingkey not found", "Key: ".$name, true, 2);
            return false;
        }
        return $a[$name];
    }

    /**
     * Used by AOOSModule to get translated string. SHOULD NOT BE ACCESSED MANUALLY! In order to translate a string use 
     * the AOOSModule::tr() function. Throws an AOOSException if the string isn't found.
     * @param $string The string to translate
     * @param $module This is used to fetch translated strings per-module. If a module name is given the translated 
     * string will be fetched from this module. If null is given, the string will be fetched from /lang.php
     * @return string
     */
    public function getTranslatedString($string, $module = null)
    {
        $a = $this->_transStrings;
        if ($module !== null && $this->getModule($module)) {
            $a = $a[$module];
        }
        if (!in_array($string, array_keys($a))) {
            throw new AOOSLangException($this, $string);
            return $string;
        }
        return $a[$string];
    }

    public function tr($string) {
        return $this->getTranslatedString($string);
    }

    /**
     * Loads $module. If the module couldn't be loaded an AOOSException is thrown. If the module is already loaded it is 
     * reloaded. If the module is successfully loaded the newly created instance is returned.
     * @param $module Name of the module
     * @return AOOSModule
     * @sa getModule
     */
    public function loadModule($module) {
//        $this->_modules->populate();
        $m = $this->modules();
        if (false === ($row = $m->find(array("NAME" => $module)))) {
            throw new AOOSException($this, $this->getTranslatedString("unknown_module"), $module);
            return false;
        }
        $deps = AOOSModel::stripQuotes($row["DEPS"]);
        if ($deps != "") {
            foreach (explode(",",$deps) as $dep) {
                if (!$this->getModule($dep)) {
                    try {
                        $this->loadModule($dep);
                    }
                    catch (AOOSException $e) {
                        throw new AOOSException($this, $this->getTranslatedString("module_unloadable"));
                        return false;
                    }
                }
            }
        }

        $dir = $this->getSetting("module_dir").$module."/";
        $path = $dir.$module.$this->getSetting("extension");
        require_once($path);
        $i = new $module($this);
        if (($dm = $i->dataModelDefinition()) !== 0) {
            $i->setDataModel($dm);
            $i->dataModel()->setSource($this->getSetting("default_storage_type"));
            $i->dataModel()->setTable($module);
        }
        $m->setDataRowSingle($row, "INSTANCE", $i);
        $i->setName($module);

        $sf = $dir."settings".$this->getSetting("extension");
        if (file_exists($sf)) {
            require($sf);
            $this->_settings[$module] = $settings;
        }
 
        $lf = $dir."lang".$this->getSetting("extension");
        if (file_exists($lf)) {
            require($lf);
            $this->_transStrings[$module] = $lang;
        }

        $i->postInitialization();
        return $i;
    }

    /**
     * Returns the instance of the given $module. If this isn't instantiated yet, getModule will try to load it.
     * an AOOSException if loadModule fails.
     * @param $module Name of the module
     * @return AOOSModule|false
     * @sa loadModule
     */
    public function getModule($module) {
        $row = $this->modules()->find(array("NAME" => $module));
        if ($row === false) {
            return false;
        }
        return $row->INSTANCE ? $row->INSTANCE : $this->loadModule($module);
    }

    /**
     * Returns the AOOSModel containing all module names, dependencies and instances.
     * @return AOOSModel
     */
    public function modules()
    {
        return $this->_modules;
    }

    /**
     * Simply returs a string containing "AOOSCore".
     * \internal This could be better
     */
    public function __toString()
    {
        return "AOOSCore";
    }

    /**
     * Connects the signal $signal of $sender to the slot $slot of $reciever
     * @param $sender The sender
     * @param $signal The signal name
     * @param $reciever The reciever
     * @param $slot The slot
     */

}
// vim: number
?>