Java ParameterCheck.mandatoryString方法代码示例

import org.springframework.extensions.surf.util.ParameterCheck; //导入方法依赖的package包/类
private ScriptNode transformImage(String mimetype, final String options, NodeRef destination)
{
    ParameterCheck.mandatoryString("Mimetype", mimetype);
    final NodeRef sourceNodeRef = nodeRef;
    
    // the delegate definition for transforming an image
    Transformer transformer = new AbstractTransformer()
    {
        protected void doTransform(ContentService contentService,
            ContentReader reader, ContentWriter writer)
        {
            ImageTransformationOptions imageOptions = new ImageTransformationOptions();
            imageOptions.setSourceNodeRef(sourceNodeRef);

            if (options != null)
            {
                imageOptions.setCommandOptions(options);
            }
            contentService.getImageTransformer().transform(reader, writer, imageOptions);
        }
    };
    
    return transformNode(transformer, mimetype, destination);
}
 

import org.springframework.extensions.surf.util.ParameterCheck; //导入方法依赖的package包/类
/**
 * @see org.alfresco.service.cmr.site.SiteService#getContainer(java.lang.String, String)
 */
public NodeRef getContainer(String shortName, String componentId)
{
    ParameterCheck.mandatoryString("componentId", componentId);

    // retrieve site
    NodeRef siteNodeRef = getSiteNodeRef(shortName);
    if (siteNodeRef == null)
    {
       throw new SiteDoesNotExistException(shortName);
    }

    // retrieve component folder within site
    // NOTE: component id is used for folder name
    NodeRef containerNodeRef = null;
    try
    {
        containerNodeRef = findContainer(siteNodeRef, componentId);
    } 
    catch (FileNotFoundException e)
    {
        //NOOP
    }

    return containerNodeRef;
}
 

import org.springframework.extensions.surf.util.ParameterCheck; //导入方法依赖的package包/类
/**
 * Re-sets the type of the node. Can be called in order specialise a node to a sub-type. This should be used
 * with caution since calling it changes the type of the node and thus* implies a different set of aspects,
 * properties and associations. It is the responsibility of the caller to ensure that the node is in a
 * approriate state after changing the type.
 * 
 * @param type Type to specialize the node
 * 
 * @return true if successful, false otherwise
 */
public boolean specializeType(String type)
{
    ParameterCheck.mandatoryString("Type", type);
    
    QName qnameType = createQName(type);
    
    // Ensure that we are performing a specialise
    if (getQNameType().equals(qnameType) == false &&
            this.services.getDictionaryService().isSubClass(qnameType, getQNameType()) == true)
    {
        // Specialise the type of the node
        this.nodeService.setType(this.nodeRef, qnameType);
        this.type = qnameType;
        
        return true;
    }
    return false;
}
 

import org.springframework.extensions.surf.util.ParameterCheck; //导入方法依赖的package包/类
public List<FeedControl> getFeedControls(String userId)
{
    ParameterCheck.mandatoryString("userId", userId);
    
    if (! userNamesAreCaseSensitive)
    {
        userId = userId.toLowerCase();
    }
    
    String currentUser = getCurrentUser();
    
    if ((currentUser == null) || 
        (! ((authorityService.isAdminAuthority(currentUser)) ||
            (currentUser.equals(userId)) ||
            (AuthenticationUtil.getSystemUserName().equals(this.tenantService.getBaseNameUser(currentUser))))))
    {
        throw new AlfrescoRuntimeException("Current user " + currentUser + " is not permitted to get feed controls for " + userId);
    }
    
    return getFeedControlsImpl(userId);
}
 

import org.springframework.extensions.surf.util.ParameterCheck; //导入方法依赖的package包/类
@Override
public TenantEntity createTenant(TenantEntity entity)
{
    ParameterCheck.mandatory("entity", entity);
    ParameterCheck.mandatoryString("entity.tenantDomain", entity.getTenantDomain());
    
    if (entity.getEnabled() == null)
    {
        entity.setEnabled(true);
    }
    
    // force lower-case on create
    entity.setTenantDomain(entity.getTenantDomain().toLowerCase());
    
    entity.setVersion(0L);
    
    Pair<String, TenantEntity> entityPair = tenantEntityCache.getOrCreateByValue(entity);
    return entityPair.getSecond();
}
 

