Set link to Freebase.  Note: Provided only for entities that exist in this
that exist in this linked data-set.

@param freebase link to Freebase
184270
public void setFreebase(String freebase) {
    if(freebase != null) {
      freebase = freebase.trim();
    }
    this.freebase = freebase;
  }
1367482
@Nonnull
  public final JettyStarter setResourceBase (@Nonnull @Nonempty final String sResourceBase)
  {
    ValueEnforcer.notEmpty (sResourceBase, "ResourceBase");
    return setResourceBase (_asRes (sResourceBase));
  }
747033
public HalResource setLink(String relation, Link link) {
    if (link == null) {
      return this;
    }
    return addResources(HalResourceType.LINKS, relation, false, new Link[] {
        link
    });
  }
799269
public void addDatabase(Database database)
    {
        this.getDatabaseList((database.getDatabaseType() & DBConstants.TABLE_MASK)).put(database.getDatabaseName(false), database);
    }
479391
public void setDatabase(String databaseKey) {

        m_databaseKey = databaseKey;
        String vfsDriver;
        String userDriver;
        String projectDriver;
        String historyDriver;
        String subscriptionDriver;
        String sqlManager;
        vfsDriver = getDbProperty(m_databaseKey + ".vfs.driver");
        userDriver = getDbProperty(m_databaseKey + ".user.driver");
        projectDriver = getDbProperty(m_databaseKey + ".project.driver");
        historyDriver = getDbProperty(m_databaseKey + ".history.driver");
        subscriptionDriver = getDbProperty(m_databaseKey + ".subscription.driver");
        sqlManager = getDbProperty(m_databaseKey + ".sqlmanager");
        // set the db properties
        setExtProperty("db.name", m_databaseKey);
        setExtProperty("db.vfs.driver", vfsDriver);
        setExtProperty("db.vfs.sqlmanager", sqlManager);
        setExtProperty("db.user.driver", userDriver);
        setExtProperty("db.user.sqlmanager", sqlManager);
        setExtProperty("db.project.driver", projectDriver);
        setExtProperty("db.project.sqlmanager", sqlManager);
        setExtProperty("db.history.driver", historyDriver);
        setExtProperty("db.history.sqlmanager", sqlManager);
        setExtProperty("db.subscription.driver", subscriptionDriver);
        setExtProperty("db.subscription.sqlmanager", sqlManager);
        Properties dbProps = getDatabaseProperties().get(databaseKey);
        String prefix = "additional.";
        String dbPropBlock = "";
        for (Map.Entry<Object, Object> entry : dbProps.entrySet()) {
            if (entry.getKey() instanceof String) {
                String key = (String)entry.getKey();
                if (key.startsWith(prefix)) {
                    key = key.substring(prefix.length());
                    String val = (String)(entry.getValue());
                    setExtProperty(key, val);
                    dbPropBlock += key + "=" + val + "\n";
                }
            }

        }
        if (!CmsStringUtil.isEmptyOrWhitespaceOnly(dbPropBlock)) {
            m_additionalProperties.put("dbprops", dbPropBlock);
        }
    }
935519
public void setAttributeUpdates(java.util.Collection<LinkAttributeUpdate> attributeUpdates) {
        if (attributeUpdates == null) {
            this.attributeUpdates = null;
            return;
        }

        this.attributeUpdates = new java.util.ArrayList<LinkAttributeUpdate>(attributeUpdates);
    }
1011929
@SuppressWarnings("unchecked")
	public T add(Link link) {

		Assert.notNull(link, "Link must not be null!");

		this.links.add(link);

		return (T) this;
	}
1000849
void setLink(Node node, Relation relation, Node childNode, NodeLink nodeLink)
    {
        nodeLink.setMultiplicity(relation.getType());

        EntityMetadata metadata = KunderaMetadataManager.getEntityMetadata(node.getPersistenceDelegator()
                .getKunderaMetadata(), node.getDataClass());
        nodeLink.setLinkProperties(getLinkProperties(metadata, relation, node.getPersistenceDelegator()
                .getKunderaMetadata()));

        // Add Parent node to this child
        childNode.addParentNode(nodeLink, node);

        // Add child node to this node
        node.addChildNode(nodeLink, childNode);
    }
517679
public void setCrunchbase(String crunchbase) {
    if(crunchbase != null) {
      crunchbase = crunchbase.trim();
    }
    this.crunchbase = crunchbase;
  }
720392
public final void setLink(Attributes attributes) {
        ptValues[GpxMetadata.PTLINK] = attributes.getValue(GPXTags.HREF);
    }
746457
protected void setEntityNavigationProperties(Object entity, StructuredType entityType) throws ODataException {
        for (Map.Entry<String, Object> entry : links.entrySet()) {
            String propertyName = entry.getKey();
            Object entryLinks = entry.getValue();
            LOG.debug("Found link for navigation property: {}", propertyName);

            StructuralProperty property = entityType.getStructuralProperty(propertyName);
            if (!(property instanceof NavigationProperty)) {
                throw new ODataUnmarshallingException("The request contains a navigation link '" + propertyName +
                        "' but the entity type '" + entityType + "' does not contain a navigation property " +
                        "with this name.");
            }

            // Note: The links are processed a bit differently depending on whether we are parsing in the context
            // of a 'write operation' or 'read operation'. Only in the case of a 'write operation' it is necessary
            // to resolve the referenced entity.
            if (isWriteOperation()) {
                // Get the referenced entity(es), but only with the key fields filled in
                if (entryLinks instanceof List) {
                    List<String> linksList = (List<String>) entryLinks;
                    for (String link : linksList) {
                        Object referencedEntity = getReferencedEntity(link, propertyName);
                        LOG.debug("Referenced entity: {}", referencedEntity);
                        saveReferencedEntity(entity, propertyName, property, referencedEntity);
                    }
                } else {
                    Object referencedEntity = getReferencedEntity((String) entryLinks, propertyName);
                    LOG.debug("Referenced entity: {}", referencedEntity);
                    saveReferencedEntity(entity, propertyName, property, referencedEntity);
                }
            }
        }
    }
295812
private LinkDatabase makeLinkDatabase(Properties props) {
    String dbtype = get(props, "duke.linkdbtype");
    if (dbtype.equals("jdbc"))
      return makeJDBCLinkDatabase(props);
    else if (dbtype.equals("jndi"))
      return makeJNDILinkDatabase(props);
    else
      throw new DukeConfigException("Unknown link database type '" + dbtype +
                                    "'");
  }
1302481
private void deleteFreeLink(int index)
    {
        this.base.set(-this.check.get(index), this.base.get(index));
        this.check.set(-this.base.get(index), this.check.get(index));
    }
990286
public void addLinkValue(String ownerObjID, FieldDefinition linkDef, String targetObjID) {
        addColumn(SpiderService.objectsStoreName(linkDef.getTableDef()),
                  ownerObjID,
                  SpiderService.linkColumnName(linkDef, targetObjID));
    }
776592
public void setLinkedId(Long i) {
        if ((i == null) || (i < -128 || i > 127)) {
            throw new IllegalArgumentException("Invoke ID our of range: <-128,127>: " + i);
        }
        this.linkedId = i;
    }
56241
public void setUrl(final String url) {
		String currUrl = getUrl();

		if (!Objects.equals(url, currUrl)) {
			getOrCreateComponentModel().url = url;
		}
	}
775875
public final Page setBase(String target, String href)
    {
        base="<base " +
            ((target!=null)?("TARGET=\""+target+"\""):"") +
            ((href!=null)?("HREF=\""+href+"\""):"") +
            ">";
        return this;
    }