Get array with mapping which property depends on other property
@return array
761305
public function GetDependsObjects()
    {
        return array(
            'PaymentType' => array(
                '_property_name' => 'PaymentDetails',
                PayInPaymentType::Card => '\MangoPay\PayInPaymentDetailsCard',
                PayInPaymentType::Preauthorized => '\MangoPay\PayInPaymentDetailsPreAuthorized',
                PayInPaymentType::BankWire => '\MangoPay\PayInPaymentDetailsBankWire',
                PayInPaymentType::DirectDebit => '\MangoPay\PayInPaymentDetailsDirectDebit',
                PayInPaymentType::DirectDebitDirect => '\MangoPay\PayInPaymentDetailsDirectDebitDirect',
                PayInPaymentType::PayPal => '\MangoPay\PayInPaymentDetailsPaypal',
                // ...and more in future...
            ),
            'ExecutionType' => array(
                '_property_name' => 'ExecutionDetails',
                PayInExecutionType::Web => '\MangoPay\PayInExecutionDetailsWeb',
                PayInExecutionType::Direct => '\MangoPay\PayInExecutionDetailsDirect',
                PayInExecutionType::ExternalInstruction => '\MangoPay\PayInExecutionDetailsExternalInstruction',                
                // ...and more in future...
            )
        );
    }
487092
public function mapRelatives()
    {
        $relations = collect($this->relations());

        if ($relations->isEmpty()) {
            return false;
        }

        return $this->items = collect($this->all())
            ->map(function ($value, $key) use ($relations) {
                if ($relations->has($key)) {
                    $className = $relations->get($key);

                    return new $className($value);
                }

                return $value;
            })
            ->all();
    }
789457
public function properties()
    {
        if ($this->properties === null) {
            $model = $this->proto();
            $props = $model->metadata()->properties();

            $collectionIdent = $this->collectionIdent();
            if ($collectionIdent) {
                $metadata      = $model->metadata();
                $adminMetadata = isset($metadata['admin']) ? $metadata['admin'] : null;

                if (isset($adminMetadata['lists'][$collectionIdent]['properties'])) {
                    // Flipping to have property ident as key
                    $listProperties = array_flip($adminMetadata['lists'][$collectionIdent]['properties']);
                    // Replacing values of listProperties from index to actual property values
                    $props = array_replace($listProperties, $props);
                    // Get only the keys that are in listProperties from props
                    $props = array_intersect_key($props, $listProperties);
                }
            }

            $this->properties = $props;
        }

        return $this->properties;
    }
1192057
public function getRelatedProperties()
    {
        //return $this->treeType->getCmsTreeTypeProperties();
        if (isset(self::$_treeTypes[$this->tree_type_id])) {
            $treeType = self::$_treeTypes[$this->tree_type_id];
        } else {
            self::$_treeTypes[$this->tree_type_id] = $this->treeType;
            $treeType = self::$_treeTypes[$this->tree_type_id];
        }
        if (!$treeType) {
            return CmsTreeTypeProperty::find()->where(['id' => null]);
        }
        //return $this->treeType->getCmsTreeTypeProperties();
        return $treeType->getCmsTreeTypeProperties();
    }
9556
public function values()
    {
        $name = $this->config('field');
        $paramName = $this->config('name');
        $param = $this->_dependentParameters[$paramName];

        return [
            $name => $this->value(),
            $paramName => $param->value()
        ];
    }
206621
public function getColumnObjectsMapping()
    {
        $mapping = array();
        $localTable = $this->getTable();
        $foreignTable = $this->getForeignTable();
        for ($i = 0, $size = count($this->localColumns); $i < $size; $i++) {
            $mapping[]= array(
                'local'   => $localTable->getColumn($this->localColumns[$i]),
                'foreign' => $foreignTable->getColumn($this->foreignColumns[$i]),
            );
        }

        return $mapping;
    }
44859
public function getComputedProperties()
    {
        $result = array();

        if($row = $this->getIterator()->current()) {
            $result = $row->getComputedProperties();
        }

        return $result;
    }
25816
public function getHasManyRowDifferences()
    {
        $differences = [];
        foreach ($this->getCurrentReflection()->getEntityProperties() as $property) {
            if ($property->hasRelationship() and ($property->getRelationship() instanceof Relationship\HasMany)) {
                $relationship = $property->getRelationship();
                $difference = $this->row->createReferencingDataDifference(
                    $relationship->getRelationshipTable(),
                    $relationship->getColumnReferencingSourceTable(),
                    null,
                    $relationship->getStrategy()
                );
                if ($difference->mayHaveAny()) {
                    $differences[$relationship->getColumnReferencingSourceTable() . ':' . $relationship->getRelationshipTable(
                    ) . ':' . $relationship->getColumnReferencingTargetTable()] = $difference->getByPivot(
                        $relationship->getColumnReferencingTargetTable()
                    );
                }
            }
        }
        return $differences;
    }