import org.springframework.extensions.surf.util.ParameterCheck; //导入方法依赖的package包/类
/**
 * Gets the Group given the group name
 * 
 * @param groupName  name of group to get
 * @return  the group node (type usr:authorityContainer) or null if no such group exists
 */
public ScriptNode getGroup(String groupName)
{
    ParameterCheck.mandatoryString("GroupName", groupName);
    ScriptNode group = null;
    NodeRef groupRef = authorityDAO.getAuthorityNodeRefOrNull(groupName);
    if (groupRef != null)
    {
        group = new ScriptNode(groupRef, services, getScope());
    }
    return group;
}
 

import org.springframework.extensions.surf.util.ParameterCheck; //导入方法依赖的package包/类
/**
 * Remove a permission for ALL user from the node.
 * 
 * @param permission Permission to remove @see org.alfresco.service.cmr.security.PermissionService
 */
public void removePermission(String permission)
{
    ParameterCheck.mandatoryString("Permission Name", permission);
    this.services.getPermissionService().deletePermission(
            this.nodeRef, PermissionService.ALL_AUTHORITIES, permission);
}
 

import org.springframework.extensions.surf.util.ParameterCheck; //导入方法依赖的package包/类
private List<FeedControl> getFeedControlsImpl(String userId)
{
    ParameterCheck.mandatoryString("userId", userId);
    
    if (!userNamesAreCaseSensitive)
    {
        userId = userId.toLowerCase();
    }
    
    try
    {
        List<FeedControlEntity> feedControlDaos = feedControlDAO.selectFeedControls(userId);
        if (logger.isDebugEnabled())
        {
            logger.debug("Selecting feed controls for userId: " + userId);
        }
        List<FeedControl> feedControls = new ArrayList<FeedControl>(feedControlDaos.size());
        for (FeedControlEntity feedControlDao : feedControlDaos)
        {
            FeedControl feedCtrl = feedControlDao.getFeedControl();
            feedControls.add(feedCtrl);
            if (logger.isDebugEnabled())
            {
                logger.debug("Found feed control for userId: " + userId + ",\n appToolId : " + feedCtrl.getAppToolId() + ",\n siteId: " + feedCtrl.getSiteId());
            }
        }
        
        return feedControls;
    }
    catch (SQLException e) 
    {
        AlfrescoRuntimeException are = new AlfrescoRuntimeException("Failed to get feed controls: " + e, e);
        logger.error(are);
        throw are;
    }
}
 

import org.springframework.extensions.surf.util.ParameterCheck; //导入方法依赖的package包/类
/**
 * Apply a permission for the specified authority (e.g. username or group) to the node.
 * 
 * @param permission Permission to apply @see org.alfresco.service.cmr.security.PermissionService
 * @param authority Authority (generally a username or group name) to apply the permission for
 */
public void setPermission(String permission, String authority)
{
    ParameterCheck.mandatoryString("Permission Name", permission);
    ParameterCheck.mandatoryString("Authority", authority);
    this.services.getPermissionService().setPermission(
            this.nodeRef, authority, permission, true);
}
 

import org.springframework.extensions.surf.util.ParameterCheck; //导入方法依赖的package包/类
/**
 * Create an association between this node and the specified target node.
 * 
 * Beware: Any unsaved property changes will be lost when this is called.  To preserve property changes call {@link #save()} first.
 *     
 * @param target        Destination node for the association
 * @param assocType     Association type qname (short form or fully qualified)
 */
public Association createAssociation(ScriptNode target, String assocType)
{
    ParameterCheck.mandatory("Target", target);
    ParameterCheck.mandatoryString("Association Type Name", assocType);
    
    AssociationRef assocRef = this.nodeService.createAssociation(this.nodeRef, target.nodeRef, createQName(assocType));
    reset();
    return new Association(this.services, assocRef);
}
 

