class.ilDclCache.php

Go to the documentation of this file.

<?php
 
class ilDclCache
{
    public const TYPE_DATACOLLECTION = 'dcl';
    public const TYPE_TABLE = 'table';
    public const TYPE_FIELD = 'field';
    public const TYPE_RECORD = 'record';
    public const TYPE_TABLEVIEW = 'tableview';
    protected static array $tables_cache = [];
    protected static array $fields_cache = [];
    protected static array $records_cache = [];
    protected static array $record_field_cache = [];
    protected static array $field_representation_cache = [];
    protected static array $record_representation_cache = [];
    protected static array $field_properties_cache = [];
    protected static array $datatype_cache = [];
    protected static array $clone_mapping = [];
 
    public static function setCloneOf(int $old, int $new, string $type): void
    {
        if (!self::$clone_mapping) {
            self::initCloneMapping();
        }
        self::$clone_mapping[$type][$old] = $new;
    }
 
    protected static function initCloneMapping(): void
    {
        self::$clone_mapping = array(
            self::TYPE_DATACOLLECTION => array(),
            self::TYPE_TABLE => array(),
            self::TYPE_FIELD => array(),
            self::TYPE_RECORD => array(),
            self::TYPE_TABLEVIEW => array(),
        );
    }
 
    public static function getCloneOf(int $id, string $type): ?object
    {
        $type_cache = self::$clone_mapping[$type];
        $clone_id = null;
 
        if (!is_array($type_cache)) {
            return null;
        }
 
        if (isset($type_cache[$id])) {
            $clone_id = $type_cache[$id];
        } else {
            foreach ($type_cache as $key => $mapping) {
                if ($mapping == $id) {
                    $clone_id = $key;
                }
            }
        }
 
        if (!$clone_id) {
            return null;
        }
 
        switch ($type) {
            case self::TYPE_DATACOLLECTION:
                return new ilObjDataCollection($clone_id);
            case self::TYPE_FIELD:
                return self::getFieldCache($clone_id);
            case self::TYPE_TABLE:
                return self::getTableCache($clone_id);
            case self::TYPE_RECORD:
                return self::getRecordCache($clone_id);
        }
 
        return null;
    }
 
    public static function getTableCache(int $table_id = null): ilDclTable
    {
        if (is_null($table_id) === true || $table_id === 0) {
            return new ilDclTable();
        }
        $tables_cache = &self::$tables_cache;
        if (!isset($tables_cache[$table_id])) {
            $tables_cache[$table_id] = new ilDclTable($table_id);
        }
 
        return $tables_cache[$table_id];
    }
 
    public static function getFieldCache(int $field_id = 0): ilDclBaseFieldModel
    {
        $fields_cache = &self::$fields_cache;
        if (!isset($fields_cache[$field_id])) {
            $fields_cache[$field_id] = ilDclFieldFactory::getFieldModelInstance($field_id);
        }
 
        return $fields_cache[$field_id];
    }
 
    public static function getRecordCache(?int $record_id): ilDclBaseRecordModel
    {
        $records_cache = &self::$records_cache;
        if (!$record_id || !isset($records_cache[$record_id])) {
            $records_cache[$record_id] = ilDclFieldFactory::getRecordModelInstance($record_id);
        }
 
        return $records_cache[$record_id];
    }
 
    public static function getRecordFieldCache(
        object $record, //object|ilDclBaseRecordModel
        object $field //object|ilDclBaseFieldModel
    ): ilDclBaseRecordFieldModel {
        $fid = $field->getId();
        $rid = $record->getId();
        if (!isset(self::$record_field_cache[$rid])) {
            self::$record_field_cache[$rid] = [];
            self::$record_field_cache[$rid][$fid] = ilDclFieldFactory::getRecordFieldInstance($field, $record);
        } elseif (!isset(self::$record_field_cache[$rid][$fid])) {
            self::$record_field_cache[$rid][$fid] = ilDclFieldFactory::getRecordFieldInstance($field, $record);
        }
 
        return self::$record_field_cache[$rid][$fid];
    }
 
    public static function getFieldRepresentation(ilDclBaseFieldModel $field): ilDclBaseFieldRepresentation
    {
        if (!isset(self::$field_representation_cache[$field->getId()])) {
            self::$field_representation_cache[$field->getId()] = ilDclFieldFactory::getFieldRepresentationInstance($field);
        }
 
        return self::$field_representation_cache[$field->getId()];
    }
 
    public static function getRecordRepresentation(
        ilDclBaseRecordFieldModel $record_field
    ): ilDclBaseRecordRepresentation {
        if ($record_field == null) {
            throw new ilDclException("Cannot get Representation of null object!");
        }
 
        if (!isset(self::$record_representation_cache[$record_field->getId()])) {
            self::$record_representation_cache[$record_field->getId()] = ilDclFieldFactory::getRecordRepresentationInstance($record_field);
        }
 
        return self::$record_representation_cache[$record_field->getId()];
    }
 
    public static function getFieldProperties($field_id): array
    {
        if (!isset(self::$field_properties_cache[$field_id])) {
            self::$field_properties_cache[$field_id] = array();
            $result = ilDclFieldProperty::where(array('field_id' => $field_id))->get();
            foreach ($result as $prop) {
                self::$field_properties_cache[$field_id][$prop->getName()] = $prop;
            }
        }
 
        return self::$field_properties_cache[$field_id];
    }
 
    public static function preloadFieldProperties(array $fields): void
    {
        foreach ($fields as $field_key => $field) {
            if (isset(self::$field_properties_cache[$field->getId()])) {
                unset($fields[$field_key]);
            }
        }
 
        if (count($fields) > 0) {
            $field_ids = array();
            foreach ($fields as $field) {
                $field_ids[] = $field->getId();
            }
            $result = ilDclFieldProperty::where(array('field_id' => $field_ids), 'IN')->get();
            foreach ($result as $prop) {
                if (!isset(self::$field_properties_cache[$prop->getFieldId()])) {
                    self::$field_properties_cache[$prop->getFieldId()] = array();
                }
                self::$field_properties_cache[$prop->getFieldId()][$prop->getName()] = $prop;
            }
        }
    }
 
    public static function getDatatype(int $datatyp_id): ilDclDatatype
    {
        if (self::$datatype_cache == null) {
            self::$datatype_cache = ilDclDatatype::getAllDatatype();
        }
 
        if (!isset(self::$datatype_cache[$datatyp_id])) {
            return new ilDclDatatype();
        }
 
        return self::$datatype_cache[$datatyp_id];
    }
 
    public static function buildFieldFromRecord(array $rec): ilDclBaseFieldModel
    {
        $fields_cache = &self::$fields_cache;
        if (isset($fields_cache[$rec["id"]])) {
            return $fields_cache[$rec["id"]];
        }
        $field = ilDclFieldFactory::getFieldModelInstanceByClass(new ilDclBaseFieldModel($rec['id']));
        $field->setId($rec["id"]);
        $field->setTableId($rec["table_id"]);
        if (null !== $rec["title"]) {
            $field->setTitle($rec["title"]);
        }
        if (null !== $rec["description"]) {
            $field->setDescription($rec["description"]);
        }
        $field->setDatatypeId($rec["datatype_id"]);
        $field->setUnique($rec["is_unique"]);
        $fields_cache[$rec["id"]] = $field;
 
        return $field;
    }
 
    public static function resetCache(): void
    {
        self::$fields_cache = array();
        self::$record_field_cache = array();
        self::$records_cache = array();
    }
}