Set this Entity after the passed in Entity in rank order.

@param assetToRankAfter The Entity that will come just before this Entity
in rank order.
188520
public void setBelow(T assetToRankAfter) {
        instance.rankBelow(asset, assetToRankAfter, rankAttribute);
        asset.save();
    }
129839
protected function setAfterSaveRoute()
    {
        parent::setAfterSaveRoute();

        if (is_array($this->afterSaveRouteUrl)) {
            if (isset($this->afterSaveRouteUrl['action'], $this->formData['gr2t_id_respondent_track']) &&
                    'index' !== $this->afterSaveRouteUrl['action']) {
                $this->afterSaveRouteUrl[\Gems_Model::RESPONDENT_TRACK] = $this->formData['gr2t_id_respondent_track'];
            }
        }
    }
925052
@Override
	public void cacheResult(
		CommerceAccountOrganizationRel commerceAccountOrganizationRel) {
		entityCache.putResult(CommerceAccountOrganizationRelModelImpl.ENTITY_CACHE_ENABLED,
			CommerceAccountOrganizationRelImpl.class,
			commerceAccountOrganizationRel.getPrimaryKey(),
			commerceAccountOrganizationRel);

		commerceAccountOrganizationRel.resetOriginalValues();
	}
524312
public void setOrdererProperties(String name, Properties properties) throws InvalidArgumentException {
        setNodeProperties("Orderer", name, orderers, properties);
    }
249314
public function setAssetsLoader(AssetsLoader $loader)
    {
        $this->assets_loader = $loader;
        $assets_db = $this->assets_loader->getAssets();
        if (!empty($assets_db)) {
            $_assets_package = Package::createFromAssetsLoader($this->assets_loader);
            foreach ($assets_db as $package=>$config) {
                if (!empty($config['views_path'])) {
                    $assets_package = clone $_assets_package;
                    $assets_package->loadFromArray($config);
                    foreach ($assets_package->getViewsPaths() as $path) {
                        $full_path = $assets_package->getFullPath($path);
                        if (@file_exists($full_path)) {
                            $this->setToView('setIncludePath', $full_path);
                        }
                    }
                }
            }
        }
        return $this;
    }
823642
public void setVendor( final CharSequence vendor) {
		if ( vendor != null) format.getHeader().createEntry( VENDOR, vendor);
	}
225252
public void setSortOrder(final java.lang.String sortOrder) {
        // when updating, make sure we store off the original so it may be
        // restored
        final String orig = (String) getStateHelper().get(PropertyKeys.origSortOrder);
        if (orig == null) {
            // do not call getSortOrder as it defaults to ascending, we want
            // null
            // if this is the first call and there is no previous value.
            getStateHelper().put(PropertyKeys.origSortOrder, getStateHelper().eval(PropertyKeys.sortOrder));
        }
        getStateHelper().put(PropertyKeys.sortOrder, sortOrder);
    }
1114434
public function markAssetAsIncluded($assetType, $assetHandle = false)
    {
        $list = AssetList::getInstance();
        if ($assetType && $assetHandle) {
            $asset = $list->getAsset($assetType, $assetHandle);
        } else {
            $assetGroup = $list->getAssetGroup($assetType);
        }

        if (isset($assetGroup)) {
            $this->providedAssetGroup->addGroup($assetGroup);
        } elseif (isset($asset)) {
            $ap = new AssetPointer($asset->getAssetType(), $asset->getAssetHandle());
            $this->providedAssetGroup->add($ap);
        } else {
            $ap = new AssetPointer($assetType, $assetHandle);
            $this->providedAssetGroupUnmatched[] = $ap;
        }
    }
246044
@Override
    public void afterCompletion(int status)
    {
        if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
            Tr.entry(tc, "afterCompletion : " + status + " : " + this);

        // JPA 5.9.1 Container Responsibilities
        // - After the JTA transaction has completed (either by transaction commit or rollback),
        // The container closes the entity manager by calling EntityManager.close. [39]
        //
        // [39] The container may choose to pool EntityManagers and instead of creating and
        // closing in each case acquire one from its pool and call clear() on it.

        // Note : em may be null now, if it was non-transactional.     d472866.1
        if (ivEm != null)
        {
            ivJpaEm.closeTxEntityManager(ivEm, ivPoolEM); // d510184
        }

        if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
            Tr.exit(tc, "afterCompletion");
    }
768819
public void setSuccessful(java.util.Collection<AssociationDescription> successful) {
        if (successful == null) {
            this.successful = null;
            return;
        }

        this.successful = new com.amazonaws.internal.SdkInternalList<AssociationDescription>(successful);
    }
699609
@Reference(service = EmbeddableWebSphereTransactionManager.class)
    protected void setTransactionManager(ServiceReference<EmbeddableWebSphereTransactionManager> ref) {
        tranMgrRef.setReference(ref);
    }
764136
public void setAssetEntryService(
		com.liferay.asset.kernel.service.AssetEntryService assetEntryService) {
		this.assetEntryService = assetEntryService;
	}
820913
private <I> void addConsideringOrder(Map<String, I> map, I newEntry) {
    for(Map.Entry<String, I> entry : map.entrySet()) {
      if(entry.getValue() instanceof MustBeAfter<?>) {
        final Class<? extends ClassLoaderPreMortemCleanUp>[] existingMustBeAfter = 
            ((MustBeAfter<ClassLoaderPreMortemCleanUp>)entry.getValue()).mustBeBeforeMe();
        for(Class<? extends ClassLoaderPreMortemCleanUp> clazz : existingMustBeAfter) {
          if(clazz.isAssignableFrom(newEntry.getClass())) { // Entry needs to be after new entry
            // TODO Resolve order automatically #51
            throw new IllegalStateException(clazz.getName() + " must be added after " + newEntry.getClass());
          }
        }
      }
    }
    
    map.put(newEntry.getClass().getName(), newEntry);
  }
1205392
public RedGBuilder<T> withDefaultValueStrategy(final DefaultValueStrategy strategy) {
        if (instance == null) {
            throw new IllegalStateException("Using the builder after build() was called is not allowed!");
        }
        instance.setDefaultValueStrategy(strategy);
        return this;
    }
562239
@Override
    public T add(NamedAsset namedAsset) {

        Validate.notNull(namedAsset, "No named asset was specified");

        return add(namedAsset, namedAsset.getName());

    }
765946
public void setProvider(com.google.api.ads.admanager.axis.v201811.GrpProvider provider) {
        this.provider = provider;
    }
1084860
public void setFontAssetDelegate(
      @SuppressWarnings("NullableProblems") FontAssetDelegate assetDelegate) {
    this.fontAssetDelegate = assetDelegate;
    if (fontAssetManager != null) {
      fontAssetManager.setDelegate(assetDelegate);
    }
  }