Gets the relationshipType value for this AffiliateLocationFeedData.

@return relationshipType   * The relationship the chains have with the advertiser.
540291
public com.google.api.ads.adwords.axis.v201809.cm.RelationshipType getRelationshipType() {
        return relationshipType;
    }
1280379
public List<TargetRelationship> getPrerequisiteLevelRelationships() {
        final ArrayList<TargetRelationship> relationships = new ArrayList<TargetRelationship>();
        for (final TargetRelationship relationship : levelRelationships) {
            if (relationship.getType() == RelationshipType.PREREQUISITE) {
                relationships.add(relationship);
            }
        }
        return relationships;
    }
767371
public function getConnectionType($evaluate = true)
    {
        return ($evaluate && is_callable($this->connectedType))
            ? call_user_func($this->connectedType)
            : $this->connectedType;
    }
425929
public function getRelationships($type = null, $direction = null)
    {
        if (null === $direction) {
            $relationships = array_merge($this->inboundRelationships, $this->outboundRelationships);
        } else {
            $dir = strtoupper($direction);
            if (!in_array($direction, array('IN', 'OUT'))) {
                throw new \InvalidArgumentException(sprintf('The direction "%s" is not valid', $direction));
            }
            $relationships = ('IN' === $dir) ? $this->getInboundRelationships() : $this->getOutboundRelationships();
        }

        if (null === $type) {
            return $relationships;
        }

        $collection = array();
        foreach ($relationships as $rel) {
            if ($rel->getType() === $type) {
                $collection[] = $rel;
            }
        }

        return $collection;
    }
1085109
def get_relation_type(self, relation):
        
        route_values = {}
        if relation is not None:
            route_values['relation'] = self._serialize.url('relation', relation, 'str')
        response = self._send(http_method='GET',
                              location_id='f5d33bc9-5b49-4a3c-a9bd-f3cd46dd2165',
                              version='5.1-preview.2',
                              route_values=route_values)
        return self._deserialize('WorkItemRelationType', response)
128837
public Field getRelationshipLinksField(Class<?> clazz, String relationshipName) {
		return relationshipLinksFieldMap.get(clazz).get(relationshipName);
	}
593365
private function buildRelationshipGetters() {
        $buffer = '';
        foreach($this->getRelationships() as $relationship) {
            $field = $this->getField($relationship->getLocalColumn());
            if($relationship->isPlural()) {
                $method = new Object\Method();
                $method->setAccess('public');
                $method->setDescription('Gets the related ' . $relationship->getAlias());
                $method->setName('get' . ucfirst($relationship->getAlias()));
                $method->setReturnType('ResultSet|Child' . $relationship->getRemoteShortModel() . '[]');
                $parameter = new Object\Parameter();
                $parameter->setDescription('');
                $parameter->setName('parameters');
                $parameter->setDefaultValue('null');
                $parameter->setType('array');
                $method->addParameter($parameter);
                $method->setContent('return $this->getRelated(\'' . $relationship->getAlias() . '\', $parameters);');
                $this->getAbstractClass()->addMethod($method);

                $method = new Object\Method();
                $method->setAccess('public');
                $method->setDescription('Gets the count of related ' . $relationship->getAlias());
                $method->setName('count' . ucfirst($relationship->getAlias()));
                $method->setReturnType('int');
                $parameter = new Object\Parameter();
                $parameter->setDescription('');
                $parameter->setName('parameters');
                $parameter->setDefaultValue('null');
                $parameter->setType('array');
                $method->addParameter($parameter);
                $method->setContent('return $this->get' . ucfirst($relationship->getAlias()) . '($parameters)->count();');
                $this->getAbstractClass()->addMethod($method);
            } else {

                $method = new Object\Method();
                $method->setAccess('public');
                $method->setDescription('Gets the related ' . $relationship->getAlias());
                $method->setName('get' . ucfirst($relationship->getAlias()));
                if($this->getAbstractClass()->hasMethod($method->getName())) {
                    $method->setName('getRelated' . ucfirst($relationship->getAlias()));
                }
                $method->setReturnType('Child' . $relationship->getRemoteShortModel() . '|false');
                $method->setContent('return $this->getRelated(\'' . $relationship->getAlias() . '\');');
                $this->getAbstractClass()->addMethod($method);

                if($field->isNullable()) {
                    $method = new Object\Method();
                    $method->setAccess('public');
                    $method->setDescription('Checks if a relationship exists');
                    $method->setName('has' . ucfirst($relationship->getAlias()));
                    $method->setReturnType('bool');
                    $method->setContent('return !is_null($this->get' . ucfirst($relationship->getAlias()) . '());');
                    $this->getAbstractClass()->addMethod($method);
                }
            }
        }
        return $buffer;
    }
