Gets the symmetrical relation

@return \Propel\Runtime\Map\RelationMap
18596
public function getSymmetricalRelation()
    {
        $localMapping = [$this->getLeftColumns(), $this->getRightColumns()];
        foreach ($this->getRightTable()->getRelations() as $relation) {
            if ($localMapping == [$relation->getRightColumns(), $relation->getLeftColumns()]) {
                return $relation;
            }
        }
    }
1275234
protected function guessInverseRelation()
    {
        $relation = Str::plural(class_basename($this->getParent()));

        return Str::camel($relation);
    }
395959
public function getRelativeOffset() {
		if($this->getParent()) {
			return $this->id - $this->getParent()->getID();
		}

		return $this->id;
	}
927229
public function getMap() {
        $return_collection = new \Doctrine\Common\Collections\ArrayCollection($this->getCoordinate()->filter(function ($coordinate) {
                    return get_class($coordinate) == "Haven\PersonaBundle\Entity\Map";
                })->getValues());

        return $return_collection;
    }
140403
public function getRelatedFields()
    {
        if (is_string($this->relation->toModel)) {
            throw new ValueError(
                sprintf(
                    'Related model "%s" cannot be resolved',
                    $this->relation->toModel
                )
            );
        }
        // owning side of a relation

        if (BaseOrm::RECURSIVE_RELATIONSHIP_CONSTANT == $this->fromField) {
            $this->fromField = $this;
        } elseif (is_string($this->fromField)) {
            $this->fromField = $this->scopeModel->getMeta()->getField($this->fromField);
        }

        //inverse side of a relation
        if (is_string($this->toField)) {
            $this->toField = $this->relation->toModel->getMeta()->getField($this->toField);
        } else {
            $this->toField = $this->relation->toModel->getMeta()->primaryKey;
        }

        return [$this->fromField, $this->toField];
    }
671377
public static function getMapping()
    {
        $instance = new static();

        $params = $instance->getBasicEsParams();

        return $instance->getElasticSearchClient()->indices()->getMapping($params);
    }
20025
public function getEntityMapping() {
        if (!$this->entityMapping) {
            $this->entityMapping = new EntityMapping($this->getMapping());
        }
        return $this->entityMapping;
    }
458772
final public function getRelations()
    {
        if ($this->relationsBuilt === false) {
            $tableMap = $this->getTableMap();
            $this->buildRelations($tableMap);
            $this->relationsBuilt = true;
        }

        return $this->relations;
    }
236569
public function getDiscriminatorMap()
    {
        $map = array();
        foreach ($this->blockManager->getValues() as $alias => $value) {
            $map[$alias] = $value->getEntity();
        }

        return $map;
    }
297597
protected function getRelations()
    {
        $relations = [];
        $rawRelations = $this->getRawRelations();
        foreach ($rawRelations as $rawRelation) {
            $relations[] = $this->getRealtion($rawRelation->foreignTable, $rawRelation->foreignKey, $rawRelation->localKey, $rawRelation->selfReferences);
        }

        return $relations;
    }
464397
public function getRelations()
    {
        if ($this->def->getTarget() === null) {
            return [];
        }

        $relations = [];
        foreach ($this->def->getTarget()->getRelations() as $relation) {
            $relations[$relation->getLocalProperty()] = $relation;
        }

        return $relations;
    }
106640
public function getMap()
    {
        $vertices = array();
        foreach ($this->vertices as $vertex) {
            $vertices[$vertex->getId()] = $vertex;
        }
        return $vertices;
    }
955654
public function getRelation($name)
    {
        if (array_key_exists($name, $this->relation_objects)) {
            return $this->relation_objects[$name];
        }

        $relation = self::getRelationDefinition($name);

        $this->relation_objects[$name] = $this->fetchRelation($relation);

        return $this->relation_objects[$name];
    }
807050
public function getRelations()
    {
        if (!isset($this->relationships)) {
            $this->relationships = array();
            // load them manually
            $mm = $this->getModelsManager();
            $relationships = $mm->getRelations(get_class($this));
            // Temporary fix because $mm->getRelations() doesn't support hasManyToMany relations right now.
            // get them separately and merge them
            $mtmRelationships = $mm->getHasManyToMany($this);

            $relationships = array_merge($relationships, $mtmRelationships);

            foreach ($relationships as $relation) {
                // todo load custom relationship
                $this->relationships[] = new Relation($relation, $mm);
            }
        }
        return $this->relationships;
    }
173366
public function getRelative(){
		$buffer	= array();
		if( $this->parts->path )
			$buffer[]	= ltrim( $this->parts->path, '/' );
		if( $this->parts->query )
			$buffer[]	= '?'.$this->parts->query;
		if( $this->parts->fragment )
			$buffer[]	= '#'.$this->parts->fragment;
		return join( '', $buffer );
	}
71095
public function getRelations()
    {
        $class = ucfirst('App\\'.ucfirst(Str::singular($this->name)));
        $query = call_user_func([$class, 'ordered']);

        if ($this->scope) {
            call_user_func($this->scope, $query);
        }

        return $query->get();
    }
1083255
public function getRelatedColumns()
    {
        //make sure we only run this once and then return the cached version
        if (empty($this->relatedColumns)) {
            foreach ($this->getColumns() as $column) {
                if ($column->getOption('is_related')) {
                    $this->relatedColumns[$column->getOption('column_name')] = $column->getOption('column_name');
                }
            }
        }

        return $this->relatedColumns;
    }