import org.springframework.extensions.surf.util.ParameterCheck; //导入方法依赖的package包/类
/**
 * Create a new folder (cm:folder) node as a child of this node.
 * 
 * Beware: Any unsaved property changes will be lost when this is called.  To preserve property changes call {@link #save()} first.
 *    
 * @param name Name of the folder to create
 * @param type Type of the folder to create (if null, defaults to ContentModel.TYPE_FOLDER)
 * 
 * @return Newly created Node or null if failed to create.
 */
public ScriptNode createFolder(String name, String type)
{
    ParameterCheck.mandatoryString("Node Name", name);
    
    FileInfo fileInfo = this.services.getFileFolderService().create(
            this.nodeRef, name, type == null ? ContentModel.TYPE_FOLDER : createQName(type));
    
    reset();
    
    return newInstance(fileInfo.getNodeRef(), this.services, this.scope);
}
 

import org.springframework.extensions.surf.util.ParameterCheck; //导入方法依赖的package包/类
/**
 * @deprecated use version with extra sourceSize parameter.
 */
public boolean isTransformable(String sourceMimetype, String targetMimetype, TransformationOptions options)
{
    ParameterCheck.mandatoryString("sourceMimetype", sourceMimetype);
    ParameterCheck.mandatoryString("targetMimetype", targetMimetype);
    
    double reliability = getReliability(sourceMimetype, targetMimetype);
    boolean result = true;
    if (reliability <= 0.0)
    {
        result = false;
    }
    return result;
}
 

import org.springframework.extensions.surf.util.ParameterCheck; //导入方法依赖的package包/类
/**
 * Sets the path within the store.  This must start with <b>/</b> at least.
 * 
 * @param path
 *            the path within the store
 */
public void setRootPath(String path)
{
    PropertyCheck.mandatory(this, "path", path);
    ParameterCheck.mandatoryString("path", path);
    if (!path.startsWith("/"))
    {
        throw new IllegalArgumentException("Propety 'path' must start with '/' - it is a path relative to the store root.");
    }
    this.rootPath = path;
}
 

import org.springframework.extensions.surf.util.ParameterCheck; //导入方法依赖的package包/类
/**
 * Remove aspect from the node.
 * 
 * Beware: Any unsaved property changes will be lost when this is called.  To preserve property changes call {@link #save()} first.
 *    
 * @param type  the aspect type
 * 
 * @return      true if successful, false otherwise
 */
public boolean removeAspect(String type)
{
    ParameterCheck.mandatoryString("Aspect Type", type);
    
    QName aspectQName = createQName(type);
    this.nodeService.removeAspect(this.nodeRef, aspectQName);
    
    // reset the relevant cached node members
    reset();
    
    return true;
}
 

import org.springframework.extensions.surf.util.ParameterCheck; //导入方法依赖的package包/类
private void initModelDiff(QName elementName, String elementType, String diffType)
{
    // Check that all the passed values are not null        
    ParameterCheck.mandatory("elementName", elementName);
    ParameterCheck.mandatoryString("elementType", elementType);
    ParameterCheck.mandatoryString("diffType", diffType);

    if ((!elementType.equals(TYPE_TYPE)) &&
        (!elementType.equals(TYPE_ASPECT)) &&
        (!elementType.equals(TYPE_DEFAULT_ASPECT)) &&
        (!elementType.equals(TYPE_PROPERTY)) &&
        (!elementType.equals(TYPE_ASSOCIATION)) &&
        (!elementType.equals(TYPE_CONSTRAINT)) &&
        (!elementType.equals(TYPE_NAMESPACE))
        )
    {
        throw new AlfrescoRuntimeException(ERR_UNKNOWN_ELEMENT_TYPE, new Object[] { elementType });
    }

    if ((! diffType.equals(DIFF_CREATED)) &&
        (! diffType.equals(DIFF_UPDATED)) &&
        (! diffType.equals(DIFF_UPDATED_INC)) &&
        (! diffType.equals(DIFF_DELETED)) &&
        (! diffType.equals(DIFF_UNCHANGED)))
    {
        throw new AlfrescoRuntimeException(ERR_UNKNOWN_DIFF_TYPE, new Object[] { diffType });
    }
   
    this.elementName = elementName;
    this.elementType = elementType;
    this.diffType = diffType;
}