Get a relationship field

@param string $name
@return Field
968987
public function getRelationshipField($name)
    {
        return $this->getRelationshipFields()->filter(function($field) use ($name) {
            return $name === $field->getName();
        })->first();
    }
48926
protected function _getField($name)
    {
        return isset( $this->_response[$name] ) ? $this->_response[$name] : null;
    }
602998
protected function getDynamicRelationship($name)
    {
        // Dynamically get the relationship
        if ($this->isRelationship($name)) {
            // Use the relationship already loaded
            if (array_key_exists($name, $this->getRelations())) {
                return $this->getRelation($name);
            }

            // Load the relationship
            return $this->getRelationshipFromMethod($name, camel_case($name));
        }
    }
520005
public function getHasManyField($name)
    {
        $field = $this->getField($name);

        return $field instanceof HasManyField ? $field : null;
    }
1010340
public function getField($name)
    {
        if (isset($this->typeClasses[$name])) {
            return $this->inject(new $this->typeClasses[$name]);
        } else {
            throw new ParserException('Unknown field type: '.$name);
        }
    }
941043
function Field($name)
    {
        if (!array_key_exists($name, $this->fields))
            throw new \InvalidArgumentException($name . ' is not a valid field for '. $this->name);
        
        return $this->fields[$name];
    }
158731
public function field($name)
    {
        return isset($this->_properties['fields'][$name])?
            $this->_properties['fields'][$name]:null;
    }
858673
public function field($name)
  {
    return isset($this->fields[$name]) ? $this->fields[$name] : false;
  }
1369680
public function getRelation($name)
    {
        $preparedName = $this->prepareRelationName($name);

        if (!key_exists($preparedName, $this->relations)) {
            throw new InvalidParamException("Relation '$name' isn't exist");
        }


        if (!isset($this->_relations[$preparedName])) {
            $this->buildRelation($name);
        }

        return $this->_relations[$preparedName];
    }
930249
public function getField(string $name, $default = null, bool $filter = true)
    {
        if ($this->relations->has($name)) {
            return $this->relations->getRelated($name);
        }

        $this->assertField($name);

        return parent::getField($name, $default, $filter);
    }
238550
public function getChildRelationship($name)
    {
        return $this->getChildRelationships()->filter(function($input) use ($name) {
            return $name === $input->getRelationshipName();
        })->first();
    }
807632
public function getRelation($name)
    {
        if (!isset($this->relationships)) {
            $relations = $this->getRelations();
        } else {
            $relations = $this->relationships;
        }

        foreach ($relations as $relation) {
            if ($relation->getAlias() == $name) {
                return $relation;
            }
        }
        return false;
    }
512451
public function dataFieldByName($name)
    {
        if ($dataFields = $this->dataFields()) {
            foreach ($dataFields as $child) {
                if (trim($name) == trim($child->getName()) || $name == $child->id) {
                    return $child;
                }
            }
        }
        return null;
    }
1076069
public function getForeignField($name)
    {
        $field = $this->getField($name);

        return $field instanceof ForeignField ? $field : null;
    }
910566
public function makeRelationship($name)
	{
		// See if the relationship already exists
		if (!$this->getRelationship($name))
		{
			// Get the child rows/row and set them back on the model as a relationship for future use
			$rows = call_user_func_array(array($this, $name), array())->rows();
			$this->addRelationship($name, $rows);
		}

		return $this;
	}
262535
public function getNestedRelationships($name)
    {
        $pieces     = explode('.', $name);
        $models     = array();
        $num_pieces = sizeof($pieces);

        //iterate over the relationships to see if they're all valid
        foreach ($pieces as $i => $rel) {
            //if this is the first item, then the model is the config's model
            if ($i === 0) {
                $models[] = $this->config->getDataModel();
            }

            //if the model method doesn't exist for any of the pieces along the way, exit out
            if (!method_exists($models[$i], $rel) || !is_a($models[$i]->{$rel}(), self::BELONGS_TO)) {
                throw new \InvalidArgumentException("The '".$this->getOption('column_name')."' column in your ".$this->config->getOption('name').
                    " model configuration needs to be either a belongsTo relationship method name or a sequence of them connected with a '.'");
            }

            //we don't need the model of the last item
            $models[] = $models[$i]->{$rel}()->getRelated();
        }

        return array('models' => $models, 'pieces' => $pieces);
    }
1051490
protected function getField($name)
    {
        if (array_key_exists($name, $this->fields)) {
            return $this->fields[$name];
        } else {
            throw new FormatterException('Field not exists');
        }
    }