Artifact.SNAPSHOT_VERSION,
                    0,
                    Artifact.SNAPSHOT_VERSION.length())) {
                return true;
            } else {
                return Artifact.VERSION_FILE_PATTERN.matcher(version).matches();
            }
        }
        return false;
    }

    public static String toSnapshotVersion(String version) {

        final int c = command & 0xFF;
        // why isn't this just return batchLimits[c]?
        switch (c) {
        case SMB_COM_CHECK_DIRECTORY:
            return batchLimits[0];
        case SMB_COM_CREATE_DIRECTORY:
            return batchLimits[2];
        case SMB_COM_DELETE:
            return batchLimits[3];
        case SMB_COM_DELETE_DIRECTORY:
            return batchLimits[4];
        case SMB_COM_OPEN_ANDX:

    public String getName() {
        return this.filename;
    }

    @Override
    public int getType() {
        return SmbConstants.TYPE_FILESYSTEM;
    }

    /**
     * @return the fileIndex
     */
    @Override
    public int getFileIndex() {
        return this.fileIndex;
    }

    /**
     * Gets the filename.
     *
     * @return the filename
     */

                directoryCache.remove(directoryPath);
                return null;
            }
        }

        return entry;
    }

    /**
     * Check if directory listing can be cached
     *
     * @param directoryPath directory path
     * @return true if caching is allowed
     */
    public boolean canCacheDirectoryListing(String directoryPath) {

    @Override
    public RoleDbm asDBMeta() {
        return RoleDbm.getInstance();
    }

    @Override
    public String asTableDbName() {
        return "role";
    }

    @Override
    public boolean hasSpecifiedColumn() {
        return _specification != null;
    }

    @Override
    public ConditionQuery localCQ() {
        return doGetConditionQuery();
    }

    /**
     * Get buffer offset
     *
     * @return offset within registered buffer
     */
    public long getOffset() {
        return offset;
    }

    /**
     * Get RDMA token
     *
     * @return RDMA provider token
     */
    public int getToken() {
        return token;
    }

    /**
     * Get buffer length
     *
     * @return buffer length
     */
    public int getLength() {

     *
     * @return current connection state
     */
    public RdmaConnectionState getState() {
        return state;
    }

    /**
     * Get remote address
     *
     * @return remote socket address
     */
    public InetSocketAddress getRemoteAddress() {
        return remoteAddress;
    }

    /**
     * Get local address
     *
     * @return local socket address
     */

            }
            return entity;
        }).orElseGet(() -> {
            throwValidationErrorApi(messages -> messages.addErrorsCrudFailedToCreateInstance(GLOBAL));
            return null;
        });

        return asJson(new ApiUpdateResponse().id(keyMatch.getId()).created(true).status(Status.OK).result());
    }

    /**

     */
    @Override
    public Exception getException() {
        return this.exception;
    }

    /**
     *
     * @return error status code
     */
    @Override
    public final int getErrorCode() {
        return getStatus();
    }

    /**
     *
     * @return whether signature verification failed
     */
    @Override

	defer cancel()

	resp := lockRPCRefresh.NewResponse()
	refreshed, err := l.ll.Refresh(ctx, *args)
	if err != nil {
		return l.makeResp(resp, err)
	}
	if !refreshed {
		return l.makeResp(resp, errLockNotFound)
	}
	return l.makeResp(resp, err)
}

// LockHandler - Acquires a lock.
func (l *lockRESTServer) LockHandler(args *dsync.LockArgs) (*dsync.LockResp, *grid.RemoteErr) {