class.arFieldList.php

Go to the documentation of this file.

<?php
require_once('class.arField.php');
 
class arFieldList {
 
        const HAS_FIELD = 'has_field';
        const IS_UNIQUE = 'is_unique';
        const IS_PRIMARY = 'is_primary';
        const IS_NOTNULL = 'is_notnull';
        const FIELDTYPE = 'fieldtype';
        const LENGTH = 'length';
        const SEQUENCE = 'sequence';
        const INDEX = 'index';
        protected static $prefixes = array( 'db', 'con' );
        protected static $protected_names = array( 'arConnector', 'arFieldList' );
        protected static $allowed_description_fields = array(
                self::IS_UNIQUE,
                self::IS_PRIMARY,
                self::IS_NOTNULL,
                self::FIELDTYPE,
                self::LENGTH,
                self::SEQUENCE,
                self::INDEX,
        );
        protected static $allowed_connector_fields = array(
                self::IS_NOTNULL,
                self::FIELDTYPE,
                self::LENGTH,
        );
        protected $primary_field;
        protected $primary_fields = array();
        protected $raw_fields = array();
        protected $fields = array();
        protected $ar;
        protected static $key_maps = array(
                self::FIELDTYPE => 'type',
                self::IS_NOTNULL => 'notnull',
        );
 
 
        public function __construct(ActiveRecord $ar) {
                $this->ar = $ar;
        }
 
 
        public static function mapKey($key) {
                if (isset(self::$key_maps[$key])) {
                        return self::$key_maps[$key];
                }
 
                return $key;
        }
 
 
        public static function getAllowedConnectorFields() {
                return self::$allowed_connector_fields;
        }
 
 
        public static function getAllowedDescriptionFields() {
                return self::$allowed_description_fields;
        }
 
 
 
        public static function getInstance(ActiveRecord $ar) {
                $arFieldList = new self($ar);
                $arFieldList->initRawFields($ar);
                $arFieldList->initFields();
 
                return $arFieldList;
        }
 
 
        public static function getInstanceFromStorage($ar) {
                $arFieldList = new self();
                $arFieldList->initRawFields($ar);
                $arFieldList->initFields();
 
                return $arFieldList;
        }
 
 
        public function getArrayForConnector() {
                $return = array();
                foreach ($this->getFields() as $field) {
                        $return[$field->getName()] = $field->getAttributesForConnector();
                }
 
                return $return;
        }
 
 
        protected function initFields() {
                foreach ($this->getRawFields() as $fieldname => $attributes) {
                        if (self::checkAttributes($attributes)) {
                                $arField = new arField();
                                $arField->getHasField(true);
                                $arField->loadFromArray($fieldname, $attributes);
                                $this->fields[] = $arField;
                                if ($arField->getPrimary()) {
                                        $this->setPrimaryField($arField);
                                }
                        }
                }
        }
 
 
        public function getFieldByName($field_name) {
                $field = NULL;
                static $field_map;
                $field_key = $this->ar->getConnectorContainerName() . '.' . $field_name;
                if ($field_map[$field_key]) {
                        return $field_map[$field_key];
                }
                foreach ($this->getFields() as $field) {
                        if ($field->getName() == $field_name) {
                                $field_map[$field_key] = $field;
 
                                return $field;
                        }
                }
        }
 
 
        public function isField($field_name) {
                $is_field = false;
                foreach ($this->getFields() as $field) {
                        if ($field->getName() == $field_name) {
                                $is_field = true;
                        }
                }
 
                return $is_field;
        }
 
 
        public function getPrimaryFieldName() {
                return $this->getPrimaryField()->getName();
        }
 
 
        public function getPrimaryFieldType() {
                return $this->getPrimaryField()->getFieldType();
        }
 
 
        protected function initRawFields(arStorageInterface $ar) {
                $regex = "/[ ]*\\* @(" . implode('|', self::$prefixes) . ")_([a-zA-Z0-9_]*)[ ]*([a-zA-Z0-9_]*)/u";
                $reflectionClass = new ReflectionClass($ar);
                $raw_fields = array();
                foreach ($reflectionClass->getProperties() as $property) {
                        if (in_array($property->getName(), self::$protected_names)) {
                                continue;
                        }
                        $properties_array = array();
                        $has_property = false;
                        foreach (explode("\n", $property->getDocComment()) as $line) {
                                if (preg_match($regex, $line, $matches)) {
                                        $has_property = true;
                                        $properties_array[(string)$matches[2]] = $matches[3];
                                }
                        }
                        if ($has_property) {
                                $raw_fields[$property->getName()] = $properties_array;
                        }
                }
 
                $this->setRawFields($raw_fields);
        }
 
 
        protected static function isAllowedAttribute($attribute_name) {
                return in_array($attribute_name, array_merge(self::$allowed_description_fields, array( self::HAS_FIELD )));
        }
 
 
        protected static function checkAttributes(array $attributes) {
                if ($attributes[self::HAS_FIELD] === 'true') {
                        foreach (array_keys($attributes) as $atr) {
                                if (!self::isAllowedAttribute($atr)) {
                                        return false;
                                }
                        }
                } else {
                        return false;
                }
 
                return true;
        }
 
 
        public function setFields($fields) {
                $this->fields = $fields;
        }
 
 
        public function getFields() {
                return $this->fields;
        }
 
 
        public function setPrimaryField($primary_field) {
                $this->primary_field = $primary_field;
        }
 
 
        public function getPrimaryField() {
                return $this->primary_field;
        }
 
 
        public function setRawFields($raw_fields) {
                $this->raw_fields = $raw_fields;
        }
 
 
        public function getRawFields() {
                return $this->raw_fields;
        }
 
 
        public function setPrimaryFields($primary_fields) {
                $this->primary_fields = $primary_fields;
        }
 
 
        public function getPrimaryFields() {
                return $this->primary_fields;
        }
}
 
?>