1246113
public function getRelatedProperties()
    {

        //return $this->treeType->getCmsTreeTypeProperties();
        if (isset(self::$_contents[$this->content_id])) {
            $cmsContent = self::$_contents[$this->content_id];
        } else {
            self::$_contents[$this->content_id] = $this->cmsContent;
            $cmsContent = self::$_contents[$this->content_id];
        }
        return $cmsContent->getCmsContentProperties();
        //return $this->cmsContent->getCmsContentProperties();

        //return $this->cmsContent->getCmsContentProperties();

        /*$query = $this->cmsContent->getCmsContentProperties();
        $query->joinWith('cmsContentProperty2trees as map2trees')
            ->andWhere(['map2trees.cms_tree_id' => $this->treeIds])
        ;

        $query->groupBy(CmsContentProperty::tableName() . ".id");
        return $query;

        $query = CmsContentProperty::find()
            ->from(CmsContentProperty::tableName() . ' AS property')
            ->joinWith('cmsContentProperty2contents as map2contents')
            ->joinWith('cmsContentProperty2trees as map2trees')
            ->andWhere(['map2contents.cms_content_id' => $this->content_id])
            ->all()
        ;*/
    }
1369062
public static function toArray()
    {
        $reflectionClass = new \ReflectionClass(get_called_class());
        $parentRelectionClass = $reflectionClass->getParentClass();

        return array_diff(
            $reflectionClass->getConstants(),
            $parentRelectionClass->getConstants()
        );
    }
898749
public function resolve(): array
    {
        $modelRelationFetcher = $this->getRelationFetcher();

        if ($this->first !== null) {
            $modelRelationFetcher->loadRelationsForPage($this->first, $this->page);
        } else {
            $modelRelationFetcher->loadRelations();
        }

        return $modelRelationFetcher->getRelationDictionary($this->relationName);
    }
381627
protected static function define_other_properties() {
        return [
            'events' => [
                'type' => event_exporter::read_properties_definition(),
                'multiple' => true,
            ],
            'firstid' => [
                'type' => PARAM_INT,
                'null' => NULL_ALLOWED,
                'default' => null,
            ],
            'lastid' => [
                'type' => PARAM_INT,
                'null' => NULL_ALLOWED,
                'default' => null,
            ],
        ];
    }
1012345
public function getRelationMappingsWith(string $dependencyMode): array
    {
        $mappings = [];

        foreach ($this->getRelationMappings() as $mapping) {
            if ($mapping->getRelation()->getDependencyMode() === $dependencyMode) {
                $mappings[] = $mapping;
            }
        }

        return $mappings;
    }
645457
public function getPropertiesAsArray()
    {
        $array = array();

        foreach ($this->getProperties() as $property) {
            $array[$property->getName()] = [ 'value' => $property->getValue(), 'type' => $property->getType() ];
        }

        return $array;
    }
932994
public function getDependencies()
    {
        if (empty($this->dependencies)) {
            foreach ($this->getManifest()->getDependencies() as $id => $version) {
                $this->dependencies[$id] = $version;
                $dependence = $this->getExtensionManager()->getExtensionById($id);
                $this->dependencies = array_merge($this->dependencies, $dependence->getDependencies());
            }
        }
        return $this->dependencies;
    }
861903
protected function dependedRelations()
    {
        foreach ($this->relations as $relation) {
            if ($relation instanceof RelationInterface && !$relation->isLeading()) {
                yield $relation;
            }
        }
    }
15519
public function getDefAsArray()
    {
        return [
            'length'                => $this->definition->getLength(),
            'title'                 => $this->definition->getTitle(),
            'description'           => $this->definition->getDescription(),
            'readOnly'              => $this->definition->getReadOnly(),
            'hidden'                => $this->definition->getHidden(),
            'recordOriginException' => $this->definition->isRecordOriginException(),
            'required'              => $this->definition->getRequired(),
            'searchable'            => $this->definition->getSearchable(),
            'translatable'          => $this->definition->getTranslatable(),
            'collection'            => $this->definition->getCollection(),
            'groups'                => $this->definition->getGroups(),
            'restrictions'          => $this->definition->getRestrictions(),
            'onVariation'           => $this->definition->getOnVariation(),

            'name'                  => $this->getName(),
            'type'                  => $this->getType(),
            'exposedName'           => $this->getExposedName(),
            'doctrineType'          => $this->getTypeDoctrine(),
            'serializerType'        => $this->getTypeSerializer(),
            'xDynamicKey'           => $this->getXDynamicKey(),
            'relType'               => null,
            'isClassType'           => false,
            'constraints'           => array_map(
                [Utils\ConstraintNormalizer::class, 'normalize'],
                $this->definition->getConstraints()
            ),
        ];
    }