Sets the relationship type
557682
def _set_relationship_type(self, type_identifier, display_name=None, display_label=None, description=None, domain='Relationship'):
        """"""
        if display_name is None:
            display_name = type_identifier
        if display_label is None:
            display_label = display_name
        if description is None:
            description = 'Relationship Type for ' + display_name
        self._relationship_type = Type(authority='DLKIT',
                                       namespace='relationship.Relationship',
                                       identifier=type_identifier,
                                       display_name=display_name,
                                       display_label=display_label,
                                       description=description,
                                       domain=domain)
705923
public void modifyRelationship(Relationship relationship, String description, String technology) {
        if (relationship == null) {
            throw new IllegalArgumentException("A relationship must be specified.");
        }

        Relationship newRelationship = new Relationship(relationship.getSource(), relationship.getDestination(), description, technology, relationship.getInteractionStyle());
        if (!relationship.getSource().has(newRelationship)) {
            relationship.setDescription(description);
            relationship.setTechnology(technology);
        } else {
            throw new IllegalArgumentException("This relationship exists already: " + newRelationship);
        }
    }
451430
public function applyTypeSettings(): void{
        $settings = $this->getTypeSettings();
        $this->setTable($settings['table']);
        $this->setConnection($settings['connection']);
    }
55689
def setType(self, personID, typeID):
        
        self._connection._sendStringCmd(
            tc.CMD_SET_PERSON_VARIABLE, tc.VAR_TYPE, personID, typeID)
514823
public function setRelationship(string $name, AbstractRelationship $relationship)
    {
        if (isset($this->relationships[$name])) {
            throw new RelationshipOverrideException($this, $name);
        }

        $this->relationships[$name] = $relationship;
    }
1025177
public void setTypeResolver(RelationshipResolver resolver, Class<?> type) {
		if (resolver != null) {
			String typeName = ReflectionUtils.getTypeName(type);

			if (typeName != null) {
				typedResolvers.put(type, resolver);
			}
		}
	}
1077862
def set_property_type(self, property_types):
        
        query_add = ''
        for property_type in property_types:
            if not isinstance(property_type, PropertyType):
                raise DaftException("property_types should be an instance of PropertyType.")
            query_add += str(property_type)

        self._query_params += query_add
1261140
public void setTypes(com.google.api.ads.admanager.axis.v201902.LabelType[] types) {
        this.types = types;
    }
80319
protected function setRestrictionRelationship($relationship)
    {
        if (null !== $relationship) {
            $this->writeAttribute(
                $relationship,
                'restriction',
                'relationship',
                $this->validator,
                'validateRestrictionRelationship',
                $this->exception,
                'Provided restriction relationship is not a valid value.'
            );
        }

        return $this;
    }
1222998
private void setIndicesAndTypes() {

        DeleteByQueryRequest innerRequest = request.request();
        innerRequest.indices(query.getIndexArr());
        String[] typeArr = query.getTypeArr();
        if (typeArr!=null){
            innerRequest.getSearchRequest().types(typeArr);
        }
//		String[] typeArr = query.getTypeArr();
//		if (typeArr != null) {
//            request.set(typeArr);
//		}
	}
1279878
private void setIndicesAndTypes() {
        request.setIndices(query.getIndexArr());

        String[] typeArr = query.getTypeArr();
        if (typeArr != null) {
            request.setTypes(typeArr);
        }
    }
1181210
def set_relationships(module_names, module_ids, link_field_names, related_ids)
    login! unless logged_in?
    
    [module_names, module_ids, link_field_names, related_ids].each do |arg|
      raise ArgumentError, "argument must be an Array" unless arg.class == Array
    end
    
    json = <<-EOF
      {
        "session": "#{@sugar_session_id}",
        "module_names": "#{module_names.to_json}",
        "module_ids": #{module_ids.to_json},
        "link_field_names": #{link_field_names.to_json},
        "related_ids": #{related_ids.to_json}   
      }
    EOF
    json.gsub!(/^\s{6}/,'')
    send!(:set_relationships, json)
  end
808300
def addRelation(self, link):
        '''
        
        '''
        if isinstance(link, Relation):
            self.internalLinks.append(link)
        else:
            raise TypeError(
                'link Type should be InternalLink, not %s' % type(link))
1229377
public void addRelationshipToProcessTopic(final SpecTopic topic, final RelationshipType type) {
        final ProcessRelationship relationship = new ProcessRelationship(this, topic, type);
        topicTargetRelationships.add(relationship);
        relationships.add(relationship);
    }
1092948
def setType(self, poiID, poiType):
        
        self._connection._beginMessage(
            tc.CMD_SET_POI_VARIABLE, tc.VAR_TYPE, poiID, 1 + 4 + len(poiType))
        self._connection._packString(poiType)
        self._connection._sendExact()
601185
public void setDataType(String type)  {
        addField(ConfigureNodeFields.type, FormField.Type.text_single);
        setAnswer(ConfigureNodeFields.type.getFieldName(), type);
    }
592186
public void setType(String type) {
	property.setType(type);
	setDynamicAttribute(null, KeyConstants._type, type);
    }