1188056
private NodeInterface getRelatedNode(boolean add) {

		T relatedNode = null;

		if ((currentObject != null) && (currentObject instanceof NodeInterface)) {

			NodeInterface localNode = (NodeInterface) currentObject;
			relatedNode = localNode.getProperty(sourceKey);
			
			if (relatedNode == null && add && sourceKey instanceof RelationProperty) {

				final RelationProperty relationProperty = (RelationProperty)sourceKey;
				final App app                           = StructrApp.getInstance();
				final Class<T> relatedType              = relationProperty.getTargetType();

				if (relatedType != null) {
					
					try {
						relatedNode = app.create(relatedType);
						relationProperty.addSingleElement(securityContext, localNode, relatedNode);

					} catch (FrameworkException fex) {

						logger.warn("", fex);
					}
					
				} else {
					
					logger.error("Related type was null for {}", currentObject);
				}
			}
		}

		return relatedNode;
	}
1077978
@Override
	public ObjectList getObjectRelationships(String repositoryId, String objectId, Boolean includeSubRelationshipTypes, RelationshipDirection relationshipDirection, String typeId, String filter, Boolean includeAllowableActions, BigInteger maxItems, BigInteger skipCount, ExtensionsData extension) {
		return relationshipService.getObjectRelationships(repositoryId, objectId, includeSubRelationshipTypes, relationshipDirection, typeId, filter, includeAllowableActions, maxItems, skipCount, extension);
	}
795609
void addRelationshipAttributeType(String attributeName, AtlasRelationshipType relationshipType) {
        List<AtlasRelationshipType> relationshipTypes = relationshipAttributesType.get(attributeName);

        if (relationshipTypes == null) {
            relationshipTypes = new ArrayList<>();
            relationshipAttributesType.put(attributeName, relationshipTypes);
        }

        relationshipTypes.add(relationshipType);
    }
241513
public List<TopicRelationship> getPrevTopicRelationships() {
        ArrayList<TopicRelationship> relationships = new ArrayList<TopicRelationship>();
        for (TopicRelationship relationship : topicRelationships) {
            if (relationship.getType() == RelationshipType.PREVIOUS) {
                relationships.add(relationship);
            }
        }
        for (TargetRelationship relationship : topicTargetRelationships) {
            if (relationship.getType() == RelationshipType.PREVIOUS) {
                relationships.add(new TopicRelationship(relationship.getPrimaryRelationship(), (SpecTopic) relationship.getSecondaryRelationship(),
                        relationship.getType()));
            }
        }
        return relationships;
    }
656335
public Relationship getEfferentRelationshipWith(Element element) {
        if (element == null) {
            return null;
        }

        for (Relationship relationship : relationships) {
            if (relationship.getDestination().equals(element)) {
                return relationship;
            }
        }

        return null;
    }
83932
public com.google.api.ads.adwords.axis.v201809.cm.FeedType getExtensionType() {
        return extensionType;
    }
87505
public function getPhpType()
    {
        if ($this->type === 'object') {
            if (is_null($this->getSubtype())) {
                throw new \InvalidArgumentException('Attribute ' . $this->getName() . ' on the entity ' . $this->getEntity()->getName() . ' is marked as an object but doesn\'t have a subtype');
            }

            if ($this->isEntitySubtype()) {
                return $this->getEntitySubtype()->getName();
            } else {
                return $this->getSubtype();
            }
        } elseif ($this->type === 'array' && null !== $this->getSubtype()) {
            if ($this->isEntitySubtype()) {
                return $this->getEntitySubtype()->getName() . '[]';
            } else {
                return $this->getSubtype() . '[]';
            }
        } else {
            if (is_null($this->getForeign())) {
                return self::$PHP_VARS[$this->getType()];
            } else {
                if ($this->getForeign() === 'OneToOne' || $this->getForeign() === 'ManyToOne' && !$this->getInverse()) {
                    return $this->getForeignEntity()->getName();
                } else {
                    return $this->getForeignEntity()->getName() . '[]|Collection';
                }
            }
        }
    }
539695
protected function getRelationTypeString($relationType)
    {
        $relationTypeList = [];

        if (RelationValue::COMMON & $relationType) {
            $relationTypeList[] = 'COMMON';
        }
        if (RelationValue::EMBED & $relationType) {
            $relationTypeList[] = 'EMBED';
        }
        if (RelationValue::LINK & $relationType) {
            $relationTypeList[] = 'LINK';
        }
        if (RelationValue::FIELD & $relationType) {
            $relationTypeList[] = 'ATTRIBUTE';
        }
        if (RelationValue::ASSET & $relationType) {
            $relationTypeList[] = 'ASSET';
        }

        if (empty($relationTypeList)) {
            throw new \Exception('Unknown relation type ' . $relationType . '.');
        }

        return implode(',', $relationTypeList);
    }
735139
private RelationType getRelationType(int type)
   {
      RelationType result;
      if (type > 0 && type < RELATION_TYPES.length)
      {
         result = RELATION_TYPES[type];
      }
      else
      {
         result = RelationType.FINISH_START;
      }
      return result;
   }
861208
public function getRelationshipType($to)
    {
        $map = $this->relationshipTypeMap;
        if (isset($map[$to])) {
            return $map[$to];
        }

        return false;
    }